a.a Codice corso: 21012, La definizione del tipo di dato astratto lista è intrinsecamente ricorsiva, infatti una lista può essere:

Transcript

1 LISTE DINAMICHE Liste semplicemente concatenate: La definizione del tipo di dato astratto lista è intrinsecamente ricorsiva, infatti una lista può essere: la lista vuota; oppure contiene un valore (di un certo tipo di dato) seguito da una lista Per poter definire in C un tipo di dato astratto "lista", si utilizza un puntatore a una struttura che contiene un campo di informazioni e un campo che è invece il puntatore alla struttura successiva. typedef struct Node { int data; struct Node *next; node; typedef node* list; Oss: mentre gli "array" sono "tipi di dato" ad accesso casuale, cioè è possibile accedere in maniera diretta a ogni singolo elemento(con [ ]); una lista è un "tipo di dato" ad accesso sequenziale, cioè bisogna scorrere necessariamente tutti gli elementi che precedono l elemento d interesse prima di potervi accedere. Inoltre una lista semplice è sempre identificata con il puntatore al primo nodo e termina sempre con un puntatore a NULL. Nota: in C++ la definizione precedente del tipo di dato astratto "lista" si può ri-scrivere anche come: struct node { int data; node *next; ; typedef node* list; Gerardo Pelosi Pagina 1 di 14

2 ESERCIZIO 1 Questi esercizi presentano (in gran parte) esempi d'uso delle liste dinamiche già presentati a lezione. In quanto segue non è utilizzato il passaggio parametri per reference. Come esercizio supplementare è possibile provare a ri-scrivere i sottoprogrammi seguenti applicando tale modalità di passaggio parametri, laddove lo si ritenga utile. Scrivere i sottoprogrammi di manipolazione delle liste concatenate semplici (di interi), indicate di seguito, utilizzando un procedimento ricorsivo e uno iterativo per ognuna di esse: - Creazione di un nuovo nodo: nodo *createnode(int d); - Inserimento in testa di un nuovo nodo con il prototipo seguente: lista inserthead(list h, node *el); - Inserimento in coda di un nuovo nodo con il prototipo seguente: lista inserttail(list h, node *el); - Stampa di una lista : void printlist(list h); - Calcolo della lunghezza di una lista: int lenlista(list h); - Ricerca elemento in una lista: lista searchlist(list h, int x); - Copia di una lista: void copylist(list h, list *ch); - Concatenazione di due liste: void appendlista(list& h1, lista& h2); - Inserimento in una lista ordinata: void insertsorted(list& h, int x); - Cancellazione di una lista: void wipelist(list& h); - Cancellazione della prima occorrenza di un elemento da una lista: void deletelist(list *h, int x); - Cancellazione di tutte le occorrenze di un elemento in lista: void deletelistall(list *h, int x); Gerardo Pelosi Pagina 2 di 14

3 // Definizione dei sottoprogrammi: node *createnode(int d) { node *p; p = new node; /* Creazione nuovo nodo */ p->data = d; p->next = NULL; return p; list inserthead(list h, node *el) { if (h == NULL) return el; if (el == NULL) return h; el->next = h; return el; list inserttail(list h, node *el) { node *aux; if (h == NULL) return el; if (el == NULL) return h; aux = h; while (aux->next!= NULL) aux = aux->next; aux->next = el; return h; void printlist(list h) { /* stampa ricorsiva */ if (h!=null) { cout << " -> " << h->data; printlist(h->next); Gerardo Pelosi Pagina 3 di 14

4 int lenlist(list h) { if (h == NULL) return 0; else return( 1 + lenlist(h->next)); list searchlist(list h, int x) { /* ricerca ricorsiva, ritorna il puntatore al nodo che */ /* contiene la prima occorrenza di x. */ if (h == NULL) return NULL; if ( h->data == x ) return h; /* caso base */ else return searchlist(h->next, x); void copylist(list h, list *ch) { if (h == NULL) *ch = NULL; else { (*ch) = createnode(h->dato); copylist(h->next, &((*ch)->next)); void appendlist(list& h1, list& h2) { // restituisce h1 = h1 h2 // il pass. per reference è necessario per gestire il caso h1 // vuota e h2 piena. if ( h1 == NULL ) h1 = h2 ; // caso base else if ( h1->next == NULL ) // caso base h1->next = h2; else appendlist(h1->next,h2); Gerardo Pelosi Pagina 4 di 14

5 void insertsorted(list& h, int x) { /* inserisce ricorsivamente, in ordine crescente */ if (h == NULL) { h = createnode(x); return ; if ( h->dato > x ) { h = inserthead(h, createnode(x)); return ; insertsorted(h->next),x); void wipelist(list& h) { node *aux; if ( h!= NULL ) { aux = h->next; /* salva punt. al nodo successivo */ delete(h); /* cancella il primo elemento */ h = NULL; wipelista(aux); /* cancella il resto della lista */ void deletelist(list *h, int x) { node *aux; if ( *h == NULL ) return; if ( (*h)->data == x ) { aux = (*h); (*h) = (*h)->next; delete aux; return ; deletelista(&((*h)->next),x); void deletelistall(list *h, int x) { node *aux; if ( (*h) == NULL ) return; if ( (*h)->data == x ) { aux = (*h); (*h) = (*h)->next; delete aux; deletelistall(h,x); /* oss: *h potrebbe valere NULL */ else deletelistall(&(*h)->next,x);/*oss:(*h)sicuramente!= NULL */ Gerardo Pelosi Pagina 5 di 14

6 ESERCIZIO 2 Scrivere una funzione in linguaggio C che elimini tutti i nodi di posto pari in una lista semplicemente concatenata di interi. Es: diventa #include <iostream> #include <cstdlib> typedef struct Node { int data; struct Node *next; nodo; typedef node* list; void DeleteEven(list h); int main( ) { int info; list h = NULL;/* Dichiarazione e inizializzazione lista */ /* (lista vuota) */... return 0; void DeleteEven(list h) {... // end DeleteEven Gerardo Pelosi Pagina 6 di 14

7 ESERCIZIO 3 Scrivere una funzione in linguaggio C che elimini tutti i nodi di posto dispari in una lista semplicemente concatenata di interi. Es: diventa 5 9 #include <iostream> #include <cstdlib> typedef struct Node { int data; struct Node *next; node; typedef node* list; void DeleteOdd(list *h); /* ri-scrivere la procedura con il parametro passato per reference */ int main( ) { int info; list h = NULL;/* Dichiarazione e inizializzazione lista */ /* (lista vuota) */... return 0; void DeleteOdd(list *h) { // end DeleteOdd Gerardo Pelosi Pagina 7 di 14

8 ESERCIZIO 4 (TE Appello del 10 Luglio 2009) Si consideri un programma che gestisce gli orari dei treni di un servizio ferroviario. In particolare, si definisca una lista dinamica che rappresenta le singole fermate di ciascun treno: ogni nodo della lista descrive un numero di treno, il numero progressivo della fermata (la stazione di partenza corrisponde alla fermata numero 1), il nome della stazione, l ora e i minuti (si usino due campi separati di tipo intero). Nella stessa lista possiamo perciò trovare le fermate di treni diversi. Dopo aver definito la struttura dati, si scriva in C/C++ la funzione TreniAlternativi, che riceve come parametro la lista delle fermate, e un numero di treno; la funzione restituisce il numero dei treni che collegano i due capolinea del treno fornito come parametro (se il treno indicato come parametro parte dalla stazione A e arriva alla stazione B, vogliamo sapere quanti sono i treni che collegano A con B, anche se A e B non sono capolinea). La funzione restituisce -1 se il treno indicato come parametro non esiste. Gerardo Pelosi Pagina 8 di 14

9 #include <cstring> #define STRLEN 30 struct Nodo { int numtreno; int numfermata; char nomestazione[strlen+1]; int hh; int mm; Nodo* next; ; typedef Nodo * Lista; int TreniAlternativi(Lista F, int numt) {... // end TreniAlternativi Gerardo Pelosi Pagina 9 di 14

10 ESERCIZIO 5 - Algoritmica di base e memoria dinamica La funzione toro( ) riceve come parametro un vettore di interi e la specifica della sua dimensione, e alloca e restituisce una lista dinamica "circolare" di interi che contiene solo i valori del vettore positivi e divisibili per 11. Ovviamente la lista può essere circolare solo se non è vuota, quindi si suggerisce di renderla circolare solo alla fine dell'analisi del vettore [N.B. una lista è circolare se l'ultimo elemento invece di avere un puntatore a NULL ha un puntatore alla testa]. (a) Si definiscano la struttura della lista e il prototipo della funzione toro. struct Nodo { int numero; Nodo* next; ; typedef Nodo * ListaC; ListaC toro( int v[], int len ); (b) Si codifichi la funzione (unitamente alle eventuali funzioni di supporto). ListaC toro( int v[], int len ) { int i = 0; ListaC ptr, testa ; testa = ptr = NULL; while (i < len) { if (v[i] > 0 && v[i] % 11 == 0) { if (testa == NULL) { testa = creanodo(v[i]); ptr = testa; else { ptr->next = creanodo(v[i]); ptr = ptr->next; ptr->next = testa; return testa; Nodo* creanodo(int a) { ListaC ptr = (Nodo*) new Nodo; ptr->numero = a; ptr->next = NULL; (c) Si disegni, la lista ottenuta con la funzione passando come parametro il vettore [111, 0, 11, -8, 73, -29, 121, 49, 16, 33, -110, 101, 44, 21] Gerardo Pelosi Pagina 10 di 14

11 ESERCIZIO 6 - Sintesi di codice Liste e Vettori struct Nodo { char c; Nodo * next; ; typedef Nodo * Lista; Si considerino una lista L di almeno N nodi e un vettore v di esattamente N puntatori a Nodo, tutti diversi da NULL e diversi tra loro, che puntano a un sottoinsieme dei nodi di L. Diciamo che L è compatibile con v se i nodi puntati da v compaiono in L in un ordine compatibile con l'ordine in cui i puntatori sono contenuti in v (cioè non succede mai che un nodo n1 puntato dal puntatore v[i] preceda in L il nodo n2 puntato dal puntatore v[j] che però si trovi "più avanti" in v). Esempi (con N=4): compatibili: L k c v i n a o incompatibili: c i n L k v a o a) Si codifichi la funzione compatibili( ) che controlla che una lista e un vettore siano compatibili secondo la precedente definizione. b) Si codifichi la funzione vprintf( ) che stampa su stdout la parola ottenuta seguendo nell'ordine i puntatori di v e accedendo ai caratteri contenuti nella lista, se L e v sono compatibili, e nulla se sono incompatibili (stamperebbe "ciao" nel caso dell'esempio soprastante). Gerardo Pelosi Pagina 11 di 14

12 ESERCIZIO 7 - Memoria Dinamica e strutture dati Si consideri la seguente definizione: struct Nodo { char * parola; Nodo * next; ; typedef Nodo * Lista; (a) Si disegni la struttura allocata dalle istruzioni del blocco di codice a lato, si indichino i valori di ogni variabile (sia statica sia dinamica: per i puntatori si usino le frecce, per i valori ignoti i punti interrogativi), e se ne calcoli la dimensione totale in byte. MMMMMMMMM sizeof(char) = 1, sizeof(void *) = 4) Nodo n, *p; char * s; s = (char *) new char[strlen("fischio")+1]; p = (Lista) new Nodo; n.next = (Lista) new Nodo; p->parola =(char*) new char[strlen("maschio")+1]; n.next->next = NULL; n.parola = s; p->next = n.next; s = (char *) new char[strlen("rischio")+1]; p->next->parola = s; Gerardo Pelosi Pagina 12 di 14

13 (b) Due parole si dicono simili se hanno al più due caratteri diversi. Una catena di parole si dice compatibile col telefono senza fili (cctsf) se ogni parola è simile alle adiacenti. La funzione int simili (char *s1, char *s2); restituisce 1 se s1 e s2 sono simili, 0 altrimenti. Usando la funzione simili( ) (senza codificarla), si codifichi una funzione f( ), opzionalmente anche ricorsiva, che riceve come parametro una lista dinamica di parole (secondo la definizione soprastante) e restituisce 1 se la lista rappresenta una catena cctsf, 0 altrimenti. (c) Si codifichi la funzione int simili (char *s1, char *s2 ); (d) Si consideri poi la definizione di una lista di catene di parole (da ogni NodoTesta inizia una Lista). struct NodoTesta { Lista catena; NodoTesta * next; ; typedef NodoTesta *ListaDiListe; Si codifichi una funzione che riceve una lista di liste così definita e dealloca interamente dalla lista di liste le sequenze di parole che non sono cctsf. Attenzione: si ipotizzi che nelle catene non ci siano parole allocate staticamente, e si badi a deallocare tutta la memoria dinamica. Gerardo Pelosi Pagina 13 di 14

14 ESERCIZIO 8 - Liste e matrici Si consideri la definizione struct Nodo { int numero; Nodo* next; ; typedef Nodo * Lista; Si codifichi la funzione spargidivisori( ), che riceve come parametri una lista di interi, una matrice NxN di interi, tutti strettamente positivi (come matrice dinamica), e la lunghezza N. La funzione deve cercare di copiare ogni valore v della lista nella matrice, inserendolo al posto di un valore che sia multiplo di v. Se ci riesce, restituisce 1, e la matrice deve contenere tutti i valori modificati, se non ci riesce, però, oltre a restituire 0, deve lasciare inalterata la matrice. Attenzione: i valori v devono sempre essere confrontati con la versione iniziale della matrice, non con le "versioni intermedie" derivanti dalla sostituzione di alcuni valori, se ci sono più multipli di v, se ne può sostituire uno a piacere (il primo che si incontra), si badi a definire chiaramente e/o dichiarare eventuali opportune strutture dati di appoggio o funzioni ausiliarie. Gerardo Pelosi Pagina 14 di 14