Nan Mihai - Lab SD

#include <stdio.h>
#include <stdlib.h>

typedef struct Element
{
    struct Element* prev;
    int data;
    struct Element* next;
}Element;

typedef struct Element* List;

List init(int data)
{
    List nou;
    nou = (Element *) malloc(sizeof(Element));
    nou->prev = NULL;
    nou->data = data;
    nou->next = NULL;
    return nou;
}

void printList(List l)
{
    if(l == NULL)
    {
        printf("Lista este vida!");
    }
    else
    {
        while(l != NULL)
        {
            printf("%d ", l->data);
            l = l->next;
        }
    }
    printf("\n");
}

List addFirst(List l, int data)
{
    List nou;
    if(l != NULL)
    {
        nou = (Element *) malloc(sizeof(Element));
        nou->prev = NULL;
        nou->next = l;
        nou->data = data;
        l = nou;
    }
    else
    {
        l = (Element *) malloc(sizeof(Element));
        l->prev = NULL;
        l->data = data;
        l->next = NULL;
        //Sau folosind functia init
    }
    return l;
}

List addLast(List l, int val)
{
    List nou, temp;
    if (l==NULL)
    {
        l->prev = NULL;
        l->data = val;
        l->next = NULL;
    }
    else
    {
        nou=(Element *)malloc(sizeof(Element));
        temp=l;
        while(temp->next!=NULL)
            temp=temp->next;
        nou->data=val;
        nou->next=NULL;
        nou->prev=temp;
        temp->next=nou;
    }
    return l;
}

List freeList(List l)
{
    List temp;
    if(l == NULL)
    {
        return NULL;
    }
    else
    {
        temp = l;
        while(l != NULL)
        {
            temp = l;
            l = l->next;
            free(temp);
        }
        return NULL;
    }
}

List delFirst(List l)
{
    if(l == NULL)
        return NULL;
    else
    {
        List nou;
        nou = l->next;
        free(l);
        l = nou;
        if(l != NULL)
        {
            l->prev = NULL;
        }
    }
    return l;
}

List delLast(List l)
{
    List temp, tmp;
    tmp = l;
    while(tmp->next != NULL)
    {
        tmp = tmp->next;
    }
    tmp->prev->next = NULL;
    free(tmp->next);
    return l;
}


List delODD(List l)
{
    List temp, tmp, x;
    tmp = l;
    if(l == NULL)
    {
        return NULL;
    }
    else
    {
        while(tmp != NULL)
        {
            if(tmp->data%2 == 1)
            {
                if(tmp->prev == NULL)
                {
                    tmp = delFirst(tmp);
                }
                else
                if(tmp->next == NULL)
                {
                    tmp = delLast(tmp);
                }
                else
                {
                    tmp->next->prev = tmp->prev;
                    tmp->prev->next = tmp->next;
                    free(tmp);
                }
            }
            tmp = tmp->next;
        }
    }
    return l;
}

List insertMean(List l)
{
    List nou, temp, x, p;
    p = l;
    int media;
    temp = l;
    if(l == NULL)
        return NULL;
    else
    if(l->next == NULL)
        return l;
    else
        while(temp->next != NULL)
        {
            media = (temp->data + temp->next->data) / 2;
            x = init(media);
            x->next = temp->next;
            x->prev = temp;
            temp->next->prev = x;
            temp->next = x;
            temp = temp->next->next;
        }
    return p;
}

/*
List reverse(List list)
{
    List m;

    if(list == NULL && list->next == NULL)
        return list;

    m = reverse( list->next );
    list->next->next = list;
    list->next = NULL;

    return m;
}
*/

int ultimul_element(List l)
{
    while(l != NULL)
    {
        l = l->next;
    }
    return l->data;
}

List reverse(List l)
{
    int ultim, ok;
    List tmp;
    ok = 0;
    if(l == NULL)
        return NULL;
    else
    {
        while(l != NULL)
        {
            if(ok == 0)
            {
                ultim = ultimul_element(l);
                tmp = (Element *) malloc(sizeof(Element));
                tmp->prev = NULL;
                tmp->next = NULL;
                tmp->data = ultim;
                l = delLast(l);
            }
            else
            {
                ultim = ultimul_element(l);
                tmp = addLast(tmp, ultim);
                l = delLast(l);
            }
            ok == 1;
        }
        return tmp;
    }
}


/*void swap(List *p, List *q) {
    List temp = *p;
    *p = *q;
    *q = temp;
}

List reverse(List l) {
    List *p;
    if (p == NULL)
        return p;
    swap(&(p->next), &(p->prev));
        if (p->prev == NULL)
        return p;
        return reverse(p->prev);
} */

int main()
{
    List l;
    l = init(6);
    printList(l);
    printf("Adaugare la inceput\n");
    l = addFirst(l, 10);
    printList(l);
    printf("Adaugare la sfarsit!\n");
    l = addLast(l, 11);
    l = addLast(l, 50);
    l = addLast(l, 199);
    l = addLast(l, 24);
    l = addLast(l, 23);
    l = addLast(l, 26);
    l = addLast(l, 27);
    printList(l);
    printf("Sterge elemente impare din lista\n");
    l = delODD(l);
    printList(l);
    printf("Inserare medie\n");
    l = insertMean(l);
    printList(l);
    printf("Golire memorie uzitata pentru lista!\n");
    l = freeList(l);
    printList(l);
    return 0;
}