// PROTOTIPIvoid 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

// PROTOTIPIvoid 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 listaPnodo 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 listaint 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 item1if (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 item1if (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 un’unica 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<item)&&(L->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

Un polinomio in una sola variabile può essere rappresentato sotto forma di lista mediante due numeri, il coefficiente e la potenza della variabile (che è sempre un

numero non negativo); per esempio il polinomio P1(x)= 4x8-5x4+8 è rappresentato come: P1 Assegnati due polinomi rappresentati da due liste P1 e P2, determinare il polinomio P3

dato dalla somma di P1 e P2. Es. sia P2 (x)= 3x6+2x4-4x -2

P3(x)= 4x8+3x6-3x4-4x+6

2 4 -2 0 -4 1 3 6

3 6 6 0 -3

4 4 8 -4

1

4 8 -5 4 8 0

// MAINint 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<L2->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 listaPnodo 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<<segno<<L->coeff<<" "; else cout<<segno<<L->coeff<<"x^"<<L->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 .

TLpTL FL prec LprecPT

Definizioni

Sia TL l’inizio 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,

InizializzazioniSia TL l’inizio 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;

AlgoritmoFino a che non termina la lista da ordinare

se la chiave di L è maggiore della chiave in prec allora avanza prec e Laltrimenti collega prec con il successivo di L

se L è minore della chiave TL poni L in testa e aggiorna TLaltrimenti scorri a partire da TL e fino a FL, utilizzando pTL, la listaordinata. Non appena trovi una chiave maggiore di quella da inserire, la inserisci

se questo non accade e arrivi alla fine della lista non ordinataallora controlla se la chiave va inserita immediatamente prima o dopo FL. In questo secondo caso dopo l’inserimento aggiorna FL al valore L.

Continua a scorrere la lista

TLpTL FL prec LprecPT

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<=TL->info) { L->next=TL; // L va in testa TL=L; } else

ordinaLista4

ESERCIZIOAssegnato 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.

1

2

3

6

7

8

4

5

Generatore casuale (tra 1 e 8)

Numero 3 Estratto 3

Numero 4 Estratto 7

Numero 1 Estratto 8

Numero 5 Estratto 6---------

tombola1

ESERCIZIScrivere 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<=pTL->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<FL->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); }