1 FONDAMENTI DI INFORMATICA II Ingegneria Gestionale a.a. 2001-2002 - 4° Ciclo Liste.

Presentazione sul tema: "1 FONDAMENTI DI INFORMATICA II Ingegneria Gestionale a.a. 2001-2002 - 4° Ciclo Liste."— Transcript della presentazione:

1 1 FONDAMENTI DI INFORMATICA II Ingegneria Gestionale a.a. 2001-2002 - 4° Ciclo Liste

2 2 Liste Una lista è una struttura dati (formata da elementi dello stesso tipo e collegati insieme) la cui lunghezza può variare dinamicamente. I suoi elementi sono variabili dinamiche che vengono creati e/ o distrutti a tempo di esecuzione producendo una struttura dati che cresce o diminuisce a seconda delle esigenze del programma in esecuzione.

3 3 Liste Ogni elemento di una lista è definito come una struttura costituita da uno o più campi dati e da un campo puntatore contenente lindirizzo dellelemento successivo. struct elem { int info; elem * succ ; } ;

4 4 Ogni lista è definita da una variabile puntatore che punta al primo elemento della lista. Nel caso di assenza di elementi (lista vuota) tale variabile puntatore assume valore NULL. In una lista il campo puntatore dellultimo elemento assume sempre valore NULL. Liste

5 5 Dati 0 lislis->info lis->next Puntatore alla lista Puntatore al successivo Ultimo elemento struct rec { int info; rec *next; };

6 6 L allocazione dinamica della memoria si presta alla gestione di liste di oggetti, quando il loro numero non é definito a priori. Queste liste possono aumentare e diminuire di dimensioni dinamicamente in base al flusso del programma, e quindi devono essere gestite in un modo più efficiente dellallocazione di memoria permanente sotto forma di array Liste Allocazione dinamica di liste

7 7 Liste Inserimento in testa: dato tempp 0 lis dato tempp 0 lis rec *tempp= new rec; tempp->info= dato; tempp->next= lis; lis= tempp; dato tempp 0 lis

8 8 Liste Estrazione dalla testa: 0 lis tempp 0 lis tempp 00 lis tempp rec *tempp= lis; lis= lis->next; tempp->next= NULL;

9 9 Liste Strutture concatenate: Una struttura é detta concatenata quando é costituita, oltre che dai suoi normali membri, anche da uno o più membri aggiuntivi, dichiarati come puntatori alla struttura stessa. struct rec {int info; rec* next; }; La definizione di una struttura concatenata é di solito accompagnata da un certo numero di funzioni, che hanno il compito di gestirla, cioè eseguire le operazioni di inserimento, di eliminazione e di ricerca di oggetti.

10 10 Liste Una lista concatenata (linked list) é un insieme di oggetti, caratterizzati dal fatto di essere istanze di una struttura concatenata. In ogni oggetto, i membri puntatori alla struttura contengono l indirizzo di altri oggetti della lista, creando così un legame fra gli oggetti e rendendo la stessa lista percorribile, anche se gli oggetti non sono allocati consecutivamente in memoria. Se la struttura possiede un solo membro puntatore a se stessa, la lista é detta single-linked, se ne possiede due, é detta double-linked. Liste concatenate :

11 11 Liste Operazioni su liste : Creazione della lista (vuota) Inserimento in lista Inserimento in testa Inserimento in coda Inserimento in una posizione specifica Eliminazione di un nodo dalla lista Estrazione da lista Lettura di una lista Stampa di una lista Cancellazione di una lista

12 12 Liste Creazione della lista : Per creare una lista, basta definirla, ovvero è sufficiente creare il modo di riferirsi ad essa. Lunica cosa che esiste sempre della lista è la sua testa (o radice ) ossia il puntatore al suo primo elemento. Questa è lunica componente allocata staticamente ed è inizializzata a NULL poiché allinizio non punta a niente in quanto non ci sono elementi. lis Es.: rec* lis= NULL ; Puntatore alla lista lista NULL

13 13 La creazione di un nuovo nodo (in qualunque fase dellesistenza di una lista) avviene creando una nuova istanza della struttura tramite allocazione dinamica, utilizzando di solito un puntatore dappoggio ( tempp ) Es.: rec* tempp = new rec; Liste Creazione di un nuovo nodo : tempp info next

14 14 Liste Assegnazione di valori ai campi dati : Lassegnazione di valori ai campi dati si ottiene dereferenziando il puntatore al nodo e accedendo ai singoli dati, ovvero utilizzando direttamente loperatore -> Es.: tempp-> info= 7; 7 tempp info next

15 15 Le operazioni di inserimento di un elemento (ed analogamente quelle di cancellazione) possono avvenire secondo diverse modalità, (ovvero in diverse posizioni della lista) assumendo di volta in volta caratteristiche specifiche. Liste Inserimento in lista :

16 16 In ogni caso linserimento di un nuovo elemento nella lista prevede sempre i seguenti passi: 1) Creazione di un nuovo nodo 2) Assegnazione di valori ai campi dati 3) Collegamento del nuovo elemento alla lista esistente aggiornamento del campo puntatore del nodo aggiornamento dei puntatori della lista Queste due ultime operazioni caratterizzeranno la tipologia dellinserimento Liste Inserimento di un nuovo elemento :

17 17 Liste Inserimento in testa : Le operazioni di collegamento per linserimento in testa, utilizzano il riferimento esplicito alla testa di lista (il puntatore alla lista lis). Il campo next del nuovo nodo punterà allo stesso valore di lis lis punterà al nuovo nodo tempp-> next= lis; lis= tempp; Valido anche per linserimento iniziale ( la lista è vuota)

18 18 Liste Inserimento in testa : dato Tempp 0 lis dato tempp 0 lis dato tempp 0 lis dato Tempp 0 lis dato0 Tempp 0 lis dato0 Tempp lis tempp->next= lis; lis= tempp;

19 19 Liste Inserimento in coda : Linserimento in coda è più complesso, in quanto non abbiamo un puntatore esplicito allultimo elemento, ma dobbiamo prima scorrere la lista per cercarlo. Supponiamo di averlo trovato e che sia il puntatore p: Il campo next del nuovo nodo punterà a NULL (in quanto è lultimo) Il campo next dellex ultimo nodo punterà al nuovo nodo. Es.: tempp-> next= NULL; p-> next= tempp;

20 20 Liste Ricerca dellultimo elemento : Per cercare lultimo elemento, possiamo scorrere la lista tramite un puntatore ausiliario p, inizializzato a lis. Es: rec* p= lis; while (p-> next != NULL) p= p->next; Questa ricerca non può però applicarsi a liste vuote!

21 21 Liste Ricerca dellultimo elemento : La condizione ( p-> next != NULL ) nel caso la lista sia vuota conduce ad un errore fatale in quanto p ha il valore NULL e quindi non consente laccesso ad alcuna struttura. Questo è un tipico errore che si fa nella gestione delle strutture dinamiche!!! p-> next= ?? 0 lis p-> next p 0 lis 0 p

22 22 Liste Ricerca dellultimo elemento : La procedura corretta è: rec* p= lis; while (p!= NULL && p-> next !=NULL) p= p->next; 0 lis p-> next p 0 lis 0 p

23 23 Liste Inserimento in coda : tempp->next= p; (o NULL) p-> next dato0 0 lis p tempp 0 lis 0 p dato0 tempp lis p dato0 tempp lis 0 p dato0 tempp p->next= tempp;lis= tempp;

24 24 Liste Inserimento in una posizione specifica : Linserimento in una posizione specifica richiede preventivamente lindividuazione di tale posizione allinterno della lista e dipende dalla condizione che si vuole verificare, per cui dobbiamo prima scorrere la lista per determinarla. Vediamo ad esempio come comportarsi per inserire i valori in ordine crescente.

25 25 Liste Inserimento ordinato dei valori : Nel caso di inserimento in ordine crescente, la lista risultante deve rimanere in ogni momento ordinata. Pertanto, allinserimento di un nuovo valore, si dovrà scorrere la lista fino alla posizione corretta per linserimento (fin quando cioè il campo info dei nodi esistenti risulta minore del dato da inserire).

26 26 Liste Ricerca di un elemento qualsiasi : La condizione più sicura da utilizzare in una ricerca è riferirsi direttamente al puntatore allelemento nella condizione di scorrimento. In tal modo però si sorpassa lelemento cercato. Per questo nella ricerca della posizione di inserimento si usano di solito due puntatori, p e q, che puntano rispettivamente allelemento precedente e al successivo. Es: rec* q= lis; rec* p= lis; while (q != NULL && q-> info dato) {p= q; q= q-> next;}

27 27 Liste Ricerca di un elemento qualsiasi : rec* q= lis; rec* p= lis; while (q != NULL && q-> info dato) {p= q; q= q-> next;} 7 tempp 82 lis 100 p q 52 lis 60 p 0 q

28 28 Liste Casi particolari : rec* q= lis; rec* p= lis; while (q != NULL && q-> info dato) {p= q; q= q-> next;} 7 tempp 98 lis 100 p q Se alluscita del while si ha q= =lis, allora p non è il puntatore allelemento precedente.

29 29 Liste Inserimento ordinato dei valori : Quindi nel caso generale: tempp-> next = q; p-> next = tempp; ma se q== lis (inserimento in testa) lis= tempp

30 30 Liste Inserimento ordinato dei valori : tempp->next= q; 7 tempp 82 lis 100 p q 7 tempp 82 lis 100 p q p->next= tempp;

31 31 Liste Eliminazione di un nodo dalla lista : Leliminazione di un nodo dalla lista prevede: Ricerca del nodo da eliminare (se necessaria) Salvataggio del nodo in una variabile ausiliaria (per passo 4) Scollegamento del nodo dalla lista (aggiornamento dei puntatori della lista) Distruzione del nodo (deallocazione della memoria) In ogni caso, bisogna verificare che la lista non sia già vuota! If (lis != NULL) ….

32 32 Liste Ricerca del nodo da eliminare : Dipende dalle esigenze del programma. Come per linserimento, il caso più semplice è costituito dalleliminazione del nodo di testa, in quanto esiste il puntatore lis a questo elemento. Negli altri casi, si procede come per linserimento

33 33 Liste Scollegamento del nodo dalla lista : Individuato il nodo, bisogna evitare che la sua rimozione spezzi la lista. lis 0 00 In generale, è necessario aggiornare il puntatore next dellelemento precedente.

34 34 Liste Eliminazione del nodo di testa : Bisogna aggiornare il puntatore alla testa lis che dovrà puntare al nodo successivo a quello da eliminare. rec* tempp= lis; (salvataggio nodo da eliminare) lis = tempp-> next; (aggiornamento lista) delete tempp; (distruzione nodo)

35 35 Liste Eliminazione del nodo di coda : Bisogna aggiornare il campo next relativo al penultimo nodo, che ora diventa lultimo (e quindi assume valore NULL). Per la ricerca dellultimo elemento si usano due puntatori p e q, che puntano rispettivamente al penultimo e allultimo elemento. La condizione sarà: rec* q= lis; rec* p= lis; while (q != NULL && q-> next != NULL) {p= q;q= q-> next;} Casi particolari: lelemento da eliminare è lunico della lista.

36 36 Liste Eliminazione del nodo di coda : rec* q= lis; rec* p= lis; while (q != NULL && q-> next != NULL) {p= q;q= q-> next;} Se alluscita del while si ha q= =lis, allora p non è il puntatore allelemento precedente. 0 lis p q 0 p q

37 37 Liste Eliminazione del nodo di coda : 0 lis p q 00 p q tempp rec *tempp= q; p->next= tempp->next; oppure: p->next= NULL; tempp

38 38 Liste Eliminazione del nodo di coda : 0 lis p q tempp 00 lis p q tempp rec* tempp= q; Lis= tempp->next; oppure lis= NULL;

39 39 rec* LeggiListaI( ) { int val; cin >> val; if (val == 0) return NULL; else { rec* l = new rec; l-> info = val; rec* ll = l; cin >> val; while (val != 0) { ll-> next = new rec; ll = ll-> next; ll-> info = val; cin >> val; } ll-> next = NULL; return l; } } Lettura lista Versione iterativa rec* LeggiListaR() { int val; cin >> val; if (val == 0) return NULL; else { rec* l = new rec; l-> info = val; l-> next = LeggiListaR(); return l; } Lettura lista Versione ricorsiva Lettura di una lista da tastiera Liste

40 40 Stampa di una lista Liste void StampaListaR( rec* l) { if (l == NULL) cout << endl; else { cout info << ; StampaListaR( l-> next); } Stampa lista Versione ricorsiva void StampaListaI( rec* l) { while (l != NULL) { cout info << ; l = l-> next; } cout << endl; } Stampa lista Versione iterativa

41 41 Cancellazione di una lista Liste void CancellaListaR( rec*& l) { if (l != NULL) { CancellaListaR( l-> next); delete l; l = NULL; } Cancellazione Lista Versione ricorsiva void CancellaListaI( rec*& l) { while (l != NULL) { rec* ll = l; l = l-> next; delete ll; } l = NULL; } Cancellazione lista Versione iterativa

42 42 Esempio Liste #include struct rec { int info; rec* next; }; void main() { rec* lis; lis = LeggiListaR(); StampaListaR( lis); CancellaListaR( lis); lis = LeggiListaI(); StampaListaI( lis); CancellaListaI( lis);Programma chiamante }

43 43 Inserimento in lista Liste void instesta( rec*& lis, int a) { rec* p = new rec; p-> info = a; p-> next = lis; lis = p; } Inserimento in testa void insfondo( rec*& lis, int a) { rec* p = lis; for (rec* q = p; q != NULL; q = q-> next) p = q; q = new rec; q-> info = a; q-> next = NULL; if (p != NULL) p-> next = q; else lis = q; } Inserimento in coda

44 44 Inserimento in ordine crescente (campo info) Liste void inscresc( rec*& lis, int a) { rec* p = lis; for (rec* q = p; q != NULL && q-> info next) p = q; rec* r = new rec; r-> info = a; r-> next = q; if (q != lis) p-> next = r; else lis = r; } Inserimento in ordine crescente

45 45 Estrazione da lista Liste BOOL esttesta( rec*& lis, int& a) { rec* p = lis; if (lis != NULL) { a = lis-> info; lis = lis-> next; delete p; return T; } return F; } Estrazione dalla testa

46 46 Estrazione da lista Liste BOOL estfondo( rec*& lis, int& a) { rec* p = lis; if (lis != NULL) { for (rec* q = p; q-> next != NULL; q = q-> next) p = q; a = q-> info; if (q == lis) lis = NULL; else p-> next = NULL; delete q; return T; } return F; }Estrazione dal fondo

47 47 Estrazione da lista Liste BOOLEAN togli( rec*& lis, int a) { rec* p = lis; for (rec* q = p; q != NULL && q-> info != a; q = q-> next) p = q; if (q != NULL) { if (q == lis) lis = p-> next; p-> next = q-> next; delete q; return T; } return F; } Estrazione di un elemento specifico

48 48 Inserimenti in versione ricorsiva Liste void insfondoR( rec*& lis, int a) { if (lis != NULL) insfondoR( lis-> next, a); else { rec* p = new rec; p-> info = a; p-> next = NULL; lis= p } Inserimento in fondo Versione ricorsiva void inscrescR( rec*& lis, int a) { if (lis != NULL && lis-> info < a) inscrescR( lis-> next, a); else { rec* p = new rec; p-> info = a; p-> next = lis; lis= p } Inserimento in ordine Versione ricorsiva

49 49 Estrazioni in versione ricorsiva Liste BOOL estfondoR( rec*& lis, int& a) { if (lis != NULL) { if (lis-> next != NULL) return estfondoR( lis-> next, a); else { a= lis-> info; delete lis; lis = NULL; return T; } else return F; }Estrazione dal fondo Versione ricorsiva BOOL togliR( rec*& lis, int a) { if (lis != NULL) { if (lis-> info != a) return togliR( lis-> next, a); else { rec* p = lis; lis = lis-> next; delete p; return T; } else return F; } Estrazione di un elemento specifico - Versione ricorsiva