Liste

Liste concatenate

lista1: insert coda
lista2: insert testa
lista3: insert ordinato
lista4: insert ordinato ricorsivo
lista5: insert coda ricorsivo


lista6: contanodi
lista7: elimina elemento testa e coda
lista8: trova max
lista9: trova max ricorsivo
lista10: elimina max
lista11: rovescia iterativo
lista12: rovescia ricorsivo
lista13: ordina e rovescia
lista14: concatena due liste
lista15: ordina e fonde due liste (merge)
lista16: crea e stampa lista circolare
lista17: cerca un valore in una lista circolare
lista18: trova elemento in una lista circolare
lista19: elimina nodo in una lista circolare
coda20: coda




/*
Lista con inserimento iterativo in coda, stampa ricorsiva.
*/



#include
#include

struct lista{
int data;
struct lista *next;
};
typedef struct lista *LISTA;

LISTA insert(LISTA,int);
void show(LISTA);

main(){
LISTA p=NULL;
int v;

printf("inserire il primo valore ( 0 per terminare ): ");
scanf("%d",&v);
p=insert(p,v);
do{
printf("inserire un valore : ");
scanf("%d",&v);
insert(p,v);
}while(v!=0);
show(p);
printf(" NULL\n");
}


LISTA insert(LISTA p, int v)
{
if(p==NULL){
p=malloc(sizeof(LISTA));
p->data=v;
p->next=NULL;
return p;
}
else{
LISTA punt=p;
while(punt->next != NULL) punt=punt->next;
punt->next=malloc(sizeof(LISTA));
punt=punt->next;
punt->data=v;
punt->next=NULL;
return p;
}
}


void show(LISTA p)
{
if(p==NULL) return;
printf("%d -> ",p->data);
show(p->next);
}

/*
Lista con inserimento iterativo in testa e stampa ricorsiva.
*/


#include
#include

struct lista{
int data;
struct lista *next;
};
typedef struct lista *LISTA;

LISTA insert_testa(LISTA,int);
void show(LISTA);


main()
{
LISTA p;
int v;
p=NULL;

do{
printf("inserire un valore: ");
scanf("%d",&v);
p=insert_testa(p,v);
}while(v!=0);
show(p);
printf(" NULL\n");
}



LISTA insert_testa(LISTA p, int v)
{
LISTA punt=NULL;

if(p==NULL){
p=malloc(sizeof(LISTA));
p->data=v;
p->next=NULL;
return p;
}
else{
punt=malloc(sizeof(LISTA));
punt->data=v;
punt->next=p;
p=punt;
return p;
}
}

void show(LISTA p)
{
if(p==NULL) return;
printf("%d -> ",p->data);
show(p->next);
}

/*
lista con inserimento ordinato iterativo e stampa ricorsiva
*/


#include
#include


struct lista{
int data;
struct lista *next;
};

typedef struct lista *LISTA;

LISTA ins_ord(LISTA,int);
void show(LISTA);


main()
{
LISTA p;
p=NULL;
int v;
do{
printf("inserire un elemento: ");
scanf("%d",&v);
p=ins_ord(p,v);
}while(v!=0);
show(p);
}


LISTA ins_ord(LISTA p, int v)
{
LISTA new, previous, current;

if(p==NULL){ //se la lista e' vuota creo un nodo e ritorno il puntatore al nodo.
p=malloc(sizeof(LISTA));
p->data=v;
p->next=NULL;
return p;
}
else{
new=malloc(sizeof(LISTA)); //altrimenti creo un nodo...
new->data=v;
new->next=NULL;
//...e provvedo al posizionamento, ci sono tre casi:

if(new->data < p->data){ //1) new e' il primo nodo
new->next=p;
p=new;
}

previous=p; //2)cerco la posizione corretta
current=p->next;
while(current != NULL && v>current->data){
previous=current;
current=current->next;
}
previous->next=new;
new->next=current;

if(current==NULL){ //3) e' l'ultimo nodo
previous->next=new;
new->next=NULL;
}
return p;
}
}


void show(LISTA p)
{
if(p==NULL) return;
printf("%d",p->data);
show(p->next);
}

/*
lista con inserimento ordinato e stampa ricorsivi.
*/


#include
#include


struct lista{
int data;
struct lista *next;
};

typedef struct lista *LISTA;

LISTA insOrdRic(LISTA, int);
void show(LISTA);

main()
{
LISTA p;
int v;
p=NULL;

do{
printf("inserire un elemento: ");
scanf("%d",&v);
p=insOrdRic(p,v);
}while(v!=0);
show(p);
printf(" NULL\n");
}


LISTA insOrdRic(LISTA p, int v)
{
LISTA new;
if(p==NULL || p->data>=v){
new=malloc(sizeof(LISTA));
new->data=v;
new->next=p;
return new;
}
else p->next=insOrdRic(p->next,v);
return p;
}

void show(LISTA p)
{
if(p==NULL) return;
printf("%d",p->data);
show(p->next);
}

/*
lista con inserimento in coda e stampa ricorsivi
*/


#include
#include

struct lista{
int data;
struct lista *next;
};
typedef struct lista *LISTA;

LISTA insert(LISTA,int);
void show(LISTA);

main(){
LISTA p;
p=NULL;
int v;
do{
printf("inserire un valore: ");
scanf("%d",&v);
p=insert(p,v);
}while(v!=0);
show(p);
printf("NULL\n");
}

LISTA insert(LISTA p, int v)
{
LISTA new;
if(p==NULL || p->next == NULL){
new=malloc(sizeof(LISTA));
new->data=v;
if(p==NULL)p=new;
else p->next=new;
}
else insert(p->next,v);
return p;
}

void show(LISTA p)
{
if(!p) return;
printf("%d ->",p->data);
show(p->next);
}

/*
Crea una rista di numero di nodi randomizzato, ed elementi a caso,
la funzione contanodi conta i nodi della lista ricorsivamente.
precondizione: nessuna
postcondizione: ritorna il numero di nodi della lista.
*/

#include
#include
#include
#include

struct lista{
int data;
struct lista *next;
};

typedef struct lista *LISTA;

LISTA crea(LISTA);
void show(LISTA);
int contanodi(LISTA);

main()
{
srand(time(NULL));
LISTA L;
L=NULL;
L=crea(L);
show(L);
printf(" NULL\n");
printf("\n I nodi della lista sono %d\n\n",contanodi(L));
}

int contanodi(LISTA p)
{
if(p==NULL) return;
return 1+contanodi(p->next);
}



LISTA crea(LISTA p)
{
LISTA punt;
int i=1 , n=rand()%10; // printf("\n n: %d\n",n); per verificare il numero scelto di nodi
p=malloc(sizeof(LISTA));
assert(p);
p->data= rand()%10;
p->next=NULL;
punt=p;
while(i
punt->next=malloc(sizeof(LISTA));
punt=punt->next;
punt->data=rand()%10;
i++;
}
punt->next=NULL;
return p;
}

void show(LISTA p)
{
if(!p) return;
printf(" %d-> ",p->data);
show(p->next);
}

/*
eliminazione iterativa in testa e in coda alla lista
*/

#include
#include

struct lista{
int data;
struct lista *next;
};
typedef struct lista *LISTA;

LISTA crea(LISTA l);
void show(LISTA);
LISTA elimina_testa(LISTA);
LISTA elimina_coda(LISTA);

main()
{
LISTA L;
L=NULL;
int v;
L=crea(L);
show(L);
printf("NULL\n");

L=elimina_testa(L);
show(L);
printf("NULL\n");
L=elimina_coda(L);
show(L);
printf("NULL\n");
}


LISTA elimina_coda(LISTA p)
{
LISTA punt,temp;
punt=p;
if(p==NULL || p->next==NULL) return 0;
while(punt->next->next!=NULL) punt=punt->next;
temp=punt->next;
punt->next=NULL;
free(temp);
return p;
}



LISTA elimina_testa(LISTA p)
{
LISTA temp;
if(p==NULL || p->next==NULL) return 0;
else{
temp=p;
p=p->next;
free(temp);
}
return p;
}


LISTA crea(LISTA p)
{
LISTA punt;

p=malloc(sizeof(LISTA));
printf("inserire il primo elemento: ");
scanf("%d",&p->data);

punt=p;
int i=2;
while(i<=5){
punt->next=malloc(sizeof(LISTA));
punt=punt->next;
printf("inserire il %d elemento: ",i);
scanf("%d",&punt->data);
punt->next=NULL;
i++;
}
return p;
}

void show(LISTA p)
{
if(p==NULL) return;
printf(" %d ->", p->data);
show(p->next);
}



//trova il massimo elemento della lista

#include
#include
#include
#include

struct lista{
int data;
struct lista *next;
};
typedef struct lista *LISTA;

LISTA crea(LISTA,int);
LISTA elimina(LISTA,int);
void show(LISTA);
LISTA find_max(LISTA);

main()
{

LISTA l=NULL;
int n;
do{
printf("inserire un elemento: ");
scanf("%d",&n);
l=crea(l,n);
show(l);
}while(n!=0);
find_max(l);
}

LISTA find_max(LISTA p)
{
LISTA current,max=p;
if(!p){printf("lista vuota\n");exit(0);}
else{
while(current!=0){
if(current->data > max->data) max=current;
current=current->next;
}
printf("\nil massimo elemento e': %d\n",max->data);
}
return p;
}


LISTA crea(LISTA p,int n)
{
//prec n>0
//post restituisce una lista di elementi allocati in testa di numero n
LISTA punt=p;
if(p==NULL){
p=malloc(sizeof(LISTA));
p->data=n;
p->next=NULL;
}
else{
p=malloc(sizeof(LISTA));
p->data=n;
p->next=punt;
punt=p;
}
return p;
}

void show(LISTA l){
if(!l) return;
printf(" %d -> ",l->data);
show(l->next);
}

/*
La funzione find_max_ric trova il massimo elemento nella lista ricorsivamente.
*/


#include
#include
#include
#include

struct lista{
int data;
struct lista *next;
};
typedef struct lista *LISTA;

LISTA crea(LISTA,int);
LISTA elimina(LISTA,int);
void show(LISTA);
LISTA find_max_ric(LISTA,LISTA);

main()
{

LISTA l=NULL;
int n;
do{
printf("inserire un elemento: ");
scanf("%d",&n);
l=crea(l,n);
show(l);
}while(n!=0);
LISTA max=l;
find_max_ric(l,max);
}

LISTA find_max_ric(LISTA p, LISTA max)
{
if(!p) { printf("\n il massimo elemento e': %d\n",max->data);return p;}
if(p->data > max->data) max=p;
find_max_ric(p->next,max);
}


LISTA crea(LISTA p,int n)
{
//prec n>0
//post restituisce una lista di elementi allocati in testa di numero n
LISTA punt=p;
if(p==NULL){
p=malloc(sizeof(LISTA));
p->data=n;
p->next=NULL;
}
else{
p=malloc(sizeof(LISTA));
p->data=n;
p->next=punt;
punt=p;
}
return p;
}

void show(LISTA l){
if(!l) return;
printf(" %d -> ",l->data);
show(l->next);
}

/*
la funzione del_max elimina il massimo elemento della lista
*/

#include
#include

struct lista{
int data;
struct lista *next;
};
typedef struct lista *LISTA;

LISTA crea(LISTA);
void show(LISTA);
LISTA del_max(LISTA);

main()
{
LISTA l;
l=NULL;
l=crea(l);
show(l);
printf(" NULL\n");
l=del_max(l);
show(l);
printf(" NULL\n");
}


LISTA del_max(LISTA p){
LISTA previous=p, punt=p, max=p;
if(!p){printf("lista vuota\n");return 0;}
else{
while(punt!=0){
if(punt->data > max->data) max=punt; //trovato il massimo
punt=punt->next;
}

if(max==p){p=p->next; free(max);} //caso del primo nodo
else{
while(previous->next!=max) previous=previous->next;
if(max->next==NULL){previous->next=NULL; free(max);} //caso ultimo nondo
else{
previous->next=previous->next->next;
free(max);
}
}
return p;
}
}






LISTA crea(LISTA p)
{
LISTA punt;

p=malloc(sizeof(LISTA));
p->next=NULL;
printf("inserire un elemento: ");
scanf("%d",&p->data);
p->next=NULL;
punt=p;
int i;
for(i=1;i<5;i++){
punt->next=malloc(sizeof(LISTA));
punt=punt->next;
printf("inserire un elemento: ");
scanf("%d",&punt->data);
}
punt->next=NULL;

return p;
}

void show(LISTA p){
if(!p)return;
printf(" %d -> ",p->data);
show(p->next);
}

/*
la funzione rovescia_iter rovescia una lista di interi iterativamente
*/

#include
#include
#include

struct lista{
int data;
struct lista *next;
};
typedef struct lista *LISTA;

LISTA crea(LISTA,int);
void show(LISTA);
LISTA rovescia_iter(LISTA);


main()
{
srand(time(NULL));
LISTA l;
l=NULL;
int size=rand()%10;
int v;
int i=0;
do{
v=rand()%10;
l=crea(l,v);
i++;
}while(i
printf("\nsize: %d\n",size);
show(l);
printf(" Null\n");
l=rovescia_iter(l);
show(l);
printf(" Null\n");
}


LISTA rovescia_iter(LISTA p)
{
LISTA current, punt;
current=p;
LISTA result=NULL;
while(current != NULL){
punt=current->next;
current->next=result;
result=current;
current=punt;
}
return result;
}





LISTA crea(LISTA p, int v)
{
LISTA new;
if(p==NULL || p->next==NULL){
new=malloc(sizeof(LISTA));
new->data=v;
if(p==NULL)p=new;
else p->next=new;
}
else crea(p->next,v);
return p;
}


void show(LISTA p)
{
if(!p) return;
printf(" %d -> ",p->data);
show(p->next);
}

//la funzione rovescia_ric rovescia ricorsivamente gli elementi della lista

#include
#include
#include

struct lista{
int data;
struct lista *next;
};
typedef struct lista *LISTA;

LISTA crea(LISTA,int);
void show(LISTA);
LISTA rovescia_ric(LISTA);


main()
{
srand(time(NULL));
LISTA l;
l=NULL;
int size=rand()%10;
int v;
int i=0;
do{
v=rand()%10;
l=crea(l,v);
i++;
}while(i
printf("\nsize: %d\n",size);
show(l);
printf(" Null\n");
l=rovescia_ric(l);
show(l);
printf(" Null\n");
}


LISTA rovescia_ric(LISTA p)
{
LISTA temp;
if(p->next==0) temp=p;
else{
temp=rovescia_ric(p->next);
p->next->next=p;
p->next=0;
}
return temp;
}










LISTA crea(LISTA p, int v)
{
LISTA new;
if(p==NULL || p->next==NULL){
new=malloc(sizeof(LISTA));
new->data=v;
if(p==NULL)p=new;
else p->next=new;
}
else crea(p->next,v);
return p;
}


void show(LISTA p)
{
if(!p) return;
printf(" %d -> ",p->data);
show(p->next);
}

/*
crea ordina e inverte una lista concatenata
*/

#include
#include

struct node{
int data;
struct node *link;
};

struct node *insert(struct node *p, int n)
{
struct node *temp;
if(p==NULL){ //caso in cui la lista e' vuota, la inizializzo.
p=(struct node *)malloc(sizeof(struct node));
if(p==NULL){ printf("errore\n");exit(0);}
p->data=n;
p->link=NULL;
}
else{
temp=p;
while(temp->link!=NULL) temp=temp->link; //altrimenti trovo l'ultimo nodo
temp->link=malloc(sizeof(struct node));
if(temp->link==NULL){printf("errore\n");exit(0);}
temp=temp->link;
temp->data=n;
temp->link=NULL;
}
return(p);
}

void print(struct node *p)
{
printf("lista: ");
while(p!=NULL)
{
printf(" %d ->",p->data);
p=p->link;
}
printf(" null\n");
}


struct node *reverse(struct node *p)
{
struct node *prev,*curr;
prev=NULL;
curr=p;
while(curr != NULL){
p=p->link;
curr->link=prev;
prev=curr;
curr=p;
}
return(prev);
}


struct node *sort(struct node *p)
{
struct node *temp1,*temp2,*min,*prev,*q;
q=NULL;
while(p!=NULL){
prev=NULL;
min=temp1=p;
temp2=p->link;
while(temp2 != NULL){
if(min->data > temp2->data)
{
min=temp2;
prev=temp1;
}
temp1=temp2;
temp2=temp2->link;
}
if(prev==NULL) p=min->link;
else prev->link=min->link;
min->link=NULL;
if(q==NULL) q=min;
else{
temp1=q;
while(temp1->link!=NULL) temp1=temp1->link;
temp1->link=min;
}
}
return q;
}

main()
{
int n;
int x;
struct node *start=NULL;
printf("inserire un valore per il numero di nodi: ");
scanf("%d",&n);
while(n-- > 0){
printf("inserire un valore: ");
scanf("%d",&x);
start=insert(start,x);
}
print(start);
start=sort(start);
print(start);
start=reverse(start);
print(start);
}

//concatenare due liste


#include
#include
#include
#include
struct lista{
int data;
struct lista *next;
};
typedef struct lista *LISTA;

LISTA crea(LISTA);
void stampa(LISTA);
LISTA concatenate(LISTA,LISTA);

main()
{
srand(time(NULL));
LISTA l;
l=NULL;
l=crea(l);
LISTA m;
m=NULL;
m=crea(m);
printf("lista n 1: ");
stampa(l);
printf("lista n 2: ");
stampa(m);
l=concatenate(l,m);
stampa(l);
}

LISTA concatenate(LISTA a, LISTA b)
{
assert(a!=NULL);
if(a->next==NULL) a->next=b;
else concatenate(a->next,b);
return a;
}

LISTA crea(LISTA p)
{
LISTA punt;
int i;

p=malloc(sizeof(LISTA));
p->data=rand()%10;
p->next=NULL;
punt=p;
for(i=1;i<5;i++){
punt->next=malloc(sizeof(LISTA));
punt=punt->next;
punt->data=rand()%10;
punt->next=NULL;
}
return p;
}

void stampa(LISTA l)
{
if(!l){printf(" null\n");return;}
printf(" %d->",l->data);
stampa(l->next);
}
//merge sort

#include
#include

struct node{
int data;
struct node *link;
};
struct node *merge(struct node *, struct node *);


struct node *insert(struct node *p, int n)
{
struct node *temp;
if(p==NULL)
{
p= (struct node *) malloc(sizeof(struct node));
if(p==NULL){
printf("errore\n");exit(0);
}
p->data=n;
p->link=NULL;
}
else{
temp=p;
while(temp->link!=NULL) temp=temp->link;

temp->link=malloc(sizeof(struct node));
if(temp->link==NULL){printf("errore\n");exit(0);}
temp=temp->link;
temp->data=n;
temp->link=NULL;
}
return p;
}
void printlist(struct node *p)
{
if(p==NULL){printf("NULL\n");return ;}
printf("%d -> ",p->data);
printlist(p->link);
}


struct node *sortlist(struct node *p)
{
struct node *temp1, *temp2, *min, *prev, *q;
q=NULL;
while(p!=NULL){
prev=NULL;
min=temp1=p;
temp2=p->link;
while(temp2!=NULL){
if(min->data > temp2->data){
min=temp2; prev=temp1;
}
temp1=temp2;
temp2=temp2->link;
}
if(prev==NULL) p=min->link;
else prev->link=min->link;
min->link=NULL;
if(q==NULL) q=min;
else{
temp1=q;
while(temp1->link!=NULL) temp1=temp1->link;
temp1->link=min;
}
}
return q;
}

main()
{
int n;
int x;
struct node *start1=NULL;
struct node *start2=NULL;
struct node *start3=NULL;

printf("inserire il numero di nodi della prima lista: ");
scanf("%d",&n);
while(n-- > 0){
printf("inserire un valore: ");
scanf("%d",&x);
start1=insert(start1,x);
}
printf("la prima lista: ");
printlist(start1);
start1=sortlist(start1);
printf("la prima lista ordinata: ");
printlist(start1);
printf("inserire il numero di nodi della seconda lista: ");
scanf("%d",&n);
while(n-- > 0){
printf("inserire un valore: ");
scanf("%d",&x);
start2=insert(start2,x);
}
printf("la seconda lista: ");
printlist(start2);
start2=sortlist(start2);
printf("la seconda lista ordinata: ");
printlist(start2);
start3=merge(start1, start2);
printf("la fusione delle liste: ");
printlist(start3);
}



struct node *merge(struct node *p,struct node *q)
{
struct node *r=NULL,*temp;
if(p==NULL) r=q; //in caso una delle due sia vuota
else if(q==NULL) r=p;
else{
if(p->data < q->data){
r=p;
temp=p;
p=p->link;
temp->link=NULL;
}
else{
r=q;
temp=q;
q=q->link;
temp->link=NULL;
}
while(p!=NULL && q!=NULL){
if(p->data < q->data){
temp->link=p;
p=p->link;
temp=temp->link;
temp->link=NULL;
}
else{
temp->link=q;
q=q->link;
temp=temp->link;
temp->link=NULL;
}
}
if(p!=NULL) temp->link=p;
if(q!=NULL) temp->link=q;
}
return r;
}

/*creazione e stampa di una lista circolare*/

#include
#include

struct lista{
int data;
struct lista *next;
};

typedef struct lista *LISTA;

LISTA crea_circ(LISTA,int);
void stampa(LISTA);

main(){
LISTA p;
int n;
p=NULL;
do{
printf("inserire un elemento: ");
scanf("%d",&n);
p=crea_circ(p,n);
stampa(p);
}while(n!=0);
}

LISTA crea_circ(LISTA p, int data)
{
LISTA punt,new;
if(!p){
p=malloc(sizeof(LISTA));
p->data=data;
p->next=p;
}
else{
punt=p;
while(punt->next != p) punt=punt->next;
punt->next=malloc(sizeof(LISTA));
punt=punt->next;
punt->data=data;
punt->next=p;
}
return p;
}

void stampa(LISTA p)
{
printf("start-> ");
LISTA punt=p->next;
printf(" %d ->",p->data);
while(punt!=p){
printf(" %d ->",punt->data);
punt=punt->next;
}
printf(" start\n");
}

/*
cerca un valore in una lista circolare
*/

#include
#include
#include

struct lista{
int data;
struct lista *next;
};
typedef struct lista *LISTA;

LISTA crea_circ(LISTA,int);
void stampa(LISTA);
LISTA cerca(LISTA,int);

int main(void)
{
srand(time(NULL));
LISTA p=NULL;
int x;
int cnt=0;
printf("lista creata: \n");
do{
x=rand()%10;
p=crea_circ(p,x);
stampa(p);
cnt++;
}while(cnt<=7);
printf("inerire l'elemento da cercare: ");
scanf("%d",&x);
cerca(p,x);
}
LISTA crea_circ(LISTA p, int data)
{
LISTA punt=p;
if(!p){
p=malloc(sizeof(LISTA));
p->data=data;
p->next=p;
}
else{
while(punt->next!=p) punt=punt->next;
punt->next=malloc(sizeof(LISTA));
punt=punt->next;
punt->data=data;
punt->next=p;
}
return p;
}

void stampa(LISTA p)
{
printf("start-> ");
LISTA punt=p;
printf(" %d ->",p->data);
while(punt->next!=p){
printf(" %d->",punt->data);
punt=punt->next;
}
printf(" start\n");
}


LISTA cerca(LISTA p, int x)
{
/*
precondizione: la funzione riceve una lista e un parametro da cercare
postcondizione: restituisce il nodo della lista che contiene l'elemento altrimenti null
*/
LISTA punt;
punt=p;
int cnt=0;
if(p==NULL)return NULL;
do{
if(punt->data==x){printf("l'elemento si trova al nodo numero %d",++cnt);return punt;}
punt=punt->next;
cnt++;
}while(punt!=p);
return NULL;
}
/*
lista circolare: funzione di controllo se un elemento appartiene o no ad una lista
*/

#include
#include
#include

struct lista{
int data;
struct lista *next;
};
typedef struct lista *LISTA;

LISTA crea_circ(LISTA,int);
void stampa(LISTA);
int find(LISTA,int);

int main(void)
{
srand(time(NULL));
LISTA p=NULL;
int x;
int cnt=0;
printf("lista creata: \n");
do{
x=rand()%10;
p=crea_circ(p,x);
stampa(p);
cnt++;
}while(cnt<=7);
printf("inerire l'elemento da cercare: ");
scanf("%d",&x);
if(find(p,x))printf("l'elemento e' presente\n");
else printf("l'elemento non appartiene alla lista\n");
stampa(p);
}
LISTA crea_circ(LISTA p, int data)
{
LISTA punt=p;
if(!p){
p=malloc(sizeof(LISTA));
p->data=data;
p->next=p;
}
else{
while(punt->next!=p) punt=punt->next;
punt->next=malloc(sizeof(LISTA));
punt=punt->next;
punt->data=data;
punt->next=p;
}
return p;
}

void stampa(LISTA p)
{
printf("start-> ");
LISTA punt=p;
printf(" %d ->",p->data);
while(punt->next!=p){
printf(" %d->",punt->data);
punt=punt->next;
}
printf(" start\n");
}


int find(LISTA p, int x)
{
/*
prec: riceve una lista circolare e un parametro equivalente al valore del nodo da cancellare
post: ritorna la lista dopo aver cancellato il nodo, se il parametro e' presente.
*/
LISTA punt;
punt=p;
if(!p){printf("la lista e' vuota\n");exit(0);}
while(punt->next!=p){
if(punt->data==x){printf(" \n%d trovato\n",punt->data); return 1;}
else punt=punt->next;
}
printf("non trovato\n");
return 0;
}

/*
lista concatenata circolare: funzione di rimozione di un nodo (delete node)
*/

#include
#include

struct lista {
int data;
struct lista *next;
};
typedef struct lista *LISTA;

LISTA add(LISTA ,int);
void stampa(LISTA);
LISTA delete(LISTA,int);

main()
{
LISTA p;
p=NULL;
int n;
do{
printf(">");
scanf("%d",&n);
p=add(p,n);
}while(n!=0);

stampa(p);
printf("inserire l'elemento del nodo da eliminare: ");
scanf("%d",&n);
p=delete(p,n);
stampa(p);
}


LISTA delete(LISTA p, int x)
{
LISTA punt=p,temp;
if(!p){printf("lista vuota\n");exit(0);}
if(p->data==x){
temp=p;
p=p->next;
free(temp);
return p;
}
while(punt->next->data!=x) punt=punt->next;
if(punt->next==p){printf("l'elemento non e' presente\n");exit(0);}
temp=punt->next;
punt->next=temp->next;
free(temp);
return p;
}



LISTA add(LISTA p, int data)
{
LISTA punt;
if(!p){
p=malloc(sizeof(LISTA));
p->next=p;
p->data=data;
return p;
}
punt=p;
while(punt->next!=p)punt=punt->next;
punt->next=malloc(sizeof(LISTA));
punt=punt->next;
punt->data=data;
punt->next=p;
return p;
}

void stampa(LISTA p)
{
LISTA punt;
punt=p;
printf("ptr->");
while(punt->next!=p){
printf(" %d ->",punt->data);
punt=punt->next;
}
printf(" ->ptr\n");
}

/*
Lista con inserimento iterativo in testa e stampa ricorsiva.
*/


#include
#include

struct lista{
int data;
struct lista *next;
};
typedef struct lista *LISTA;

LISTA insert_testa(LISTA,int);
void show(LISTA);


main()
{
LISTA p;
int v;
p=NULL;

do{
printf("inserire un valore: ");
scanf("%d",&v);
p=insert_testa(p,v);
}while(v!=0);
show(p);
printf(" NULL\n");
}



LISTA insert_testa(LISTA p, int v)
{
LISTA punt=NULL;

if(p==NULL){
p=malloc(sizeof(LISTA));
p->data=v;
p->next=NULL;
return p;
}
else{
punt=malloc(sizeof(LISTA));
punt->data=v;
punt->next=p;
p=punt;
return p;
}
}

void show(LISTA p)
{
if(p==NULL) return;
printf("%d -> ",p->data);
show(p->next);
}


/*implementazione di una coda con le due funzioni di inserimento e cancellazione*/


#include
#include

struct coda{
int data;
struct coda *next;
};
typedef struct coda *CODA;

CODA enqueue(CODA,int);
CODA dequeue(CODA);
void show(CODA);

main()
{
int data;
CODA c;
c=NULL;
printf("inserire un valore: ");
scanf("%d",&data);
while(data!=0){
c=enqueue(c,data);
show(c);
printf(" NULL\n");
printf(">\n");
scanf("%d",&data);
}
printf("inserire 1 per eliminare un valore: ");
scanf("%d",&data);
while(data==1){
c=dequeue(c);
show(c);
printf(" NULL\n");
printf("1 per continuare: ");
scanf("%d",&data);
}
show(c);
printf(" NULL\n");
};


CODA enqueue(CODA c, int data)
{
CODA new;
if(c==NULL || c->next==NULL){
new=malloc(sizeof(CODA));
new->data=data;
if(c==NULL) c=new;
else c->next=new;
}
else enqueue(c->next,data);
return c;
}


CODA dequeue(CODA c)
{
CODA punt,temp;
punt=c;
if(c==NULL || c->next==NULL){printf("la coda e' vuota\n"); exit(0);}
while(punt->next->next != NULL) punt=punt->next;
temp=punt->next;
punt->next=NULL;
free(temp);
return c;
}

void show(CODA c)
{
if(!c)return ;
printf(" %d-> ",c->data);
show(c->next);
}