Lab 2 3° Semestre

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Utilizando la Siguiente estructura (lista doblemente enlazada circular):

typedef struct Node{
    void* data;
    struct Node* next;
    struct Node* prev;
} node;

typedef struct{
    node* first; //puntero al primer elemento
    node* current;
}Lista;

Cree la Función Lista* createList() la cual retorna una instancia del tipo de dato Lista con sus valores inicializados.
_______________________________________________________________________________________________________________________________________
Lista* createList(){
Lista* L;

L = (Lista*) malloc (sizeof(Lista));

L->first = NULL;
L->current = NULL;

return L;
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Cree las funciones void* first(Lista* list) y void* next(Lista *list) las cuales retornan un puntero al primer dato de la lista y un puntero al dato que está a continuación del nodo current respectivamente.

Recuerde actualizar la ubicación del current en cada caso.
_______________________________________________________________________________________________________________________________________
void* first(Lista* list){

list->current = list->first;

return list->current->data;
}

void* next(Lista *list){

list->current = list->current->next;

return list->current->data;
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Cree las funciones void pushBack(Lista* list, void* data),  la cual agrega un nodo al final de la lista.

Puede utilizar la función node* _createNode(void* data)  la cual crea, inicializa y retorna un nuevo nodo.
_______________________________________________________________________________________________________________________________________
void pushBack(Lista* list, void* data){

    node* nodo = _createNode(data);
    node* nodoaux = _createNode(data);

    if(list->first == NULL){
        list->first = nodo;       //Se le asigna al primer node El "nodo"
        list->first->next = nodo; //Se le asigna al nodo que esta después del primero El "nodo";
        list->first->prev = nodo; //Se le asigna al que viene antes del primero El "nodo"
    }else{
        nodoaux = list->first->prev; //Se le asigna a "nodeaux" el nodo que viene antes del "primer nodo"
        list->first->prev = nodo;    //Se le asigna "nodo" al nodo que viene "antes del primer nodo"
        nodo->prev = nodoaux;        //Se le asigna "nodoaux" al nodo que esta "antes de nodo"
        nodo->next = list->first;    //Se le asigna el "primer nodo" al nodo que esta "después del nodo"
        nodoaux->next = nodo;        //Se le asigna "nodo" al nodo que viene "después de nodoaux"
    }
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Cree la Función void pushFront(Lista* L, void* dato) la cual agrega un dato al inicio de la lista.

Puede utilizar la función node* _createNode(void *data) la cual crea, inicializa y retorna un nuevo nodo inicializado.
_______________________________________________________________________________________________________________________________________
void pushFront(Lista* L, void* dato) {
node* nodo= _createNode(dato);

    if(L->first == NULL){
        nodo->next = nodo;
        nodo->prev = nodo;
        L->first = nodo;
    }else{
        nodo->next = L->first;
        nodo->prev = L->first->prev;
        L->first->prev->next = nodo;
        L->first->prev = nodo;
        L->first = nodo;
    }
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Enunciado de la pregunta
Cree la función void popCurrent(Lista* list), la cual elimina el nodo que está en la posición current de la lista.
_______________________________________________________________________________________________________________________________________
void popCurrent(Lista* list){

if(list->current->prev != NULL){
    list->current->prev->next = list->current->next;
}else{
    list->first = list->current->next;
}
if(list->current->next!= NULL)
    list->current->next->prev =list->current->prev;
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Cree la función void clean(Lista* L); la cual vacía la lista L por completo.

Sugerencia: Use las función void popFront(Lista* list) para eliminar los elementos de la lista.
_______________________________________________________________________________________________________________________________________
 void clean(Lista* L){
     while(L->current != NULL){
         popFront(L);
     }
 }
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Usando las operaciones del TDA Lista:

    Lista* createList(); //crea y retorna una nueva lista
    void* first(Lista* L); // Retorna un puntero al primer dato de la lista
    void* next(Lista* L);  // Retorna el dato que viene después del current
    void* last(Lista* L); // Retorna un puntero al último dato de la lista
    void* prev(Lista* L); // Retorna el dato anterior al current
    void pushFront(Lista* L, void* dato); //Inserta al comienzo
    void pushBack(Lista* L, void* dato);  //Inserta al final
    void pushCurrent(Lista* L, int* dato);  //Inserta el dato después del current
    void popFront(Lista* L);  //Elimina del comienzo
    void popBack(Lista* L);  //Elimina del final
    void popCurrent(Lista* L);  //Elimina el dato apuntado por current

Cree una lista con los números entre el 1 y el 15.

Imprima los impares de manera decreciente.
Imprima los pares de manera ascendente.

Imprima en pantalla el resultado de la suma de todos los pares multiplicado por la resta de todos los impares.

Se espera el siguiente resultado:

15 13 11 9 7 5 3 1
2 4 6 8 10 12 14
-1904
_______________________________________________________________________________________________________________________________________
Lista* list= createList();
    int i;

    for(i=1; i<=15;i++){
        int* j=(int*) malloc (sizeof(int));
        *j=i;
        pushBack(list,j);
    }

    int* aux= first(list);
    int* aux2= first(list);
    int* suma= (int*) calloc (1,sizeof(int));
    int* resta= (int*) calloc(1,sizeof(int));
    int* multi= (int*) calloc(1,sizeof(int));

    aux= last(list);
    aux2= last(list);

    do{
        if(*aux % 2 != 0)
            printf("%d ", *aux);
        aux=prev(list);
    }while(*aux != *aux2);

    printf("\n");

    aux  = first(list);
    aux2 = first(list);

    do{
        if(*aux % 2 == 0)
        printf("%d ", *aux);
        aux = next(list);
    }while(*aux != *aux2);

    printf("\n");

    do{
        if(*aux % 2 == 0){
            *suma = *suma + *aux;
        }else{
            *resta = *resta - *aux;
        }
        aux = next(list);
    }while(*aux != *aux2);

    *multi = (*suma)*(*resta+30);
    printf("%d",*multi);
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////