Untitled

LISTE

-struct nodo 
-if(testa==NULL){
	return NULL; 
}





// Online C compiler to run C program online
#include <stdio.h>
#include <stdlib.h>

typedef struct nodo_{
    int num;
    struct nodo_ *next;
}nodo_t;

nodo_t* inserisciInTesta(nodo_t *l, int num)
{
    nodo_t *tmp;
    
    tmp = malloc(sizeof(nodo_t));
    if(tmp != NULL)
    {
        tmp -> num = num;
        tmp -> next = l;
        l = tmp;
    }
    else
    {
        printf("Memoria esaurita");
    }
    
    return l;
}

void stampaLista(nodo_t* l)
{
    nodo_t *corrente = l;
    while(corrente != NULL)
    {
        printf("%d -> ", corrente->num);
        corrente = corrente -> next;
    }
    printf("NULL\n");
}

int main() {
    
    nodo_t *lista = NULL;
    
    lista = inserisciInTesta(lista, 3);
    lista = inserisciInTesta(lista, 5);
    lista = inserisciInTesta(lista, 7);
    
    stampaLista(lista);

    
    return 0;
}

/*Definire un nuovo tipo di dato strutturato in C (C89) per
rappresentare una lista concatenata mediante cui memorizzare una
sequenza di lunghezza indefinita di numeri interi.
Realizzare i seguenti sottoprogrammi in C nelle versioni sia
iterativa che ricorsiva.
* Scrivere un sottoprogramma che riceve una testa di una lista
dinamica di interi e ne visualizza il contenuto.*/

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

typedef struct nodo_{
	int num; 
	struct nodo_ *next;

}nodo_t;


void visualizza_lista(nodo_t* l){
	nodo_t *corrente=l;
	while(corrente!=NULL){
		printf("%d\n", corrente->num);
		corrente= corrente->next;

}

int main(){
	nodo_t *lista=NULL;
	visualizza_lista(lista);
	return 0; 

}

/* Scrivere un sottoprogramma che riceve una testa di una lista
dinamica di interi e ne restituisce la lunghezza.*/

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

typedef struct nodo_{
	int num; 
	struct nodo_ *next;
}nodo_t;

nodo_t* creaNodo(int num){
	nodo_t* nuovo_nodo = (nodo_t*)malloc(sizeof(nodo_t));
	nuovo_nodo->num=num;
	nuovo_nodo->next=NULL;
	return nuovo_nodo;

}


int lunghezzalista(nodo_t *head){
	int lunghezza=0;
	nodo_t* corrente=head; 

	while(corrente!=NULL){
		lunghezza++; 
		corrente=corrente->next;
	}return lunghezza;
}

int main(){
	nodo_t*head = creaNodo(10);
	head->next=creaNodo(20);
	head->next->next=creaNodo(30);
	
	int lenght;
	lenght=lunghezzalista(head);
	printf("%d", lenght);
	return 0;

}

/*Scrivere un sottoprogramma che riceve una testa di una lista
dinamica di interi ed un intero. Il sottoprogramma restituisce 1 se
il numero è presente nella lista altrimenti 0.*/

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

typedef struct nodo_{
	int num; 
	struct nodo_ *next;	
}nodo_t;

int ricerca_elemento(nodo_t*l, int n){
	nodo_t*corrente=l; 
	while(corrente != NULL){
		if(n==corrente->num){
			return 1;
		}else{
			return 0; 
		}
		corrente=corrente->next; 
	}
}

//cancella in testa e in coda
#include <stdio.h>

nodo_t* cancellaTesta(nodo_t *l)
{
    nodo_t *tmp;
    
    if(l != NULL)
    {
        tmp = l; //Salvo un puntatore alla testa attuale
        l = l->next; //Sposta la testa al nodo nuo
        free(tmp);
    }
}

nodo_t *cancellaCoda(nodo_t *l)
{
    nodo_t *tmp, *prec;
    
    if(l != NULL)
    {
        // Caso 1: La lista ha un solo elemento (l == coda)
        if (l->next == NULL)
        {
            free(l);
        
            l=NULL;
        }
        else
        {
            // Caso 2: La lista ha più di un elemento
            for(prec = l; prec->next->next != NULL; prec = prec->next;)
            
            //A questo punto, 'prec' è il penultimo nodo
            tmp = prec -> next; //tmp è l'ultimo nodo
            prec->next = NULL; //Stacca l'ultimo nodo dalla lista
            free(tmp);
        }
        return l;
    }
}

int main() {
    nodo_t *lista;
    
    lista = cancellaTesta(lista); 
    return 0;
}

//elimina nodo della lista 
#include <stdio.h>
nodo_t* cancellaTesta(nodo_t *l)
{
    nodo_t *tmp;
    
    if(l != NULL)
    {
        tmp = l; //Salvo un puntatore alla testa attuale
        l = l->next; //Sposta la testa al nodo nuo
        free(tmp);
    }
}
nodo_t *cancellaCoda(nodo_t *l)
{
    nodo_t *tmp, *prec;
    
    if(l != NULL)
    {
        // Caso 1: La lista ha un solo elemento (l == coda)
        if (l->next == NULL)
        {
            free(l);
            l=NULL;
        }
        else
        {
            // Caso 2: La lista ha più di un elemento
            for(prec = l; prec->next->next != NULL; prec = prec->next;)
            
            //A questo punto, 'prec' è il penultimo nodo
            tmp = prec -> next; //tmp è l'ultimo nodo
            prec->next = NULL; //Stacca l'ultimo nodo dalla lista
            free(tmp);
        }
        return l;
    }
}

int main() {
    nodo_t *lista;
    
    lista = cancellaTesta(lista);
    return 0;
}

/*Supponendo di avere a disposizione una struttura dati per liste
dinamiche e una serie di sottoprogrammi standard di manipolazione
delle liste (come quelli definiti sopra), scrivere un programma in C
che acquisisce da tastiera due sequenze di lunghezza indefinita di
numeri interi ciascuna terminata da uno 0 (che non fa parte della
sequenza); ciascuna sequenza va memorizzata in una lista. Il
programma calcola l'intersezione delle due sequenze rimuovendo
eventuali duplicati, salvando il risultato in una terza lista e
visualizzandolo. Il programma libera tutta la memoria allocata prima
di terminare.*/

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

typedef struct nodo_{
	int num; 
	struct nodo_ *next;
}nodo_t;


/*nodo_t* no_duplicati(nodo_t* l){
	if(l==NULL){
		return NULL; 
	}
	
	// 1->2->3->2->4->5->3->NULL

	nodo_t* corrente=l;
	nodo_t* prev=NULL;
	while(corrente!=NULL){
		while(corrente->next!=NULL){
			if(corrente->next->num==corrente->num){
				prev->next= corrente->next->next;
				nodo_t* tmp= corrente->next;
				free(tmp);
			}

			prev=corrente->next;
			corrente->next=corrente->next->next;
		}
		
		corrente=corrente->next;

	}
	return l; 
 
}*/


nodo_t* no_duplicati(nodo_t* l) {
    if (l == NULL) {
        return NULL;
    }
    
    nodo_t* corrente = l;
    
    while (corrente != NULL && corrente->next != NULL) {
        nodo_t* prev = corrente;
        
        while (prev->next != NULL) {
            if (prev->next->num == corrente->num) {
                nodo_t* tmp = prev->next;
                prev->next = prev->next->next;
                free(tmp);
            } else {
                prev = prev->next;
            }
        }
        
        corrente = corrente->next;
    }
    
    return l;
}


nodo_t* intersezione(nodo_t* l1, nodo_t *l2){
	if(l1==NULL || l2==NULL){
		return NULL;
	}
    nodo_t* curr1=l1;
	nodo_t* curr2=l2;
	nodo_t* l3=NULL;

//[2]->[3]->[4]->[9]->NULL
//[5]->[8]->[9]->[4]->[6]->NULL

	while(curr1!=NULL){ 
		while(curr2!=NULL){
			if(curr1->num==curr2->num){
				l3=inseriscitesta(curr1, curr1->num);
			}
			curr2=curr2->next;
		}
		curr1=curr1->next;
		curr2=l2;

	}
	return l3; 

}

int main(){
	nodo_t* list1=NULL;
	nodo_t* list2=NULL; 
	nodo_t* list3=NULL;
	int num; 
	do{
		scanf("%d", &num);
		list1 = inseriscitesta(list1, num);
	}
	while(num!=0);
	do{
		scanf("%d", &num);
		list2 = inseriscitesta(list2, num);
	}
	while(num!=0);

	list1=no_duplicati(list1);
	list2=no_duplicati(list2);
	list3=intersezione(list1, list2);

	return 0; 

}
	

	//list1= [2]->[3]->[4]->[4]->[9]->NULL ------> list1_nodup=[2]->[3]->[4]->[9]->NULL
	//list2= [5]->[8]->[9]->[4]->[6]->NULL ------> list2_nodup=[5]->[8]->[9]->[4]->[6]->NULL
	//list3= [4]->[9]->NULL