// PROTOTIPI void costruisciLista(Pnodo &, string &); void stampaLista(Pnodo ); void creaNodo (int, Pnodo&); Pnodo inserisciNodoTesta (int,Pnodo &); Pnodo inserisciNodoCoda(int,Pnodo, Pnodo &) ; Pnodo inserisciNodoMezzo(int,Pnodo,Pnodo &); Pnodo cancellaNodo (int,Pnodo &,Pnodo &); Pnodo cercaItem(int,Pnodo,Pnodo &); bool listaVuota(Pnodo); int cercaPosizione(int, Pnodo); int contaNodi(Pnodo); ESERCIZIO Riscrivere con funzioni ricorsive le procedure // PROTOTIPI void costruisciLista(Pnodo &); void stampaLista(Pnodo ); void creaNodo (int, Pnodo&); Pnodo inserisciNodoTesta (int,Pnodo &); void inserisciNodoCoda (int,Pnodo &); void inserisciNodoMezzo (int,Pnodo &); void cancellaNodo (int,Pnodo &); void cercaItem(int,Pnodo,Pnodo &); bool listaVuota(Pnodo); int cercaPosizione(int, Pnodo); int contaNodi(Pnodo);

void inserisciNodoCoda ( int info1,Pnodo &L) {// inserisce un nuovo nodo in coda alla lista Pnodo prec, curr; if (L==NULL) creaNodo(info1, L); else { curr=L; prec=NULL; while (curr!=NULL) { prec=curr; curr=curr->next; } creaNodo(info1, prec->next); } Pnodo inserisciNodoCoda ( int info1,Pnodo L, Pnodo &TL) {// inserisce un nuovo nodo in coda alla lista if (L==NULL) { creaNodo(info1, L); return L; } else { if (L->next!=NULL) return inserisciNodoCoda(info1, L->next, TL); creaNodo(info1, L->next); return TL; } void inserisciNodoCodaNew ( int info1,Pnodo &L) {// inserisce un nuovo nodo in coda alla lista Pnodo temp; temp=L; if (temp==NULL) creaNodo(info1, L); else { while (temp->next!=NULL) { temp=temp->next; } creaNodo(info1, temp->next); }

void inserisciNodoMezzo( int info1,Pnodo &L) {// inserisce un nuovo nodo in mezzo alla lista int inf; Pnodo prec, curr, Temp; cout<<"Dammi valore nodo "; cin>>inf;cout<<endl; if (L==NULL) creaNodo(info1, L); else { curr=L; prec=NULL; while ((curr->info!=info1)&&(curr->next!=NULL)) {prec=curr; curr=curr->next; } if (curr->info==info1) { creaNodo(inf, Temp); Temp->next=curr->next; curr->next=Temp; } Pnodo inserisciNodoMezzo( int info1,Pnodo L, Pnodo &TL) { // inserisce un nuovo nodo in mezzo alla lista int inf; Pnodo Temp; if (L==NULL) { creaNodo(info1, L); return L; } //Se la lista è nulla la crea con il nuovo nodo else { // cerca il nodo if (L->info!=info1)&&(L->next!=NULL)) return inserisciNodoMezzo(info1, L->next, TL); else { if ((L->info!=info1) return TL ; // se non c'è esce else // se c'è lo aggiunge cout<<"Dammi valore nodo da aggiungere"; cin>>inf;cout<<endl; creaNodo(inf, Temp); Temp->next=L->next; L->next=Temp; return TL ;} }

void cancellaNodo (int item1,Pnodo &L) { Pnodo Temp; if (L!=NULL) { if (L->info==item1) { Temp=L; L=L->next; delete Temp; } else cancellaNodo(item1, L->next); } void cercaItem(int item1,Pnodo L, Pnodo &p) { if (L!=NULL) { if (L->info==item1) { p=L; return; } else cercaItem(item1, L->next,p); } else { p=NULL; return;} } Pnodo cercaItem (int item1,Pnodo L) {// cerca la chiave item1 if (L==NULL) { return false; } else if (L->info==item1) return true; else return cercaItem(item1, L->next); Pnodo cancellaNodo (int item1,Pnodo &L, Pnodo &TL) { // cancella un nodo di chiave item1 Pnodo Temp; if (L!=NULL) { if (L->info==item1) { Temp=L; L=L->next; delete Temp; return TL; } else return cancellaNodo(item1, L->next, TL); } else return TL; }

int cercaPosizione(int item1, Pnodo L) { // cerca la posizione nella lista di item1 { if ((L->next==NULL)&&(L->info!=item1) ) return -100; else if (L->info==item1) return 1; else return cercaPosizione(item1, L->next)+1; } int contaNodi(Pnodo L) { // conta i nodi della lista if (L==NULL) return 0; else return contaNodi(L->next)+1; } Pnodo cancellaNodoUguali (int item1,Pnodo &L, Pnodo &TL) { // cancella un nodo di chiave item1 Pnodo Temp; if (L!=NULL) { if (L->info==item1) { Temp=L; L=L->next; delete Temp; cancellaNodoUguali(item1, L, TL); } else return cancellaNodoUguali(item1, L->next, TL); } return TL; } listeFileGenRic2

Date due liste legate di interi L1 ed L2, contenenti eventuali ripetizioni, costruire la lista legata L3, senza ripetizioni, che contiene tutti gli interi presenti sia in L1 che in L2. UNIONE Pnodo L1,L2, L3,p3; costruisciLista(L1); stampaLista(L1); cout<<endl; costruisciLista(L2); stampaLista(L2); cout<<endl; system("pause"); L3=NULL; p3=Lista3(L1,L2, L3); if (p3==NULL) cout<<"UNIONE VUOTA"<<endl; else { cout<<"\n UNIONE "<<endl; stampaLista(p3); } Pnodo Lista3(Pnodo M,Pnodo M2, Pnodo &M3) { if (M==NULL) return M3;// se L1 è vuota ritorna NULL else { aggiornaM3(M,M3); //inserisci L1 in M3 senza ripetizioni aggiornaM3(M2,M3); //inserisci L2 in M3 senza ripetizioni } return M3; } listeUnione3 void aggiornaM3(Pnodo L,Pnodo &L3) {Pnodo Lx, temp; while (L!=NULL) // Finchè L non è finita {if (L3==NULL) // Se siamo all'inizio in L3 metti L {creaNodo(L->info,L3); } else { Lx=L3; //Finchè non trovo in L3 L oppure non finisce L3 while ((Lx->info!=L->info)&&(Lx->next!=NULL)) Lx=Lx->next; if (Lx->info!=L->info) // Se non c'è l'aggiungo { creaNodo(L->info,temp); Lx->next=temp; } L=L->next; } }

Pnodo L1,L2, L3,L4; costruisciLista(L1); stampaLista(L1); costruisciLista(L2); stampaLista(L2); L3=NULL; cout<<"\n INTERSEZIONE "<<endl; L4=Lista3(L1,L2, L3); if (L4==NULL) cout<<" Intersezione vuota "<<endl; stampaLista(L4); Date due liste legate di caratteri L1 ed L2, contenenti eventuali ripetizioni, costruire la lista legata L3, senza ripetizioni, che contiene tutti e soli i caratteri presenti in entrambe le liste. INTERSEZIONE Pnodo Lista3(Pnodo M1,Pnodo M2, Pnodo &M3){ bool bol; while (M1!=NULL){ if (cercaItem(M1->info,M2)) aggiungiNodo(M1->info,M3); M1=M1->next; } return M3; } bool cercaItem(int item1,Pnodo L) {// cerca la chiave item1 if (L==NULL) { return false; } else if (L->info==item1) return true; else return cercaItem(item1, L->next); } void aggiungiNodo ( int info1,Pnodo &M3) { Pnodo curr=M3; if (M3==NULL){ creaNodo(info1,M3); return;} else { while ((curr->next!=NULL)&&(curr->info!=info1)) curr=curr->next;} if (curr->next==NULL) creaNodo(info1,curr->next); return; } listeIntersezione3

Siano L1 ed L2 due liste legate, di eguale lunghezza. Scrivere una procedura o funzione ricorsiva che restituisca la lista L1 contenente in successione gli elementi di L1 ed L2, alternati fra loro. Esempio: se L1 = (1,4,3,5) ed L2 = (7,6,2,6),L1 = (1,7,4,6,3,2,5,6) listeAlternate4 Pnodo Alterna(Pnodo &Tl1,Pnodo L1,Pnodo L2) { Pnodo temp1, temp2; if (L1->next==NULL) {L1->next=L2; return Tl1;} else { temp1=L1->next; temp2=L2->next; L1->next=L2; L2->next=temp1; return Alterna(Tl1, L1->next->next,temp2); } void inserisciNodo ( int info1,Pnodo &L,Pnodo &TL) { if (TL==NULL) { creaNodo(info1, TL); L=TL;} else { creaNodo(info1, L->next); L=L->next;} }

void Sposta(Pnodo &plett, Pnodo &prec,Pnodo &TL) { // se dispari lo metto in testa, se pari lo lascio stare if ((plett->info)%2!=0) { prec->next=plett->next; plett->next=TL; TL=plett; plett=prec->next; cout<<" "<<endl; } else { prec=plett; plett=plett->next; } return; } Assegnate due liste legate L1 e L2 contenenti numeri interi, fondere le due liste in ununica lista in cui nella prima parte ci siano solo i numeri dispari e nella seconda parte solo i numeri pari. int main() { Pnodo L1, L2,; costruisciLista(L1); costruisciLista(L2); spostaNodi(L1,L2); cout<<"\n Lfinale "<<endl; stampaLista(L1); } void spostaNodi(Pnodo &TL1, Pnodo TL2) { Pnodo plett, TL,prec; TL=TL1; prec=TL; if (TL->next!=NULL) { plett=TL->next; while (plett->next!=NULL) { Sposta(plett,prec,TL); } plett->next=TL2; Sposta(plett,prec,TL); //ultimo nodo di TL1 TL1=TL; } else {TL->next=TL2; plett=TL->next; } while (plett->next!=NULL) { Sposta(plett,prec,TL1); } Sposta(plett,prec,TL1); TL2=NULL; //ultimo nodo di TL2 } spostanodi4

void costruisciLista(Pnodo &TL, string &NomeIn) {Pnodo L=NULL, temp,prec=NULL; int item; ifstream filista; ofstream outlista; NomeIn="L2.txt"; filista.open(NomeIn.c_str()); if (!filista) { cerr<<"Non si puo' aprire il file"<<endl; system("pause");} filista>>item; if (L==NULL) { creaNodo(item, temp); TL=temp; } while (!filista.eof()) { filista>>item; cout<<" NODO DA INSERIRE "<<item<<endl; creaNodo(item, temp); L=TL; prec=NULL; while ((L->info next!=NULL)) { prec=L; L=L->next;} { if ((prec==NULL)&&(L->info>=item)) { temp->next=TL; TL=temp; cout<<"\n metti in testa "<<item<<end; } else if (L->next==NULL) { if (L->info<item) { L->next=temp; cout<<"\n metti in coda "<<item<<endl; } // item è più grande dell'ultimo else { prec->next=temp; temp->next=L; // item precede l'ultimo cout<<"\n metti penultimo "<<endl;} } else { prec->next=temp; cout<<"\n metti in mezzo "<<endl; temp->next=L; } Dato un file di interi non ordinati metterli in una lista in ordine crescente listeInsertionSort

// MAIN int main() { int item, pot, coef; Pnodo poL1, poL2; cout<<" PRIMO POLINOMIO "<<endl; costruisciPolinomio(poL1,nome); stampaPolinomio(poL1); cout<<" SECONDO POLINOMIO "<<endl; costruisciPolinomio(poL2,nome); stampaPolinomio(poL2); cout<<" POLINOMIO SOMMA "<<endl; stampaPolinomio(Somma(poL1, poL2)); system("pause"); } void costruisciPolinomio(Pnodo &L, string &NomeIn) {Pnodo nodo; int coe, po; ifstream filista; ofstream outlista; filista.open(NomeIn.c_str()); filista>>coe; filista>>po; { creaNodo(coe,po,L); filista>>coe; filista>>po; while (!filista.eof()) { inserisciNodoCoda(coe,po,L); filista>>coe; filista>>po; } } Pnodo Somma(Pnodo L1, Pnodo L2) {Pnodo L3, TL3; L3=NULL; TL3=NULL; while (L1!=NULL) { if (L1->grado>L2->grado){ inserisciNodoCoda (L1->coeff, L1->grado, L3); L1=L1->next; } else if (L1->grado grado){ inserisciNodoCoda (L2->coeff, L2->grado, L3); L2=L2->next; } else { inserisciNodoCoda (L1->coeff+L2->coeff, L1->grado, L3); L1=L1->next; L2=L2->next; } } stampaPolinomio(L3); } Si presume che i due polinomi siano ordinati

void inserisciNodoCoda ( int c1,int p1,Pnodo &L) {// inserisce un nuovo nodo in coda alla lista Pnodo prec, curr; if (L==NULL) creaNodo(c1,p1, L); else { curr=L; prec=NULL; while (curr!=NULL) { prec=curr; curr=curr->next; } creaNodo(c1,p1, prec->next); } void stampaPolinomio(Pnodo L) { char segno; segno=' '; if (L!=NULL) { if (L->coeff>=0) segno='+'; if (L->grado==0)cout coeff<<" "; else cout coeff grado<<" "; return stampaPolinomio(L->next); } void creaNodo (int c1, int p1, Pnodo& Temp) { Temp= new Rnodo; Temp->coeff=c1; Temp->grado=p1; Temp->next=NULL; } listePolinomi

Data una lista di interi non ordinata, renderla ordinata. TL pTL FL precLprecPT Definizioni Sia TL linizio della lista ordinata; Sia FL La fine della lista ordinata; Sia L il puntatore di scorrimento sulla parte di lista non ordinata ; Sia prec il puntatore che precede L ; Sia pTL il puntatore di scorrimento sulla parte di lista ordinata ; Sia precpT il puntatore che precede pTL;

FL, TL, L, prec, pTL, precpT, Inizializzazioni Sia TL linizio della lista ordinata; Sia FL La fine della lista ordinata; Sia L il puntatore di scorrimento sulla parte di lista non ordinata ; Sia prec il puntatore che precede L ; Sia pTL il puntatore di scorrimento sulla parte di lista ordinata ; Sia precpT il puntatore che precede pTL; Algoritmo Fino a che non termina la lista da ordinare se la chiave di L è maggiore della chiave in prec allora avanza prec e L altrimenti collega prec con il successivo di L se L è minore della chiave TL poni L in testa e aggiorna TL altrimenti scorri a partire da TL e fino a FL, utilizzando pTL, la lista ordinata. Non appena trovi una chiave maggiore di quella da inserire, la inserisci se questo non accade e arrivi alla fine della lista non ordinata allora controlla se la chiave va inserita immediatamente prima o dopo FL. In questo secondo caso dopo linserimento aggiorna FL al valore L. Continua a scorrere la lista TL pTL FL precLprecPT

Data una lista di interi non ordinata, renderla ordinata. int main() { int item; string nome;Pnodo L1; cout<<" LISTA DI PARTENZA "<<endl; costruisciLista(L1,nome); cout<<"\n LISTA ASSEGNATA"<<endl;; ordinaLista(L1,L1); stampaLista(L1); } void ordinaLista(Pnodo FL,Pnodo &TL) { Pnodo prec,L,pTL,precPT; prec=TL; L=FL->next; // parto dal secondo elemento while (L!=NULL) // scorro la lista a partire da FL { pTL=TL; if (L->info>=prec->info) // se L è maggiore del suo prec { if (prec=FL) FL=prec->next; //se il suo prec coincide con FL aggiorna FL prec=L; // aggiorna prec e L L=L->next; // avanza else // se L è minore del suo prec { //sconnetto L prec->next=prec->next->next; // collego prec con post L //per collocare L vediamo se siamo all'inizio if (L->info info) { L->next=TL; // L va in testa TL=L; } else ordinaLista4

ESERCIZIO Assegnato un insieme dei numeri interi, ad esempio tra 1 e 90, scrivere un algoritmo che, utilizzando le liste, estragga combinazioni a 5 a 5 dei suddetti numeri senza mai estrarre un numero già estratto Generatore casuale (tra 1 e 8) Numero 3 Estratto 3 Numero 4 Estratto 7 Numero 1 Estratto 8 Numero 5 Estratto tombola1

ESERCIZI Scrivere un algoritmo che trasforma una lista L di interi in una lista priva di zeri e conti il numero di elementi cancellati. Siano L1 ed L2 due liste legate che contengono interi, con L1 che contiene anche ripetizioni. Costruire una terza lista L3, senza ripetizioni, che contenga tutti gli elementi di L1 non appartenenti ad L2. Siano assegnate due liste astratte, Lpari e Ldispari. Scrivere un algoritmo che data la lista L non ordinata, contenente numeri interi pari e dispari, sposti da essa sia i numeri pari che i numeri dispari inserendoli in maniera ordinata rispettivamente nelle liste Lpari e Ldispari.

Trasformare una lista L disordinata e contenente ripetizioni in una lista ordinata senza ripetizioni che contiene soltanto gli elementi di L che si ripetono esattamente k volte. SFIDA Verifica se una lista è palindroma utilizzando una funzione ricorsiva listePalindroma2

{ precPT=NULL;// a partire da TL trova dove collocare L while ((L->info>pTL->info)&&(pTL->next!=FL)) // avanza tra TL e FL se L>pTL { precPT=pTL; pTL=pTL->next; } { if (L->info info) {precPT->next=L; //inserisci subito prima di pTL L->next=pTL; } else { // sono arrivato a FL controllo se L va prima o dopo if (L->info info) { pTL->next=L; L->next=FL; } else { L->next=FL->next; FL->next=L; FL=L; } L->next=pTL->next->next; //inserisci in mezzo pTL->next=L; } // se non ho finito incremento L L=prec->next; }

Assegnato un file di record denominato Anagrafe.dat I record hanno la seguente struct: struct TPersona { char cognome[20]; char nome[20]; Tpdata nascita; char luogo[20]; }; Mostrare a video tutti i record ordinati prima per cognome, poi per luogo e infine per data di nascita. Si possono costruire degli array di puntatori ai record e quindi ordinarli ognuno secondo il campo desiderato.

struct Tpersona { char cognome[30]; char nome[20]; Tpdata nascita; char luogo[20]; }; typedef Tpersona* Ppersona;//Ppersona è un nuovo tipo: puntatore a Tpersona // PROTOTIPI void Stampa(Ppersona[],int); void bubble(Ppersona [],int,int(*)(Ppersona,Ppersona)); int cognome(Ppersona,Ppersona); int luogo(Ppersona,Ppersona); int nascita(Ppersona,Ppersona ); // MAIN main () { Tpersona persona1; Ppersona PuntaP1[101], PuntaP2[101], PuntaP3[101]; const int Lrec=sizeof(Tpersona); fstream filepers; filepers.open(Nomefile,ios::in|ios::out|ios::binary|ios::ate); int NumPers, esiste; if (!filepers) { …………. } NumPers=filepers.tellg()/Lrec; filepers.seekg(0,ios::beg); for (int i=0; i<NumPers; i++) { filepers.read((char*) &persona1, Lrec); //leggi I dati della persona PuntaP1[i] = new Tpersona; // Inserisci i dati letti in PuntaPx[i] * PuntaP1[i] = persona1; PuntaP2[i] = PuntaP1[i]; PuntaP3[i] = PuntaP1[i]; }

cout<<" INIZIALE"<<endl; Stampa(PuntaP1,NumPers); cout<<"\n COGNOME"<<endl; bubble(PuntaP1,NumPers,cognome); Stampa(PuntaP1,NumPers); cout<<"\n LUOGO"<<endl; bubble(PuntaP2,NumPers,luogo); Stampa(PuntaP2,NumPers); cout<<"\n NASCITA"<<endl; bubble(PuntaP3,NumPers,nascita); Stampa(PuntaP3,NumPers); filepers.close(); void bubble(Ppersona vet[], int N, int(*confronta)(Ppersona,Ppersona)) { int j, k; Ppersona s; for (k=0; k<N-1; k++) { for (j=N-2; j>=k; j--) { if (confronta(vet[j], vet[j+1])>=1) { s=vet[j]; vet[j]=vet[j+1]; vet[j+1]=s; } } } } int cognome(Ppersona Px, Ppersona Py) { return ((strcmp(Px->cognome, Py->cognome))); } int luogo(Ppersona Px, Ppersona Py) { return ((strcmp(Px->luogo, Py->luogo))); } int nascita(Ppersona Px, Ppersona Py) { double data1,data2; data1=(Px->nascita.anno)*10000+(Px->nascita.mese)*100+(Px->nascita.giorno); data2=Py->nascita.anno*10000+Py->nascita.mese*100+Py->nascita.giorno; return (data1-data2); }