Dispensa 18 CORSO DI PROGRAMMAZIONE A.A CORSO DI LAUREA IN INGEGNERIA E SCIENZE INFORMATICHE CESENA. Laboratori

Transcript

1 ORSO I LURE IN INGEGNERI E SIENZE INFORMTIHE ESEN ORSO I PROGRMMZIONE ispensa 18 Laboratori ott. Mirko Ravaioli mirko.ravaioli@unibo.it

2 orso di Programmazione ispensa 18 Liste Inserimento in onsiderando le seguenti strutture dati e variabili: struct cella{ char valore; struct cella *next; }; struct cella * = ; ove cella è la struttura che definisce come è fatto ogni elemento della lista, è il puntatore al primo elemento della lista ( mantiene l indirizzo di memoria della prima cella in lista). ttraverso una chiamata alla funzione malloc() allochiamo in memoria lo spazio necessario per mantenere la nuova cella da inserire all interno della lista: 1 = (struct cella*)malloc(sizeof(struct cella)); Pagina 2 di 49

3 orso di Programmazione ispensa 18 è un puntatore ad un elemento di tipo struct cella allo stesso modo di, la funzione malloc() restituisce l indirizzo di memoria della prima cella allocata, tale indirizzo viene memorizzato all interno della variabile (puntatore). La prima operazione da compiere è collegare la nuova cella alla prima della lista, quindi fare in modo che l elemento next della nuova cella prenda lo stesso valore di : 2 ->next = ; La seconda operazione consiste nell associare la al elemento creato: 3 = ; In modo da ottenere l inserimento del elemento in : 4 Pagina 3 di 49

4 orso di Programmazione ispensa 18 Se non si seguono esattamente nell ordine indicato i passi indicati in precedenza e ad esempio come primo passo si associa la della lista al elemento: ERRORE! se fatto come primo passo si perde il riferimento al resto della lista! Si perde il riferimento al resto della lista quindi non sarà possibile collegare il elemento con il resto della lista! Riassumendo il codice necessario per l inserimento di un elemento in lista: = (struct cella*)malloc(sizeof(struct cella)); ->next = ; = ; Le istruzioni descritte funzionano anche considerando una lista vuota: 1 = (struct cella*)malloc(sizeof(struct cella)); Pagina 4 di 49

5 orso di Programmazione ispensa >next = ; 3 = ; 4 Pagina 5 di 49

6 orso di Programmazione ispensa 18 Stampa degli elementi il lista onsiderando la struttura dati e le variabili definite nel punto precedente, la stampa consiste nel accedere ad ogni elemento della lista partendo dal primo elemento in. 1 con ->valore si accede alla proprietà della prima cella Per poter leggere i valori nella seconda cella bisogna accedere a tale cella: 2 = ->next permette di passare alla cella successiva dopo aver eseguito = ->next si ottiene: ora con ->valore è possibile accede alla proprietà della seconda cella si procede eseguendo nuovamente = ->next per accedere alla terza cella: Pagina 6 di 49

7 orso di Programmazione ispensa 18 = ->next permette di passare alla cella successiva 3 ora con ->valore è possibile accede alla proprietà della terza cella Ripetendo le operazioni viste nei punti precedenti si accede alla fine della lista: 4 Pagina 7 di 49

8 orso di Programmazione ispensa 18 Quindi la logica è quella di accedere a tutti gli elementi della lista fino a quando non si arriva alla fine della lista e cioè al valore. Quindi riassumendo il codice potrebbe essere: while (!= ) { printf( %d, ->valore); tesa = ->next; } Procedendo in questo modo però dopo aver stampato la lista si perde il riferimento al primo elemento della lista, e quindi alla lista intera! Quindi prima di scorrere la lista bisognerebbe tener traccia del primo elemento attraverso un altro puntatore: temp 1 temp = ; 2 temp = temp->next; temp Pagina 8 di 49

9 orso di Programmazione ispensa 18 3 temp = temp->next; temp 4 temp = temp->next; temp Pagina 9 di 49

10 orso di Programmazione ispensa 18 In questo modo arrivati alla fine della lista il riferimento al primo elemento non è andato perso. on l istruzione temp = si riesce a ripristinare lo stato iniziale. temp = ; while (!= ) { printf( %d, ->valore); = ->next; } = temp; E preferibile muoversi all interno della lista (scorrere la lista) con un puntatore diverso dalla e non con il riferimento alla (così si evita di dimenticarsi di tener traccia del primo elemento!!) temp = ; while (temp!= ) { printf( %d, temp->valore); temp = temp ->next; } In questo modo dopo aver eseguito la stampa il riferimento alla non è stato modificato! Pagina 10 di 49

11 orso di Programmazione ispensa 18 Ricerca di un elemento in lista La ricerca è simile alla stampa: bisogna scorrere la lista fino ad individuare l elemento cercato: temp = ; trovato = 0; while (temp!= ) { if (temp->valore = valoreaercare) { trovato = 1; break; } temp = temp ->next; } if (trovato) printf( Il valore cercato è presente in lista! ); else printf( valore NON trovato ); ll interno dell analisi della lista (dentro al ciclo while) attraverso un controllo con un istruzione if è possibile valutare se la cella corrente è quella cercata, la variabile trovato ci permette di sapere al di fuori del ciclo se l elemento cercato è presente o meno all interno della lista. Se entriamo dentro al corpo dell istruzione if la variabile trovato viene impostata al valore 1 altrimenti rimane settata al valore 0. Pagina 11 di 49

12 orso di Programmazione ispensa 18 Numero di occorrenze di un elemento in lista Questa operazione è simile a quella del punto precedente (in questo caso bisogna però contare quante volte un elemento è ripetuto all interno della lista): temp = ; conta = 0; while (temp!= ) { if (temp->valore = valoreaercare) conta++; temp = temp ->next; } printf( L elemento cercato è presente %d volte!,conta); Numero di elementi in lista temp = ; conta = 0; while (temp!= ) { conta++; temp = temp ->next; } printf( La lista ha %d elementi!,conta); Pagina 12 di 49

13 orso di Programmazione ispensa 18 Inserimento di un elemento in coda alla lista Per poter inserire un elemento in coda alla lista prima bisogna procedere a scorrere la lista fino ad arrivare all ultimo elemento: 1 temp temp = ; while (temp->next!= ) temp = temp ->next; ome negli esempi precedenti la lista viene scorsa attraverso un puntatore d appoggio (cursore) in modo da non perdere il riferimento al primo elemento 2 temp attraverso la funzione malloc() viene creato il elemento: = (struct cella*)malloc(sizeof(struct cella)); Pagina 13 di 49

14 orso di Programmazione ispensa 18 3 temp Il puntatore all elemento successivo dell ultima cella viene fatto puntare alla nuova cella: temp->next = ; isogna fare attenzione in quanto se la lista è vuota non bisogna scorrere la lista ma semplicemente far puntare il puntatore alla al elemento. Il codice per questa funzionalità è: = (struct cella*)malloc(sizeof(struct cella)); if ( == ) = ; else { temp = ; while (temp->next!= ) temp = temp ->next; temp->next = ; } Pagina 14 di 49

15 orso di Programmazione ispensa 18 ancellazione dell elemento in alla lista Prima di cancellare l elemento in, il riferimento alla della lista deve passare al secondo elemento per evitare di perdere l intera lista: 1 temp Viene utilizzato un puntatore temp per tener traccia del primo elemento prima di far puntare a all elemento successivo: temp = ; = ->next; 2 temp a questo punto è possibile eliminare il primo elemento attraverso la funzione free(): 3 temp free(temp); Pagina 15 di 49

16 orso di Programmazione ispensa 18 ancellazione di un elemento in lista Per cancellare un elemento dalla lista bisogna prima individuare l elemento all interno della lista, quindi bisogna avviare una procedura di ricerca vista in precedenza per arrivare all elemento da eliminare. temp opo aver individuato l elemento da eliminare (ad esempio la cella considerando l esempio precedente), bisogna rimuoverlo dalla lista. Per eliminare correttamente l elemento senza alterare la catena che collega un elemento ad un altro, bisogna far in modo che l elemento che precede la cella da eliminare venga collegato all elemento che segue la cella da eliminare, quindi: temp Però per poter fare questo è necessario avere un riferimento all elemento precedente della cella da eliminare. Quindi oltre al cursore temp che ci consente di scorrere la lista è necessario un ulteriore puntatore (ad esempio prec ) che di volta in volta ci permetta di tener traccia dell elemento precedente di quello considerato. Supponiamo di dover eliminare la cella, quindi dovremo scorrere la lista fino ad arrivare a tale cella. Pagina 16 di 49

17 orso di Programmazione ispensa 18 prec 1 temp ome prima operazione il cursore temp punta alla stessa cella della, ovviamente il precedente del primo elemento non esiste quindi il riferimento prec sarà a temp = ; ptec = ; prec 2 temp Prima di accedere all elemento successivo bisogna tener traccia dell elemento che si sta per lasciare: prec = temp; Pagina 17 di 49

18 orso di Programmazione ispensa 18 prec 3 temp Si procede passando all elemento successivo: temp = temp->next; I punti 2 e 3 si ripetono fino ad arrivare all elemento da eliminare : prec 4-4 temp 4- Pagina 18 di 49

19 orso di Programmazione ispensa 18 La situazione prima di eliminare l elemento è: prec 5 Prima di eliminare l elemento bisogna collegare la cella precedente () a quella successiva (): prec temp 6 temp prec->next = temp->next; in modo da ottenere: 7 prec temp on la funzione free() eliminiamo la cella puntata da temp free(temp); Pagina 19 di 49

20 orso di Programmazione ispensa 18 Quindi riassumendo il codice per eliminare un elemento dalla lista: prec = ; temp = ; while (temp!= ) { if (temp->valore == elementoaeliminare) { prec->next = temp->next; free(temp); break; } prec = temp; temp = temp->next; } isogna fare attenzione in quanto se l elemento da eliminare è il primo della lista, il codice riportato precedente genera la perdita del riferimento alla della lista: prec temp ERRORE! in questo modo si perde il riferimento alla della lista! Pagina 20 di 49

21 orso di Programmazione ispensa 18 Quindi il codice corretto diventa: prec = ; temp = ; while (temp!= ) { if (temp->valore == elementoaeliminare) { if (prec == ) = ->next; else prec->next = temp->next; free(temp); break; } prec = temp; temp = temp->next; } prima di eliminare un elemento bisogna controllare se questo è l elemento in alla lista, in tal caso bisogna muovere il riferimento alla. Pagina 21 di 49

22 orso di Programmazione ispensa 18 ancellare tutte le occorrenze di un elemento in lista Questa funzionalità è simile alla precedete solo che dopo aver eliminato la prima occorrenza dell elemento non bisogna uscire dal ciclo ma procedere alla ricerca di altre occorrenze: prec = ; temp = ; while (temp!= ) { if (temp->valore == elementoaeliminare) { if (prec == ) = ->next; else prec->next = temp->next; elimina = temp; temp = temp->next; free(elimina); } else { prec = temp; temp = temp->next; } } ato che bisogna procedere con l analisi della lista non è possibile eliminare a partire da temp in quanto verrà utilizzato all iterazione successiva per considerare il elemento. Pagina 22 di 49

23 orso di Programmazione ispensa 18 Swap di due elementi in lista L operazione di swap consiste nello scambiare di posto due elementi all interno della lista. Per eseguire questa operazione bisogna considerare diverse cose: individuare il primo elemento da spostare individuare il secondo elemento da spostare considerare cosa fare se uno dei due elementi è il primo della lista considerare cosa fare se i due elementi sono consecutivi all interno della lista (uno attaccato all altro) Ovviamente in base a quanto detto prima le operazioni da implementare possono essere differenti. Per individuare gli elementi da spostare bisogna implementare una ricerca all interno della lista per ottenere i riferimenti necessari rispettivamente al primo e al secondo elemento (si ripete 2 volte la ricerca vista nei punti precedenti). ome per la cancellazione di un elemento servirà un puntatore all elemento precedente per poter sistemare a modo tutti i riferimenti. onsiderando che nessuno dei due elementi sia in alla lista e che gli elementi non siano consecutivi: precprimo precsecondo E F primo secondo i puntatori primo e secondo si riferiscono rispettivamente alla prima e alla seconda cella da invertire, mentre precprimo e precsecondo sono puntatori agli elementi che precedono primo e secondo. Pagina 23 di 49

24 orso di Programmazione ispensa 18 opo l operazione di swap, la lista dovrebbe diventare (usando qualche puntatore d appoggio): 4 precprimo 1 precsecondo E F primo 2 secondo 3 riorganizzando un po : precprimo precsecondo E F secondo primo Vediamo ora il dettaglio dei passi per arrivare a quanto visto sopra. Pagina 24 di 49

25 orso di Programmazione ispensa 18 1 precprimo precsecondo E F primo secondo precprimo->next = secondo; 2 precprimo precsecondo E F primo secondo precsecondo->next = primo; Pagina 25 di 49

26 orso di Programmazione ispensa 18 3 precprimo temp precsecondo E F primo secondo Per evitare di perdere il riferimento all elemento successivo di primo, prima di spostare il riferimento next di primo salviamo tale valore in una variabile d appoggio temp temp = primo->next; primo->next = secondo->next; precprimo temp precsecondo E F primo secondo Pagina 26 di 49

27 orso di Programmazione ispensa 18 4 precprimo temp precsecondo E F primo secondo secondo->next = temp; 5 precprimo precsecondo E F primo secondo Pagina 27 di 49

28 orso di Programmazione ispensa 18 ome descritto in precedenza troveremo delle differenze nel caso in cui uno dei due elementi da spostare è in alla lista, in quanto parte delle operazioni riguarderanno il riferimento alla della lista: precprimo 1 4 precsecondo E primo 2 secondo 3 avremo quindi: precsecondo E primo secondo Pagina 28 di 49

29 orso di Programmazione ispensa 18 Un altro caso particolare lo troveremo quando gli elementi da invertire sono uno di seguito all altro: 2 precprimo precsecondo 3 primo secondo 1 avremo quindi: precprimo precsecondo primo secondo Pagina 29 di 49

30 orso di Programmazione ispensa 18 Riassumendo il codice necessario per lo swap di due elementi in lista, considerando che primo sia il puntatore al primo elemento, secondo sia il puntatore al secondo elemento, precprimo sia il puntatore all elemento precedente del primo e sia impostato a nel caso tale elemento sia in, precsecondo sia il puntatore all elemento che precede secondo ed eventualmente sia uguale a primo nel caso in cui i due elementi siano consecutivi: if (precprimo == ) //il primo elemento è in = secondo; else precprimo->next = secondo; if (precsecondo->next == primo) //se due elementi sono consecutivi temp = primo; else { temp = primo->next; precsecondo->next = primo; } primo->next = secondo->next; secondo->next = temp; Pagina 30 di 49

31 orso di Programmazione ispensa 18 Inserimento di un elemento attraverso una funzione Proviamo a scrivere una funzione che ci consenta di inserire un elemento all interno della lista, considerando tutte le variabili locali (anticipiamo che questo primo esempio è sbagliato! spiegheremo poi il perchè). 1 #include <stdio.h> 2 #include <stdlib.h> 3 4 struct cella{ 5 char valore; 6 struct cella *next; 7 }; 8 9 void inserisci(struct cella *t, char val); int main() 12 { 13 struct cella * = ; //...altre operazioni inserisci(, ); //...altre operazioni return 0; 22 } void inserisci(struct cella *t, char val) 25 { 26 struct cella *; = (struct cella*)malloc(sizeof(struct cella)); 29 ->valore = v; 30 ->next = t; 31 t = ; 32 } Pagina 31 di 49

32 orso di Programmazione ispensa 18 erchiamo di capire dove si trova l errore analizzando, tra le altre cose, quello che accade in memoria mentre le varie istruzioni vengono eseguite. Prima della chiamata all interno del main() della funzione inserisci, la lista sarà: in memoria quindi potremo avere la seguente situaione: Quando la funzione inserisci viene chiamata (riga 17) all interno del main(), il controllo viene ceduto dal chiamante (main) alla funzione chiamata (inserisci), tutte le variabili della funzione inserisci() vengono allocate in memoria (incluse quelle presenti all interno dell inzione). Pagina 32 di 49

33 orso di Programmazione ispensa 18 Quindi la situazione in memoria sarà: val t I parametri passati alla funzione verranno copiati nelle variabili presenti nell inzione nell ordine in cui sono stati inseriti, quindi t prenderà il valore presente all interno di e val il carattere (riga 24 e 26): val t Pagina 33 di 49

34 orso di Programmazione ispensa 18 ttraverso la funzione malloc() verrà allocata la nuova cella in memoria, l indirizzo del primo byte allocato verrà restituito dalla funzione malloc() e inserito (riga 28) all interno della variabile : val t Il valore presente all interno della variabile val viene copiato all interno dell elemento valore della nuova cella creata, referenziata dal puntatore (riga 29): val t Pagina 34 di 49

35 orso di Programmazione ispensa 18 Quindi la situazione a livello logico sarà: t Pagina 35 di 49

36 orso di Programmazione ispensa 18 ome descritto nel paragrafo la prima operazione da implementare per inserire l elemento in lista consisterà nel far puntare il puntatore next di della nuova cella a quello che punta la (->next = t): t Quindi in memoria avremo: val t Pagina 36 di 49

37 orso di Programmazione ispensa 18 ome descritto nel paragrafo la seconda operazione da fare consiste nello spostare il riferimento della, nel nostro caso t dato che siamo all interno della funzione (t = ): t Quindi in memoria avremo: val t Pagina 37 di 49

38 orso di Programmazione ispensa 18 Riassumendo in memoria avremo la seguente situazione: val t t Pagina 38 di 49

39 orso di Programmazione ispensa 18 Quando la funzione termina tutte le variabili locali vengono eliminate dalla memoria, il controllo viene restituito al chiamante (funzione main()) in memoria avremo la seguente situazione: livello logico: Quindi tutte le modifiche fatte alla della lista all interno della funzione non vengono viste all esterno! Pagina 39 di 49

40 orso di Programmazione ispensa 18 Modifichiamo il codice descritto all inizio paragrafo (in rosso le modifiche). 1 #include <stdio.h> 2 #include <stdlib.h> 3 4 struct cella{ 5 char valore; 6 struct cella *next; 7 }; 8 9 void inserisci(struct cella **t, char val); int main() 12 { 13 struct cella * = ; //...altre operazioni inserisci(&, ); //...altre operazioni return 0; 22 } void inserisci(struct cella **t, char val) 25 { 26 struct cella *; = (struct cella*)malloc(sizeof(struct cella)); 29 ->valore = v; 30 ->next = *t; 31 *t = ; 32 } La funzione inserisci() riceve ora come primo parametro un puntatore di puntatore cioè una variabile che al suo interno mantiene l indirizzo di memoria di un altra variabile che a sua volta contiene un indirizzo di memoria. Pagina 40 di 49

41 orso di Programmazione ispensa 18 Prima della chiamata all interno del main() della funzione inserisci, la lista sarà: in memoria quindi potremo avere la seguente situaione: Quando la funzione inserisci viene chiamata (riga 17) all interno del main(), il controllo viene ceduto dal chiamante (main) alla funzione chiamata (inserisci), tutte le variabili della funzione inserisci() vengono allocate in memoria (incluse quelle presenti all interno dell inzione). Pagina 41 di 49

42 orso di Programmazione ispensa 18 Quindi la situazione in memoria sarà: val t I parametri passati alla funzione verranno copiati nelle variabili presenti nell inzione nell ordine in cui sono stati inseriti, quindi t prenderà l indirizzo di memoria della prima variabile e quindi di e val il carattere (riga 24 e 26): val t Pagina 42 di 49

43 orso di Programmazione ispensa 18 ttraverso la funzione malloc() verrà allocata la nuova cella in memoria, l indirizzo del primo byte allocato verrà restituito dalla funzione malloc() e inserito (riga 28) all interno della variabile : val t Il valore presente all interno della variabile val viene copiato all interno dell elemento valore della nuova cella creata, referenziata dal puntatore (riga 29): val t Pagina 43 di 49

44 orso di Programmazione ispensa 18 Quindi la situazione a livello logico sarà: t *t *t val t con t si ottiene il valore 1001 o meglio l indirizzo di memoria che contiene il valore della variabile (puntatore), mentre con *t si accede al contenuto dell area di memoria referenziata dall indirizzo Pagina 44 di 49

45 orso di Programmazione ispensa 18 ome descritto nel paragrafo la prima operazione da implementare per inserire l elemento in lista consisterà nel far puntare il puntatore next di della nuova cella a quello che punta la (->next = *t): t *t Quindi in memoria avremo: val t Pagina 45 di 49

46 orso di Programmazione ispensa 18 ome descritto nel paragrafo la seconda operazione da fare consiste nello spostare il riferimento della, nel nostro caso t dato che siamo all interno della funzione (*t = ): t *t N. modificando *t modifichiamo anche! Quindi in memoria avremo: val t Pagina 46 di 49

47 orso di Programmazione ispensa 18 Riassumendo in memoria avremo la seguente situazione: val t t Pagina 47 di 49

48 orso di Programmazione ispensa 18 Quando la funzione termina tutte le variabili locali vengono eliminate dalla memoria, il controllo viene restituito al chiamante (funzione main()) in memoria avremo la seguente situazione: livello logico: Quindi tutte le modifiche fatte alla della lista in questo caso rimarranno! Pagina 48 di 49

49 orso di Programmazione ispensa 18 Una versione ulteriore del programma corretto potrebbe essere (in rosso le modifiche rispetto alla prima versione errata): 1 #include <stdio.h> 2 #include <stdlib.h> 3 4 struct cella{ 5 char valore; 6 struct cella *next; 7 }; 8 9 struct cella* inserisci(struct cella *t, char val); int main() 12 { 13 struct cella * = ; //...altre operazioni = inserisci(, ); //...altre operazioni return 0; 22 } struct cella* inserisci(struct cella *t, char val) 25 { 26 struct cella *; = (struct cella*)malloc(sizeof(struct cella)); 29 ->valore = v; 30 ->next = t; 31 t = ; 32 return t; 33 } In questo caso la funzione inserisci restituisce un valore, e cioè la della lista modificata (riga 32). Quando la funzione termina il valore restituito viene inserito all interno della variabile (riga 17) in modo da mantenere aggiornate le modifiche fatte. Questa versione è equivalente alla precedente. Pagina 49 di 49