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

struct nodoLista {
    int valore;
    struct nodoLista *nextPtr;
};

typedef struct nodoLista Lista;

// Prototipi
void suf_insert(Lista **ptrPtr, int val);
void print_list(Lista *ptr);
void purga_dispari(Lista **ptrPtr);

int main() {
    Lista *mia_lista = NULL;
    
    // Inseriamo un po' di numeri mistic (Nota: il 5 e il 7 sono dispari consecutivi!)
    suf_insert(&mia_lista, 5);
    suf_insert(&mia_lista, 12);
    suf_insert(&mia_lista, 7);
    suf_insert(&mia_lista, 9);
    suf_insert(&mia_lista, 22);
    suf_insert(&mia_lista, 4);
    
    printf("Lista Originale (Atteso: 5 12 7 9 22 4):\n");
    print_list(mia_lista);
    
    // Chiamata alla tua funzione killer
    purga_dispari(&mia_lista);
    
    printf("Lista dopo la purga (Atteso: 12 22 4):\n");
    print_list(mia_lista);
    
    return 0;
}

// Funzione fornita dal professore
void suf_insert(Lista **ptrPtr, int val) {
    while(*ptrPtr != NULL) {
        ptrPtr = &((*ptrPtr)->nextPtr);
    }
    Lista *tmp = (Lista *)malloc(sizeof(Lista));
    tmp->valore = val;
    tmp->nextPtr = NULL;
    *ptrPtr = tmp;
}

void print_list(Lista *ptr) {
    while(ptr != NULL) {
        printf("%d ", ptr->valore);
        ptr = ptr->nextPtr;
    }
    printf("\n");
}

/* ========================================================================= */
/* ESERCIZIO DELLO STUDENTE                                                  */
/* ========================================================================= */

/* PRE:  'ptrPtr' è l'indirizzo della testa della lista (che può essere modificata).
 * POST: Tutti i nodi con valore dispari vengono scollegati e la loro memoria
 * liberata con free(). La lista risultante contiene solo numeri pari.
 */
void purga_dispari(Lista **ptrPtr) {
    // Caso Base: fine della lista
    if (*ptrPtr == NULL) {
        return;
    }

    if ((*ptrPtr)->valore % 2 != 0) {
        // Trovato un dispari: preparo la distruzione
        Lista *da_cancellare = *ptrPtr;
        // Scavalco
        *ptrPtr = (*ptrPtr)->nextPtr;
        // Distruggo
        free(da_cancellare);
        
        // Chiamata ricorsiva SULLO STESSO PUNTO (perché il nodo successivo è "scivolato" qui)
        purga_dispari(ptrPtr);
        
    } else {
        // È pari: va tutto bene, avanzo la ricorsione al prossimo nodo
        purga_dispari(&((*ptrPtr)->nextPtr));
    }
}