Previously on TDP. LISTA rappresentata mediante "struct e puntatori" Cosa e aux? Di che tipo e e cosa contiene?

Transcript

1 Previously on TDP lis ^ ^ 7 21 ** ** 14 *** memoria 9 NULL LISTA rappresentata mediante "struct e puntatori" *** lis->info == cosa? lis->next == ^^; /*cosa e ^^?*/ che cosa e' (*lis)? Cosa e aux? Di che tipo e e cosa contiene? Dichiararla e disegnarla, sapendo che aux->info e il campo info contenente 21 e allora cosa contiene aux->next?? Tecniche della Programmazione, M.Temperini, - Liste Concatenate 2 1/28

2 LISTA "struct e puntatori": costruzione di una lista, usando instestalista() n volte TipoLista costrlista (int ) { TipoLista reslista ; /* 0) */ int i; ; for (i=1; i<=n; i++) { printf ( nuovo elem (intero): ); return ; /* 1) */ ; /* 2) */ Tecniche della Programmazione, M.Temperini, - Liste Concatenate 2 2/28

3 LISTA "struct e puntatori": FUNZIONE di inserimento in lista, in testa instestalista(&lis, 12) ^ lis memoria 21 la lista (21, 14) diventi in 14 void instestalista(tipolista, TipoElem ) { TipoNodo ; NULL nuovo = malloc(sizeof(tiponodo)); nuovo = el; nuovo = *plis; /* 3.1 */ ; /* 3.2 */ return; Tecniche della Programmazione, M.Temperini, - Liste Concatenate 2 3/28

4 LISTA "struct e puntatori": costruzione di una lista, usando instestalista() TipoLista costrlista (int n) { TipoLista reslista = NULL; /* 0) */ int i; TipoElem dato; for (i=1; i<=n; i++) { printf ( nuovo elem (intero): ); leggielem(&dato); /* o magari scanf("%d", &dato); se sono interi */ /* 1) */ instestalista(&reslista, dato); /* 2) */ return reslista; lis Tecniche della Programmazione, M.Temperini, - Liste Concatenate 2 4/28

5 LISTA "struct e puntatori": Tecnica di inserimento in coda lis ^ ^ 7 21 *** ** 14 NULL memoria 9 NULL Immaginiamo di aver gia costruito la lista 7, 21 e 14: aggiungiamo 9 CASO LISTA VUOTA (lis==null) CASO GENERICO (list!=null) lis = malloc( ); lis ; lis->next = ; ultimo ** *** ultimo->next = malloc(sizeof(tiponodo)); ultimo = ultimo->info = ; lis NULL Tecniche della Programmazione, M.Temperini, - Liste Concatenate 2 5/28

6 costruzione lista di n nodi interi (con inserimento in coda)...typedef int TipoElem;... TipoLista costrcoda (int n) { TipoLista ; TipoNodo * ; int i; TipoElem ; 1) lettura dato restituisce alla funzione chiamante il puntatore al nodo iniziale della lista costruita in memoria 2) inserimento CASO LISTA 3) 4) 2.1) assegnazione ultimo (con assestamento ultimo n-1 volte Tecniche della Programmazione, M.Temperini, - Liste Concatenate 2 6/28

7 lista di n nodi interi (con inserimento in coda): primo caso - lista vuota...typedef int TipoElem;... TipoLista costrcoda (int n) { TipoLista reslista = NULL; int i; TipoNodo * ultimo; TipoElem dato; if (n<=0) ; printf( primo elem? ); leggielem( ); /* 1)*/ reslista = ; /* 2) */ reslista->info = ; reslista->next = ; reslista ultimo = reslista; ultimo 7 NULL... /* resto della costruzione */ return reslista; Tecniche della Programmazione, M.Temperini, - Liste Concatenate 2 7/28

8 lista di n nodi interi (con inserimento in coda): caso generico...typedef int TipoElem;... TipoLista costrcoda (int n) { reslista TipoLista reslista = NULL; TipoNodo * ultimo; int i; TipoElem dato; ultimo if (n<=0) return NULL;... /* 1)*/... /* 2) */ reslista->info = dato; reslista->next = NULL; ultimo = reslista; /*ultimo */ for (i=0; i<n-1; i++) { 9 printf( elem? ); /* 3) */ scanf( %d, ); ultimo = malloc(sizeof(tipodato)); /* 4) */ ultimo = ultimo->next; ultimo->info = ; ultimo->next = ; return reslista; si nota che tutti i NULL inseriti nei campi next, a meno dell'ultimo, vengono cancellati da altro contenuto, praticamente appena dopo essere stati asssegnati... il cambiamento nella prossima slide evita queste assegnazioni inutili Tecniche della Programmazione, M.Temperini, - Liste Concatenate 2 8/28

9 costruzione lista di n nodi interi (con inserimento in coda) - modifica Nella versione attuale sovrascriviamo, ad ogni inserimento di un nuovo nodo, il campo next dell'elemento appena aggiunto: se ci limitiamo ad assegnare NULL al campo next del solo ultimo nodo immesso (cioe' eseguire l'assegnazione ad ultimo->next appena usciti dal ciclo di inserimenti), risparimiamo un po' di assegnazioni reslista-info = dato; reslista->next = NULL; ultimo = reslista; reslista ultimo 7 for (i=0; i<n-1; i++) { printf( primo elem? ); scanf( %d, &dato); ultimo->next = malloc(sizeof(tipodato)); ultimo = ultimo->next; ultimo->info = dato; ultimo->next = NULL; return reslista; 9 NULL Tecniche della Programmazione, M.Temperini, - Liste Concatenate 2 9/28

10 Es. funzione che legge una riga e produce la lista dei suoi caratteri...typedef char TipoElem;... TipoLista costrcoda2 () { TipoLista ris = NULL; TipoNodo * ultimo; TipoElem dato; Assumiamo almeno un carattere diverso da \n in input I = qwerty\n ris q w 1) lettura primo car. (dato) 2) 3) lettura secondo (dato) 4) 5) 6) return ris; int main () {... list = stampalista (list);... y NULL Tecniche della Programmazione, M.Temperini, - Liste Concatenate 2 10/28

11 Es. funzione che legge una riga e produce la lista dei suoi caratteri...typedef char TipoElem;... TipoLista costrcoda2 () { TipoLista ris = NULL; TipoNodo * ultimo; TipoElem dato; scanf( %c, &dato); /* 3) (e' la 'w')*/... Tecniche della Programmazione, M.Temperini, - Liste Concatenate 2 11/28

12 Es. funzione che legge una riga e produce la lista dei suoi caratteri...typedef char TipoElem;... TipoLista costrcoda2 () { TipoLista ris = NULL; TipoNodo * ultimo; TipoElem dato; int main () {... list = costrcoda2(); stampalista (list);... q printf( scrivi una riga ); /* 1) */ scanf( %c, &dato); ris = malloc(sizeof(tipodato)); ris->info=dato; ultimo=ris; scanf( %c, &dato); /* 3) (e' la 'w')*/ while(dato!= \n ) { ultimo->next = ; ultimo = ; ultimo ; scanf( %c, ); w e r t y \n NULL Tecniche della Programmazione, M.Temperini, - Liste Concatenate 2 12/28

13 Tecnica del record generatore Quindi non si puo fare ultimo->next=malloc( ).Per questo bisogna scrivere un codice (istruzioni) per un caso e altro codice, diverso, per il secondo caso. Pero, possiamo fare in modo che ultimo ci sia sempre, unificando i due casi: se facciamo cosi', le medesime istruzioni funzionano in entrambi i casi. pgen = puntatore al record generatore RECORD GENERATORE = record fittizio, che non fara parte integrante della lista ma esistera solo durante la sua Durante la costruzione della lista il RG e il primo della lista (ma non contiene informazioni rilevanti nel campo info). Al termine della manipolazione della lista (costruzione in questo caso) il RG viene deallocato. All inizio (lista vuota) viene creato il RG; e ultimo punta Adesso possiamo usare sempre il codice del Tecniche della Programmazione, M.Temperini, - Liste Concatenate 2 13/28

14 costruzione lista con inserimento in coda (tecnica del rec. gen) 1) allocazione record generatore (RG) 2) ultimo = 3) lettura dato (elemento da inserire) 4) inserimento l ultimo 4.1) 4.2) 4.3) 5) lettura prossimo elemento mentre non finito (es. dato!= \n ) 6) chiusura lista 7) ris = pgen->next (il vero primo elemento della lista) 8) eliminazione Tecniche della Programmazione, M.Temperini, - Liste Concatenate 2 14/28

15 costruzione lista con inserimento in coda (tecnica del record generatore) lista da riga di testo in input 1/3 typedef char TipoElem; struct strutturalista { TipoElem info; typedef struct strutturalista ; typedef TipoNodo * TipoLista costruiscilistacoda() { TipoLista ris ; TipoNodo * ultimo, *pgen; TipoElem dato; Tecniche della Programmazione, M.Temperini, - Liste Concatenate 2 15/28

16 costruzione lista con inserimento in coda (tecnica del record generatore) lista da riga di testo in input 2/3 TipoLista costruiscilistacoda() { TipoLista ris = NULL; TipoNodo * ultimo, *pgen; TipoElem dato; /* 1) */ pgen = if (pgen==null) { printf ( errore in allocazione del RG\n ); return NULL; /* 2) */ ultimo = printf( scrivi una riga\n ); scanf(, ); /* 3) */ while ( ) { /* 4, 5; INS. sempre caso GENERICO */ ultimo Tecniche della Programmazione, M.Temperini, - Liste Concatenate 2 16/28

17 costruzione lista con inserimento in coda (tecnica del record generatore) lista da riga di testo in input 3/3 TipoLista costruiscilistacoda() {... ultimo = pgen; printf( scrivi una riga\n ); scanf( %c,&dato); while (dato!= \n ) { ultimo->next = malloc ( ); ultimo=ultimo->next; ultimo->info = dato; scanf( %c,&dato); ultimo->next = ; ris = ; free (pgen); return ris; Tecniche della Programmazione, M.Temperini, - Liste Concatenate 2 17/28

18 LISTA "struct e puntatori": deallocazione lista - 1/3 - programma che legge e costruisce due liste, lis, lis2, le usa e poi le dealloca dalla memoria (lis con codice nella main(); lis2 con una chiamata di funzione #include int main() { TipoLista lis, lis2;... /* costruzione lis */... /* costruzione lis2 */ /* deallocazione prima lista */ free(lis); ^ 14 NULL 21 memoria 7 No, non e' questa la soluzione per considerazioni identiche a quelle fatte a proposito di deallocazione del primo elemento di una lista Tecniche della Programmazione, M.Temperini, - Liste Concatenate 2 18/28

19 LISTA "struct e puntatori": deallocazione lista - 2/ /* deallocazione prima lista */ while( ) { eliminazione (primo) elem. puntato da lis aux=lis; lis=lis->next; free(aux); mentre lis non NULL /* deallocazione seconda lista mediante chiamata di funzione */ /* side effect previsto */... FINE return ; Tecniche della Programmazione, M.Temperini, - Liste Concatenate 2 19/28

20 LISTA "struct e puntatori": deallocazione lista - 3/3 - void deallocalista(tipolista ) { TipoNodo ; while(*plis) { aux = ; *plis = free(aux); return; Tecniche della Programmazione, M.Temperini, - Liste Concatenate 2 20/28

21 LISTA "struct e puntatori": Funzione di Inserimento in coda - 1/6 - caso generale nel caso generico (lista non vuota) l'inserimento in coda non provoca una variazione del puntatore all'inizio della lista; MA NEL CASO DI INSERIMENTO IN LISTA VUOTA, SI'; quindi la chiamata da effettuare e' Algoritmo A) CASO GEN. ultimo ** 14 NULL B) CASO LVUOTA. ultimo ** Tecniche della Programmazione, M.Temperini, - Liste Concatenate 2 21/28?

22 LISTA "struct e puntatori": Funzione di Inserimento in coda - 2/6 - posizionamento puntatore ultimo ^ ^ caso generale ^ 7 21 *** memoria 14 NULL posizionamento di ultimo (punto A) TipoNodo * aux; aux=lis; while (aux) aux = aux->next; /* ora chi punta sull'ultimo nodo? */ l'unico problema e' che nel caso LISTA VUOTA se si inizializza aux con aux=lis, poi non esiste aux->next (il nodo successore) in quanto non esiste nemmeno il nodo puntato da aux... Per ovviare a questo problemino si usa la tecnica del RG... Tecniche della Programmazione, M.Temperini, - Liste Concatenate 2 22/28

23 (applicazione tecnica del Record Generatore (RG) lis ^ q w e NULL TipoNodo * aux; aux = ; while (!=NULL) aux = ; /* ora aux punta sull'ultimo nodo */ Tecniche della Programmazione, M.Temperini, - Liste Concatenate 2 23/28

24 LISTA "struct e puntatori": Funzione di Inserimento in coda - 3/6 - void insincoda(tipolista * plis, TipoElem el) { (Algoritmo che unifica i casi lista vuota e generico con la tecnica del RG) 0) allocazione record generatore (RG) e suo posizionamento in testa alla lista; 1=A)inizializzazione aux 2=B) aggiunta dopo *ultimo (il nodo puntato da ultimo) 3) sistemazione *plis (side effect, assegnandogli pgen->next) 4) chiusura lista - 5) eliminazione Tecniche della Programmazione, M.Temperini, - Liste Concatenate 2 24/28

25 LISTA "struct e puntatori": Funzione di Inserimento in coda - 4/6 - void insincoda(tipolista * plis, TipoElem el) { TipoNodo * aux *ultimo, *pgen; pgen = malloc(sizeof(tiponodo)); /* 0 */ if (!pgen) { pgen->next = /* 0 */ aux = ; /* 1 */ while( ) aux = aux->next; = aux; /* 1 - ultimo punta o l'ultimo nodo, se c'e', o il RG */ /* 2 inserimento in coda */ /* resto algoritmo */ return; Tecniche della Programmazione, M.Temperini, - Liste Concatenate 2 25/28

26 LISTA "struct e puntatori": Funzione di Inserimento in coda - 5/6 - void insincoda(tipolista * plis, TipoElem el) { TipoNodo * aux *ultimo, *pgen; pgen = malloc(sizeof(tiponodo)); /* 0 */ if (!pgen) { printf ("... eeeekkkk!!!!\n"); return; pgen-> next = *plis; /* 0 */ aux = pgen; while(aux->next) /* 1 */ aux = aux->next; ultimo = aux; /* */ /* 2 - inserimento */ /* 3 sistemazione *plis */ /* 4 eliminazione RG */ return; Tecniche della Programmazione, M.Temperini, - Liste Concatenate 2 26/28

27 LISTA "struct e puntatori": Funzione di Inserimento in coda - 6/6 - void insincoda(tipolista * plis, TipoElem el) { TipoNodo * aux *ultimo, *pgen; pgen = malloc(sizeof(tiponodo)); /* 0 */ if (!pgen) { printf ("... eeeekkkk!!!!\n"); return; pgen-> next = *plis; /* 0 */ aux = pgen; while(aux->next) /* 1 */ aux = aux->next; ultimo = aux; /* 1 - ultimo punta... */ ultimo->next = malloc(sizeof(tiponodo)); /* 2 */ if (ultimo->next == NULL) printf("... problemi in alloc. nuovo nodo */ else { ultimo->next->info = el; ultimo->next->next = NULL; Tecniche della Programmazione, M.Temperini, - Liste Concatenate 2 27/28