Upload
cosima-tarantino
View
214
Download
1
Embed Size (px)
Citation preview
1
FONDAMENTI DI INFORMATICA IIIngegneria Gestionalea.a. 2001-2002 - 4° Ciclo
Liste
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
Liste
Ogni elemento di una lista è definito come una struttura costituita da uno o più campi dati e da un campo puntatore contenente l’indirizzo dell’elemento successivo.
struct elem{ int info; elem * succ ;} ;
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 dell’ultimo elemento assume sempre valore NULL.
Liste
5
Liste
Dati Dati Dati 0
lis lis->info lis->next
Puntatore alla lista
Puntatore al successivo
Ultimo elemento
struct rec
{
int info;
rec *next;
};
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 dell’allocazione di memoria permanente sotto forma di array
Liste
Allocazione dinamica di liste
7
ListeInserimento in testa:
datotempp
0lis
datotempp
0lis
rec *tempp= new rec;
tempp->info= dato;
tempp->next= lis;
lis= tempp;
datotempp
0lis
8
ListeEstrazione dalla testa:
0lis
tempp
0lis
tempp
0 0lis
tempp
rec *tempp= lis;
lis= lis->next;
tempp->next= NULL;
9
ListeStrutture 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
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
ListeOperazioni 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
ListeCreazione della lista:
Per creare una lista, basta definirla, ovvero è sufficiente creare il modo di riferirsi ad essa. L’unica cosa che esiste sempre della lista è la sua testa (o radice) ossia il puntatore al suo primo elemento.
Questa è l’unica componente allocata staticamente ed è inizializzata a NULL poiché all’inizio non punta a niente in quanto non ci sono elementi.
lisEs.:rec* lis= NULL ;
Puntatorealla listalista
NULL
13
La creazione di un nuovo nodo (in qualunque fase dell’esistenza di una lista) avviene creando una nuova istanza della struttura tramite allocazione dinamica, utilizzando di solito un puntatore d’appoggio ( tempp )
Es.:rec* tempp = new rec;
ListeCreazione di un nuovo nodo:
temppinfo next
14
ListeAssegnazione di valori ai campi dati:
L’assegnazione di valori ai campi dati si ottiene dereferenziando il puntatore al nodo e accedendo ai singoli dati, ovvero utilizzando direttamente l’operatore ->
Es.:tempp-> info= 7;
7temppinfo next
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.
ListeInserimento in lista:
16
In ogni caso l’inserimento di un nuovo elemento nella lista prevede sempre i seguenti passi:
1) Creazione di un nuovo nodo2) Assegnazione di valori ai campi dati3) 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 dell’inserimento
ListeInserimento di un nuovo elemento:
17
ListeInserimento in testa:
Le operazioni di collegamento per l’inserimento 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 l’inserimento iniziale ( la lista è vuota)
18
ListeInserimento in testa:
datoTempp
0lis
datotempp
0lis
datotempp
0lis
datoTempp
0lis
dato 0Tempp
0lis
dato 0Tempp
lis
tempp->next= lis;
lis= tempp;
19
ListeInserimento in coda:
L’inserimento in coda è più complesso, in quanto non abbiamo un puntatore esplicito all’ultimo 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 è l’ultimo)Il campo next dell’ex ultimo nodo punterà al nuovo nodo.
Es.:tempp-> next= NULL;p-> next= tempp;
20
ListeRicerca dell’ultimo elemento:
Per cercare l’ultimo 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
ListeRicerca dell’ultimo 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 l’accesso ad alcuna struttura.
Questo è un tipico errore che si fa nella gestione delle strutture dinamiche!!!
p-> next= ??
0lis
p-> next
p
0lis
0p
22
ListeRicerca dell’ultimo elemento:
La procedura corretta è:
rec* p= lis;while (p!= NULL && p-> next !=NULL) p= p->next;
0lis
p-> next
p
0lis
0p
23
ListeInserimento in coda:
tempp->next= p; (o NULL)
p-> nextdato 0
0lis
p
tempp
0lis
0p
dato 0tempp
lis
p
dato 0tempp
lis
0p
dato 0tempp
p->next= tempp; lis= tempp;
24
ListeInserimento in una posizione specifica:
L’inserimento in una posizione specifica richiede preventivamente l’individuazione di tale posizione all’interno 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
ListeInserimento ordinato dei valori:
Nel caso di inserimento in ordine crescente, la lista risultante deve rimanere in ogni momento ordinata.
Pertanto, all’inserimento di un nuovo valore, si dovrà scorrere la lista fino alla posizione corretta per l’inserimento (fin quando cioè il campo info dei nodi esistenti risulta minore del dato da inserire).
26
ListeRicerca di un elemento qualsiasi:La condizione più sicura da utilizzare in una ricerca è riferirsi direttamente al puntatore all’elemento nella condizione di scorrimento. In tal modo però si sorpassa l’elemento cercato.
Per questo nella ricerca della posizione di inserimento si usano di solito due puntatori, p e q, che puntano rispettivamente all’elemento precedente e al successivo.
Es:rec* q= lis; rec* p= lis;while (q != NULL && q-> info < tempp-> dato){p= q; q= q-> next;}
27
ListeRicerca di un elemento qualsiasi:
rec* q= lis; rec* p= lis;while (q != NULL && q-> info < tempp-> dato){p= q; q= q-> next;}
7tempp 82lis 10 0
p
q
52lis 6 0
p
0q
28
ListeCasi particolari:
rec* q= lis; rec* p= lis;while (q != NULL && q-> info < tempp-> dato){p= q; q= q-> next;}
7tempp 98lis 10 0
p
q
Se all’uscita del while si ha q= =lis, allora p non è il puntatore all’elemento precedente.
29
ListeInserimento ordinato dei valori:
Quindi nel caso generale:
tempp-> next = q;p-> next = tempp;
ma se q== lis (inserimento in testa)
lis= tempp
30
ListeInserimento ordinato dei valori:
tempp->next= q;
7tempp
82lis 10 0
p
q
7tempp
82lis 10 0
p
q
p->next= tempp;
31
ListeEliminazione di un nodo dalla lista:
L’eliminazione 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
ListeRicerca del nodo da eliminare:
Dipende dalle esigenze del programma.
Come per l’inserimento, il caso più semplice è costituito dall’eliminazione del nodo di testa, in quanto esiste il puntatore lis a questo elemento.
Negli altri casi, si procede come per l’inserimento
33
ListeScollegamento del nodo dalla lista:
Individuato il nodo, bisogna evitare che la sua rimozione spezzi la lista.
lis
lis
lis
0
0
0
In generale, è necessario aggiornare il puntatore next dell’elemento precedente.
34
ListeEliminazione 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
ListeEliminazione del nodo di coda:
Bisogna aggiornare il campo next relativo al penultimo nodo, che ora diventa l’ultimo (e quindi assume valore NULL).
Per la ricerca dell’ultimo elemento si usano due puntatori p e q , che puntano rispettivamente al penultimo e all’ultimo elemento.
La condizione sarà:
rec* q= lis; rec* p= lis;while (q != NULL && q-> next != NULL) {p= q;q= q-> next;}
Casi particolari: l’elemento da eliminare è l’unico della lista.
36
ListeEliminazione del nodo di coda:
rec* q= lis; rec* p= lis;while (q != NULL && q-> next != NULL) {p= q;q= q-> next;}
Se all’uscita del while si ha q= =lis, allora p non è il puntatore all’elemento precedente.
0lis
p
q
0lis
p
q
37
ListeEliminazione del nodo di coda:
0lis
p
q
0 0lis
p
q
tempp
rec *tempp= q;
p->next= tempp->next;
oppure:
p->next= NULL;
tempp
38
ListeEliminazione del nodo di coda:
0lis
p
q
tempp
00lis
p
q
tempp
rec* tempp= q;
Lis= tempp->next;
oppure
lis= NULL;
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 listaVersione ricorsiva
Lettura di una lista da tastieraListe
40
Stampa di una listaListe
void StampaListaR( rec* l){ if (l == NULL) cout << endl; else { cout << l-> info << ’ ’; StampaListaR( l-> next); }}
Stampa listaVersione ricorsiva
void StampaListaI( rec* l){ while (l != NULL) { cout << l-> info << ’ ’; l = l-> next; } cout << endl;}
Stampa listaVersione iterativa
41
Cancellazione di una listaListe
void CancellaListaR( rec*& l){ if (l != NULL) { CancellaListaR( l-> next); delete l; l = NULL; }}
Cancellazione ListaVersione ricorsiva
void CancellaListaI( rec*& l){ while (l != NULL) { rec* ll = l; l = l-> next; delete ll; } l = NULL;}
Cancellazione lista
Versione iterativa
42
EsempioListe
#include <iostream. h>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
Inserimento in listaListe
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
Inserimento in ordine crescente (campo info)Liste
void inscresc( rec*& lis, int a){ rec* p = lis; for (rec* q = p; q != NULL && q-> info < a; q = q-> 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
Estrazione da listaListe
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
Estrazione da listaListe
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
Estrazione da listaListe
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
Inserimenti in versione ricorsivaListe
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 fondoVersione 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 ordineVersione ricorsiva
49
Estrazioni in versione ricorsivaListe
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