1 / 29

CORSO DI PROGRAMMAZIONE II Lezione 24 MOD. A prof. E. Burattini a.a. 2009-2010

CORSO DI PROGRAMMAZIONE II Lezione 24 MOD. A prof. E. Burattini a.a. 2009-2010. ESEMPIO DI UNA CLASSE PILA. Ricordiamo che: La pila o stack è una struttura astratta composta da più elementi omogenei.

oriel
Download Presentation

CORSO DI PROGRAMMAZIONE II Lezione 24 MOD. A prof. E. Burattini a.a. 2009-2010

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. CORSO DI PROGRAMMAZIONE II Lezione 24 MOD. A prof. E. Burattini a.a. 2009-2010 Program. Mod B - Cap. 12 - prof. Burattini

  2. ESEMPIO DI UNA CLASSE PILA Ricordiamo che: La pila o stack è una struttura astratta composta da più elementi omogenei. Una pila è uno stack di dati con accessi del tipo LIFO (Last In First Out) per cui l’ultimo elemento inserito nello pila è anche il primo elemento che si può estrarre da esso. L’aggiunta di un elemento alla pila viene detta operazione di push, mentre la rimozione dallo pila viene detta operazione di pop. Vogliamo implementare una classe astratta chiamata pila i cui elementi sono numeri interi e la cui struttura è quella di un vettore. Program. Mod B - Cap. 12 - prof. Burattini

  3. Aggiungiamo alla struttura descritta un intero che indichi la posizione attuale dell’elemento da rimuovere. Indichiamo con items il vettore che contiene i componenti della pila (supposta omogenea), con top l’indice dell’elemento attuale, con push l’operazione di aggiungere oggetti e con pop quella di eliminarli. Prima di analizzare l’oggetto pila, osserviamo che dobbiamo necessariamente determinare il numero massimo di elementi che possiamo gestire: indichiamo con Max tale valore che rappresenterà una costante globale (ad esempio Max=100). I data-member della pila sono int top; int items[Max]; rigorosamente privati, mentre il costruttore dovrà inizialmente indicare che la pila è vuota ponendo top = -1; Program. Mod B - Cap. 12 - prof. Burattini

  4. In questo caso non è necessario un distruttore. Per usufruire della classe pila abbiamo la necessità di implementare i seguenti metodi: push che inserisce un oggetto della pila in cima; pop che elimina l’elemento dalla cima; cima che ne stampi semplicemente il valore senza eliminarlo; vuota, funzione booleana che restituisca true se la pila è vuota, false altrimenti; piena, funzione booleana che restituiscatrue se la pila è piena, false altrimenti; stampa, mostra a video tutti gli elementi nello stesso ordine in cui sono stati immessi. Program. Mod B - Cap. 12 - prof. Burattini

  5. Le dichiarazioni dei metodi sono riportate di seguito. #include<iostream> using namespace std; const int Max=10; class pila { public: pila() { top=-1; } void push(int e); void pop(int &e); void cima(); bool vuota(); bool piena(); friend ostream& operator<< (ostream&, pila); private: int top; int items[Max]; }; Program. Mod B - Cap. 12 - prof. Burattini

  6. Data la non eccessiva lunghezza della definizione della classe pila abbiamo ritenuto utile non spezzarla in due file, per cui utilizzeremo un solo file pilaMat.cpp in cui sono incluse sia le definizioni che le implementazioni dei vari metodi. Program. Mod B - Cap. 12 - prof. Burattini

  7. push : se la pila non è piena allora, per inserire l’elemento e in cima, s’incrementa di una unità la variabile top e si pone items[top]e; se la pila è piena si scrive “Pila piena”; pop : se la pila non è vuota allora, per eliminare l’elemento dalla cima, si restituisce prima l’elemento e posto in cima e poi si decrementa la variabile top di una unità; cima : se la pila non è vuota, stampa il valore items[top] senza eliminarlo; vuota : restituisce il valore booleano del confronto top==-1; piena: restituisce il valore booleano del confronto top==Max-1; overload di <<: stampa tutti gli elementi della pila a partire da top decrescendo fino all’indice 0. Program. Mod B - Cap. 12 - prof. Burattini

  8. // COSTRUZIONE E GESTIONE DI UNA PILA CON UN VETTORE E LISTE - pileMat.h #include<iostream> using namespace std; const int Max=10; // CLASSE class pila { public: pila() { top=-1; } void push(int e); void pop(int &e); void cima(); bool vuota(); bool piena(); friend ostream& operator<< (ostream&, pila); private: int top; int items[Max]; }; // -------------------------- DEFINIZIONI void pila::push(int e) { if (!piena()) { top++; items[top]=e; } else cout<<"Pila piena"<<endl; } void pila::pop(int& e) { if(!vuota()) { e=items[top]; top--; } else cout<<"Errore la pila è vuota"<<endl; } void pila::cima() { if(!vuota()) cout<<"elemento in cima = "<<items[top]<<endl; else cout<<"Non ci sono elementi nella pila "<<endl; } bool pila::vuota() { return (top==-1); } bool pila::piena() { return (top==Max-1); } ostream& operator<< (ostream& os, pila p) { os<<"("; for(int i=p.top; i>=0; i--) os<<p.items[i]<<" "; os<<")"<<endl; return os; } Program. Mod B - Cap. 12 - prof. Burattini

  9. #include<iostream> //#include"pileMat.h" using namespace std; // MAIN int main() { pila A; int e, scelta=-1; do { cout<<"\n MENU PILA "<<endl; cout<<"1) Inserisci elemento nella pila"<<endl; cout<<"2) Preleva elemento dalla pila"<<endl; cout<<"3) Verifica pila vuota"<<endl; cout<<"4) Verifica pila piena"<<endl; cout<<"5) Visualizza elemento della pila"<<endl; cout<<"6) Visualizza elenco della pila"<<endl; cout<<"0) ESCI"<<endl; cout<<"\n Inserisci scelta : "; cin>>scelta; switch(scelta) { { case 1: cout<<endl<<"Dammi il valore dell'elemento da inserire nella pila: (0 per finire) "; cin>>e; while (e!=0){ if (A.piena()) { cout<<"\n\a La pila e' piena !!\n"; e=0;} else { A.push(e); cout<<endl<<"Dammi il valore dell'elemento da inserire nella pila: (0 per finire) "; cin>>e; } } break; case 2: if(!A.vuota()) { A.pop(e); cout<<"\n L'elemento prelevato dalla testa alla pila e' : "<<e<<endl; } else cout<<"\n\n LA PILA e' VUOTA \a\n\n"; break; Program. Mod B - Cap. 12 - prof. Burattini pile

  10. ESERCIZIO Assegnata la classe Pila avente la seguente descrizione class pila { public: pila() { top=-1; } void push(int e); void pop(int &e); void cima(); bool vuota(); bool piena(); friend ostream& operator<< (ostream&, pila); private: int top; int items[Max]; }; Scrivere un algoritmo che gestisca i dati introdotti nella pila con la strategia FIFO invece che LIFO Program. Mod B - Cap. 12 - prof. Burattini

  11. // COSTRUZIONE E GESTIONE DI UNA CODA UTILIZZANDO PILE #include<iostream> # include"pileMat.h" using namespace std; void creaCoda1(pila &,pila &); // MAIN int main() { pila A,B; int e, scelta; do { cout<<"\n MENU PILA "<<endl; cout<<"1) Inserisci elemento nella coda"<<endl; cout<<"2) Preleva elemento dalla coda"<<endl; cout<<"3) Verifica coda vuota"<<endl; cout<<"4) Verifica coda piena"<<endl; cout<<"5) Visualizza elemento in testa alla coda"<<endl; cout<<"6) Visualizza elenco della coda"<<endl; cout<<"0) ESCI"<<endl; cout<<"\n Inserisci scelta : "; cin>>scelta; switch(scelta) { Program. Mod B - Cap. 12 - prof. Burattini

  12. case 1: creaCoda1(A,B); cout<<"\n PILA "<<endl; cout<<A<<endl; cout<<"\n CODA "<<endl; cout<<B<<endl; break; case 2: if(!B.vuota()) { B.pop(e); cout<<"\n L'elemento prelevato dalla testa della coda e' : "<<e<<endl;} else cout<<"\n\n LA CODA e' VUOTA \a\n\n"; break; case 3: if(B.vuota()) cout<<"\n\a La coda e' vuota !!\n"; else cout<<"\n La coda non e' vuota !\n"; break; case 4: if(B.piena()) cout<<"\n la coda e' piena !!"; else cout<<"\n La coda non e' piena !"; break; case 5: B.cima(); break; case 6: cout<<B; break; } } while(scelta); return 0; } // DEFINIZIONI void creaCoda1(pila &Ax,pila &Bx) { int elem,ex;pila q; while (!Bx.vuota()) { Bx.pop(elem); Ax.push(elem);} cout<<endl<<"Dammi il valore dell'elemento da inserire: (0 per finire) "; cin>>elem; while (elem!=0) { Ax.push(elem); cout<<endl<<"Dammi il valore dell'elemento da inserire: (0 per finire) "; cin>>elem;} while (!Ax.vuota()) { Ax.pop(elem); Bx.push(elem); } } Program. Mod B - Cap. 12 - prof. Burattini

  13. Una versione ricorsiva per creare una pila e una coda contemporaneamente. void crea_pila_coda(pila &Ax, pila &Bx, int elex) { cout<<endl<<"Dammi il valore dell'elemento da inserire: (0 per finire) "; cin>>elex; { if (elex!=0) { Ax.push(elex); leggidati(Ax,Bx, elex); } } { if (elex!=0) Bx.push(ela); } } Program. Mod B - Cap. 12 - prof. Burattini

  14. Come costruire un riconoscitore di sequenze palindrome usando le pile bool palindroma(pila &A,pila &B) {int elemA,elemB; bool flag=true; while( (!A.vuota())&&(!B.vuota())) { A.pop(elemA); B.pop(elemB); if (elemA!=elemB) flag=false; } return flag; } pila_coda Program. Mod B - Cap. 12 - prof. Burattini

  15. Program. Mod B - Cap. 12 - prof. Burattini

  16. Una versione ricorsiva per la creazione di pila e coda contemporaneamente void crea_pila_coda(pila &Ax, pila &Bx, int elex) { cout<<endl<<"Dammi il valore dell'elemento da inserire: (0 per finire) "; cin>>elex; { if (elex!=0) { Ax.push(elex); crea_pila_coda(Ax,Bx, elex); } } {if (elex!=0) Bx.push(elex); } } Program. Mod B - Cap. 12 - prof. Burattini

  17. Assegnate due sequenze di caratteri, utilizzando i metodi della classe pila sotto indicati, scrivere una funzione booleana che verifichi, se le due sequenze sono una l’inversa dell’altra. class Pila { Pila() //costruttore, inizializza a lista vuota push(char e) //inserisce il carattere e in testa alla pila pop(char & e) //elimina il carattere e dalla testa della pila int lung() // fornisce la lunghezza della lista bool piena() bool vuota() } Es. 1a sequenza – ROMA 2a sequienza - AMOR Program. Mod B - Cap. 12 - prof. Burattini

  18. //MAIN { pila P1,P2,P3; char e; crea_pila(P1) crea_pila_coda(P2,P3); cout<<“ Le due sequenze “; if (!inversa(P1,P3)) cout<<“ non “; cout<< sono l’una l’inversa dell’altra”<<endl; } void crea_pila(Pila &P) {cout<<endl<<"Dammi elemento "; cin>>e; while (e!=0){ if (A.piena()) { cout<<"\n\a La pila e' piena; e=0;} else { P.push(e); cout<<endl<<"Dammi elemento) "; cin>>e; } } bool inversa(Pila Pa, Pila Pb) { if (Pa.vuota) return true; else Pa.pop(Ea); Pb.pop(Eb); if (Ea!=Eb) || ((Pa.lung()==Pb.lung) return false; else return inversa(Pa, Pb); } void crea_pila_coda(pila &Ax, pila &Bx, char elex) { cout<<endl<<"Dammi elemento "; cin>>elex; if (elex!=0) { Ax.push(elex); crea_pila_coda (Ax,Bx, elex); } { if (elex!=0) Bx.push(elex); } } Program. Mod B - Cap. 12 - prof. Burattini

  19. L k 9 9 9 9 3 3 8 8 8 8 5 5 7 7 5 5 k 9 9 3 3 8 8 5 5 7 7 Sia data una lista circolare L i cui elementi, a partire da quello in posizione k noto sono ordinati in maniera crescente e con ripetizioni, e l’elemento in posizione k non presenta ripetizioni. A partire da k scrivere una funzione ricorsiva che elimini le ripetizioni dalla lista e conti quanti sono gli elementi rimasti. Le function disponibili sono: class lista { lista() // costruttore, inizializza a lista vuota. int estrai(int n) // ritorna il valore dell’elemento di posto n, se esiste, MAX_INT altrimenti void cancella(int n) //cancella l’elemento di posizione n se esiste. …………..} Program. Mod B - Cap. 12 - prof. Burattini

  20. L k 9 9 9 9 3 3 8 8 8 8 5 5 7 7 5 5 k 9 9 3 3 8 8 5 5 7 7 Sia data una lista circolare L (v. fig.) i cui elementi, a partire da quello in posizione k noto sono ordinati in maniera crescente e con ripetizioni, e l’elemento in posizione k non presenta ripetizioni. A partire da k scrivere una funzione ricorsiva che elimini le ripetizioni dalla lista e conti quanti sono gli elementi rimasti. // MAIN La lista L e k sono già noti { int i=k+1; eleK=L.estrai(k); while (L.estrai(i)!=elek) {if (L.estrai(i)== L.estrai(i+1) L.cancella(i); else i++; }} Program. Mod B - Cap. 12 - prof. Burattini

  21. /* Dato un albero BST contare quanti nodi ci sono al di sotto di un nodo preassegnato con chiave multipla di un preassegnato K.*/ Tnodo TrovaDatoT(int d, Tnodo A) { if (A==NULL) return NULL; else if (d==A->key) return A; else if ( A->key > d) return TrovaDatoT(d,A->left); else return TrovaDatoT(d,A->right); } alberi eser 1 int conta(Tnodo N, int k) { int h=0; if (N==NULL) return 0; else if (N->key%k==0) {cout<<N->key<<" ";h=1;} return h+conta(N->left,k)+conta(N->right,k); } Program. Mod B - Cap. 12 - prof. Burattini

  22. /* Dato un albero BST contare quanti fratelli hanno la somma delle chiavi dispari.*/ alberi eser 2 int conta(Tnodo N) { if (N==NULL) return 0; else if ((N->left!=NULL)&&(N->right!=NULL)) { if ((N->left->key+N->right->key)%2==1) {cout<<N->left->key<<" "<<N->right->key<<endl; return 1+conta(N->left)+conta(N->right);} else return conta(N->left)+conta(N->right); } else return conta(N->left)+conta(N->right); } Program. Mod B - Cap. 12 - prof. Burattini

  23. Si hanno a disposizione le seguenti funzioni membro: class lista { lista() // costruttore, inizializza a lista vuota. int lung() // fornisce la lunghezza della lista. int estrai(int n) // ritorna il valore dell’elemento di posto n, se esiste, MAX_INT altrimenti void cancella(int n) // cancella l’elemento di posizione n se esiste. void inserisci(int m,int i) // se L =(c1,..,ci,.., cn) L diventa (c1,..ci,m,.., cn) int pos(int m) // pos = k se ck è il primo elemento di L uguale a m altrimenti pos = 0. } Utilizzando tali funzioni trasformare una lista L disordinata e contenente ripetizioni nella lista ordinata senza ripetizioni che contiene soltanto gli elementi di L che si ripetono esattamente k volte. Program. Mod B - Cap. 12 - prof. Burattini 2A

  24. Date due liste L1 e L2 di interi non ordinate, costruire una lista L3 ordinata senza ripetizioni e senza i nodi con chiave multipla di un prefissato K. listeSortNoRip Trovare l’errore Program. Mod B - Cap. 12 - prof. Burattini

  25. Siano assegnate due liste astratte di interi L1 ed L2, non ordinate, per cui sono disponibili solo le seguenti funzioni-membro: class Lista { Lista() //costruttore, inizializza a lista vuota int estrai(int n) //ritorna il valore dell’elemento di posto n se esiste, MAX_INT altrimenti int lung() // fornisce la lunghezza della lista void inserisciOrdinato(int n) //inserisce in ordine crescente l’intero n nella lista void cancella(int n) // cancella l’elemento posto nella posizione n, se esiste bool primo(int n) // ritorna vero se n è primo } Costruire la lista L3, ordinata in modo crescente, che contenga tutti i numeri pari appartenenti ad L1 e non appartenenti ad L2 e tutti i numeri primi>2 appartenenti sia ad L1 che a L2. Es. L1= {12,13, 25, 44, 1, 20, 7,6,11} L3={6,7, 12,13,20 } L2= {5,6, 15, 17, 2,13, 44, 7} Program. Mod B - Cap. 12 - prof. Burattini 3A

  26. Data la lista astratta L1 contenente interi relativi, scrivere un algoritmo che pone i numeri negativi di L1 nella lista Lneg in ordine decrescente e i numeri positivi o nulli nella lista Lpos in ordine crescente. Si hanno a disposizione le seguenti funzioni membro: class lista { lista() // costruttore, inizializza a lista vuota. int estrai(int n) // ritorna il valore dell’elemento di posto n, se esiste, MAX_INT altrimenti void cancella(int n) //cancella l’elemento di posizione n se esiste. int lung() // fornisce la lunghezza della lista. void inserisci(int n, int k) // Inserisce l’intero k nel posto ennesimo se n è minore o uguale alla lunghezza della lista più uno. …………..} A4 Program. Mod B - Cap. 12 - prof. Burattini

  27. Sia data una lista con nodi del tipo struct Lnodo { int info; Lnodo *prec; }; Scrivere una procedura che elimini i nodi a partire dalla coda. Program. Mod B - Cap. 12 - prof. Burattini

  28. Scrivere una procedura che, utilizzando le function per le code mostrate a lezione trasformi una preassegnata coda in una pila. Program. Mod B - Cap. 12 - prof. Burattini

  29. FINE Program. Mod B - Cap. 12 - prof. Burattini

More Related