C/C++ - Cancellazione Lista Linkata

Ciao a tutti, sto provando a implementare le funzioni di una lista linkata, però non so come procedere con la funzione di cancellazione di tutta la lista(void destroy(element * h) ), spero che voi possiate aiutarmi grazie in anticipo!!

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

struct element {
	int info; 		   /* valore dell’elemento */
	struct element* next;  /* indirizzo del prossimo elemento */
};

typedef struct element element;	//consente di usare il tipo element come sinonimo del tipo struct element.

element* insert(element* list, int n);
element* find(element* list, int n);
void print_list(element* h);
element* delete(element* h, int n);

void destroy(element* h);

int conta; // variabile globale

int main (void){
	char c;
	int n, count=0;
	element* head;
	element* prova;
	head= NULL;
	prova= NULL;
	
	
	while( ( c = getchar ()) != 'f' ){  	/* c e’ il prossimo carattere letto da standard input Il ciclo termina quando c e’ il carattere ’f’ */
		switch(c){
			case '+':
				c++;
				scanf("%d", &n);
				if( (find(head,n) )== NULL ){	
				head= insert(head, n);	
				
				}			
			break;
			
			case '?':
				c++;
				scanf("%d", &n);
				prova= find(head, n);
				if(prova != NULL){
					printf("trovato\n");					
				}	else printf("non trovato \n");				
			break;
			
			case '-':
				c++;
				scanf("%d", &n);
				
				head= delete(head, n);
				
			
			break;
			
			case 'c':
				printf("numero elementi lista: %d\n", conta);
			break;
			
			case 'p':
				print_list(head);
			break;
			
			case 'd':
				//printf("%d\n", head->info);
				destroy(head);
			break;
		} 
	} 
	
	//printf("ciao\n");
	return 0;
}

element* insert(element* list, int n){
	element *new_node;
	new_node= malloc(sizeof(element));
	
	if(new_node == NULL){
		exit(EXIT_FAILURE);
	}
	new_node -> info = n;
	new_node -> next = list;
	
	conta++;
	return new_node; 

}

element* find(element* list, int n){
	while( list != NULL && list -> info != n){
		list= list -> next;
	}		
	return list;
		
	
}

void print_list(element* h){
	int n;	
	element *elemento;
	elemento= h;	
	while( elemento != NULL ){
		n= elemento ->info;		
		printf("n: %d\n", n);
		elemento= elemento -> next;
	}
}

element* delete(element* h, int n){
	element *prev, *curr;
	
	for(curr= h, prev= NULL; curr !=NULL; prev= curr, curr= curr -> next)
		if(curr -> info == n) break;
		
	if(curr == NULL)  //se non ho trovato niente	
		return h;
	
	if(prev == NULL)	h = h -> next;
	
	else	prev -> next = curr -> next;
	

	free(curr);
	
	conta--;

	return h;
} 

void destroy(element* h){
	
	element *curr,*prev;
	
	while( h != NULL ){
		h = delete(h, h -> info);
		h= h -> next;	
	}

}

E per adesso che errore ti da?

ciao, grazie di aver risposto , per ora non da errore ma non cancella, ad esempio se inserisco 3 elementi, nell'ultima posizione mette 0 poi nelle altre dei valori che mi sembrano siano degli indirizzi di memoria.

Assumendo che il resto del codice funzioni (cosa che non ho testato), si potrebbe fare qualcosa del genere:

void destroy(element* h){
    if (h == null) return; //Fine

    element *next = h->next;
    delete(h, h->info);
    destroy(next);
} 

E poi passare a destroy il primo elemento della lista.

Ciao, grazie ancora dell'aiuto ,comunque il resto del codice sembra funzionare il problema è questa funzione in teoria il tuo codice dovrebbe essere corretto anche perché la funzione delete singolarmente funziona, invece se richiamata da destroy mi da in output

+1+2+3       // +1 = insert(element *list, 1)..
p            // stampa
n: 3
n: 2
n: 1
-2            //delete(element* h, 2)
p
n: 3
n: 1
d             //void destroy(element *h)
p
n: 134520848
n: 134520864

che se non sbaglio sono indirizzi di memoria vero?

Ma hai provato a modificare il codice provando a scrivere una funzione come quella che ti ho indicato?

si, utilizzando la tu funzione ottengo l'output che ho postato , la cosa strana è che la funzione delete funziona se chiamata da singoli elementi invece con la ricorsione non va..., ciao e grazie