Dipartimento di Elettronica, Informazione e Bioingegneria API 2013/4

Transcript

1 Dipartimento di Elettronica, Informazione e Bioingegneria API 2013/4 Array, liste, pile, G. Gini 2013

2 Dati ricorsivi costruttore istruzione tipo dato atomo assegnamento variabile enumerazione istruzione composta struct ripetizione nota for array scelta if struct ripetizione ignota while file ricorsione funzione dati ricorsivi grafo go to puntatori Strutture statiche o dinamiche?

3 LISTE Una lista e una struttura dati ricorsiva che consente di accorpare elementi della stessa tipologia mantenendoli in ordine logico (non fisico) Definizione: Dato un insieme di valori U, chiamiamo lista una seq uenza finita L di elementi di U. L può essere la lista vuota, denotata con il simbolo Λ; altrimenti L è una sequenza finita della forma L = (a1, a2,..., an), dove n >= 1 e ai U per ogni i = 1, 2,..., n. <lista>::= Λ <elemento><lista> Il tipo di dato astratto lista è definito da: notazione insieme di primitive

4 Primitive su lista costruttore di lista lista_vuota? NULL? (lista). primo_elemento della lista: si puo fare se la lista non e vuota, e restituisce un elemento. PRIMO_EL (lista) resto della lista tolto il primo elemento: restituisce una lista accorciata. RESTO (lista) attacca_elemento_in_testa ad una lista. CONS (e, lista) aggiunge e all'inizio di lista. NULL?() -> vero PRIMO_EL (e1, e2, e3) -> e1 RESTO (e1, e2, e3) -> (e2, e3) CONS (e0, lista) -> (e0, e1, e2, e3)

5 Es1: restituisci l elemento di posto n definire la funzione nth che prende come argomenti un intero n ed una lista e ritorna l'ennesimo elemento della lista (numerata a partire da 0). - se n=0, restituisce primo_el altrimenti ritorna l'(n-1) elemento del resto della lista item nth (int n, list-item x) if n=0 then return PRIMO_EL (x) else return (nth (n-1, RESTO (x)) Computazione di nth( 2 ( )) = > nth(1 ( ))=> nth(0 (2 3 4)) RETURN 2

6 Es 2: restituisci la lunghezza della lista int lunghezza (list-item x) if NULL? (x) then return 0 else return lunghezza (RESTO( x)) + 1 Computazione: lunghezza(0 1 2) lunghezza(1 2) + 1 lunghezza(2)+1 +1 lunghezza() return 0 return 1 return 2 return 3

7 Es3 : inserimento in ordine In una lista ordinata il nuovo elemento viene inserito nella lista quando si e raggiunta la posizione voluta. Se l elemento è minore del primo della lista, va messo in testa insert-crescente( item x, list-item y) if NULL? (y) then return (list x) if x < PRIMO_EL(y) then return CONS(x y) else return CONS (PRIMO_EL( y), insert-crescente (x, RESTO(y)))

8 RAPPRESENTAZIONI GRAFICHE e puntatori E opportuno vedere la lista come composta da scatole doppie, che contengono per ogni elemento l elemento stesso ed un modo per raggiungere l elemento successivo (puntatore). la lista e caratterizzata da un puntatore d accesso la lista può essere scandita solo dall inizio alla fine; la fine è contrassegnata da un puntatore finale nullo. In genere i linguaggi imperativi non hanno la lista come struttura dati direttamente disponibile, e possono implementare la lista in diversi modi: 1. Rappresentazione mediante arrays 2. Rappresentazione mediante puntatori.

9 esempio Lista di tre elementi E1 P1 E2 P2 E3 NULL

10 Liste in array La rappresentazione mediante array richiede array di record - il primo campo e l elemento - il secondo e l indice in cui trovare il prossimo elemento es: rappresentiamo in C in un array di 10 righe e 2 colonne la lista di interi (e1, e2, e3) - puntatore d accesso = 1 - segno di fine lista: -1 typedef struct{ int pos; int info;elemlista; ElemLista MIA_lista [10]; 0 e3-1 1 e1 5 2 * * 3 * * 4 * * 5 e2 0 6 * * 7 * * 8 * * 9 * *

11 Array e lista libera P LL 0 e3-1 1 e1 5 2 * 6 3 * 2 4 * 7 5 e2 0 6 * 4 7 * 8 8 * 9 9 * -1 per poter inserire elementi e opportuno che le posizioni non usate siano collegate a lista, (lista libera). Nella stessa array allora convivono due liste, la lista delle informazioni e la lista libera. In questo caso il puntatore lista libera = 3

12 Strutture dati dinamiche in C strutture nelle quali è possibile modificare le dimensioni aggiungendo o togliendo elementi allocando o deallocando memoria l accesso alle componenti non sempre è il risultato di una sola operazione ma può richiedere l esecuzione di un numero di passi proporzionale alla dimensione della struttura stessa.

13 Allocazione e Rilascio di memoria Si alloca memoria solo quando occorre inserire dati Si libera memoria quando il dato non serve più in C occorre introdurre funzioni che fanno riferimento a variabili di tipo puntatore Si allocano o deallocano durante l esecuzione del programma Sono anonime (si accede mediante puntatori, non hanno un nome) Occorrono le funzioni della <stdlib.h> malloc per allocazione prende celle da heap free per rilascio di memoria (torna in heap)

14 Gestione della memoria La memoria riservata ai dati del programma è partizionata in due "zone" pila (stack) per var. statiche e automatiche mucchio (heap) per var. dinamiche Esempio int * Punt1; int ** Punt2;

15 malloc e free TipoDato *punt; punt = malloc (sizeof(tipodato)); Dichiara punt come puntatore a TipoDato Crea in memoria la variabile del tipo TipoDato Restituisce l indirizzo della variabile creata (NULL se heap esaurito) Assegna questo indirizzo a punt, che ora punta alla variabile dinamica free(punt); Rilascia lo spazio puntato da punt per tanti bytes quanto indicato da TipoDato N.B.: non serve specificare la dimensione in byte, che è intrinsecamente derivabile dal tipo della variabile allocata sizeof Ritorna la grandezza in bytes dell operando

16 Puntatori "ciondolanti" dangling references Sono puntatori a zone di memoria deallocate ( a variabili dinamiche "non più esistenti") Sono più gravi della produzione di garbage: portano a veri e propri errori Alcuni linguaggi (LISP, SCHEME, Java) non hanno una operazione free(), ma un garbage collector - Un componente della macchina astratta che trova e riutilizza la memoria inaccessibile (non più referenziata)

17 Problemi coi puntatori è possibile programmare molto male generando effetti difficili da "tracciare" in modo che il funzionamento del programma dipenda da come uno specifico sistema gestisce la memoria Lo stesso programma, se scritto "male", può funzionare in modo diverso su macchine diverse

18 Puntatori per la lista Lista Si definisce Lista, il puntatore alla lista la memoria viene allocata per l elemento da inserire E1 P1 E2 P2 E3 NULL

19 Dichiarazione di lista typedef struct EL { TipoDato Info; struct EL *Prox; ElemLista; typedef ElemLista *ListaDiElem; ListaDiElem Lista; struct EL definisce i campi di ogni elemento typedef rinomina il tipo structel come ElemLista typedef definisce il nuovo tipo ListadiElem come puntatore al tipo ElemLista Lista é perciò il puntatore alla lista

20 Funzioni di base in C - 1 Inizializzazione con variable globale Lista = NULL; con procedura su variabile globale void Inizializza (void) { Lista = NULL;

21 Funzioni di base in C - 2 Lista vuota? int ListaVuota (ListadiElem Lista) /* Lista, passata per valore, punta al primo elemento*/ { if (Lista == NULL) return 1; else return 0; Esempio di chiamata: int vuota; vuota = ListaVuota (Lista);

22 Funzioni di base in C - 3 Prendi il primo elemento di una lista - di tipo int int PrimoElem (ListadiElem Lista) { if (ListaVuota(Lista)== false) return Lista->Info else return error ; Lista->Info è scrittura abbreviata per accedere al campo Info della variabile dereferenziata *Lista Lista->Info equivale a *Lista.Info (ListaVuota(Lista)== false) equivale a (Lista!= NULL)

23 Funzioni di base in C - 4 Prendi il resto della lista tolto il primo elemento ListaDiElem RestoLista (ListadiElem Lista) { if(lista!= NULL) /*ci sono elementi*/ return Lista->Prox else return error ; Lista->Prox è scrittura abbreviata per accedere al campo Prox della variabile dereferenziata *Lista è equivalente a *Lista.Prox

24 Esempio: ricerca elemento Scandire una lista di interi fino a trovare o l'elemento o la fine lista boolean Ricerca (ListadiElem Lista, int Cercare) {while (Lista!= NULL)/*non vuota*/ {if (Lista->Info == Cercare) return true; Lista = Lista->Prox;/*by value*/ return false;

25 -> ricerca ricorsiva Se Lista vuota return false altrimenti return ricerca (resto Lista) boolean Ricerca (ListadiElem Lista, int Cercare) { if (Lista == NULL) return false; if (Lista->Info == Cercare) return true; else return Ricerca (Lista-> Prox, Cercare);

26 Funzioni di base in C 5 Inserire in testa Lista punt elem Alloco una scatola per elem A prox assegno Lista A Lista assegno punt

27 Inserimento in testa (passaggio per valore) ListaDiElem InserisciTesta (ListadiElem Lista, int Elem) { ElemLista * punt; punt = malloc (sizeof(elemlista)); punt->info = Elem; punt->prox = Lista; return punt; chiamata: Lista = InserisciTesta (Lista, new);

28 Inserimento in testa (passaggio per indirizzo) Inserimento in testa (come procedura, passaggio per indirizzo) void InserisciTesta (ListadiElem *Lista, int Elem) { ElemLista *punt; punt = malloc (sizeof(elemlista)); punt->info = Elem; punt->prox = *Lista; *Lista = punt; *Lista é indirizzo primo elemento della lista

29 Inserimento in coda (ricorsivo) ListaDiElem InserisciCoda(ListadiElem Lista, int Elem) { ElemLista *punt; if (ListaVuota(Lista)) {punt = malloc (sizeof(elemlista)); punt->info = Elem; punt->prox = NULL; return punt; else {Lista->Prox=InserisciCoda(Lista>Prox, Elem); return Lista;/*il puntatore a lista*/ chiamata: Lista = InserisciCoda (Lista, Nuovo); return InserisciTesta(ListadiElem lista, int Elem);

30 Inserimento in ordine ListaDiElem InserisciOrdine(ListadiElem Lista, int Elem) { Elemlista *punt, *puntcorr, *puntprec; puntprec = NULL; puntcorr = Lista; while (puntcorr!=null&&elem>puntcorr->info) /*va avanti*/ {puntprec = puntcorr; puntcorr = puntcorr->prox; /*ci siamo*/ punt = malloc (sizeof(elemlista)); punt->info = Elem; punt->prox = puntcorr; if (puntprec!= NULL) /* siamo all' interno*/ {puntprec->prox= punt; return Lista; else return punt; /*è in testa*/ chiamata Lista = InserisciOrdine (Lista,new);

31

32 Cancellazione di elemento (ricorsiva) ListaDiElem Cancella (ListadiElem Lista, int Togli) {ElemLista *puntemp; if (ListaVuota(Lista)== false)/*ci sono elementi*/ {if(lista->info == Togli)/* trovato*/ {puntemp = Lista->Prox; free (Lista); return puntemp; else {Lista->Prox = Cancella(Lista->Prox, Togli); return Lista; else return Lista ;*/è vuota*/ chiamata : Lista = Cancella(Lista, Elem);

33 #include <stdio.h> #include <stdlib.h> struct listnode { char data; struct listnode *nextptr; ; typedef struct listnode ListNode; typedef ListNode *ListNodePtr; /*tipo dato lista*/ void insert( ListNodePtr *, char ); /*prototipi*/ char delete( ListNodePtr *, char ); int isempty( ListNodePtr ); void printlist( ListNodePtr ); void instructions( void ); Programma completo Usa procedure e chiamate per indirizzo main() { ListNodePtr startptr = NULL; int choice; char item; instructions(); /* mostra il menu */ printf( "? " ); scanf( "%d", &choice );

34 while ( choice!= 3 ) { switch ( choice ) { case 1: printf( "Enter a character: " ); scanf( "\n%c", &item ); insert( &startptr, item ); printlist( startptr ); break; case 2: if (!isempty( startptr ) ) { printf( "Enter character to be deleted: " ); scanf( "\n%c", &item ); if ( delete( &startptr, item ) ) { printf( "%c deleted.\n", item ); printlist( startptr ); else printf( "%c not found.\n\n", item ); else printf( "List is empty.\n\n" ); break; default: printf( "Invalid choice.\n\n" ); instructions(); break;

35 printf( "? " ); scanf( "%d", &choice ); printf( "End of run.\n" ); /* stampa il menu */ void instructions( void ) { printf( "Enter your choice:\n" " 1 to insert an element into the list.\n" " 2 to delete an element from the list.\n" " 3 to end.\n" ); /* inserisci in ordine un valore nella lista */ void insert( ListNodePtr *sptr, char value ) { ListNodePtr newptr, previousptr, currentptr; newptr = malloc( sizeof( ListNode ) ); if ( newptr!= NULL ) { newptr->data = value; newptr->nextptr = NULL; previousptr = NULL; currentptr = *sptr;

36 while ( currentptr!= NULL && value > currentptr->data ) { previousptr = currentptr; currentptr = currentptr->nextptr; if ( previousptr == NULL ) { newptr->nextptr = *sptr; *sptr = newptr; else { previousptr->nextptr = newptr; newptr->nextptr = currentptr; else printf( "%c not inserted. No memory available.\n", value ); /* cancella un elemento */ char delete( ListNodePtr *sptr, char value ) { ListNodePtr previousptr, currentptr, tempptr; if ( value == ( *sptr )->data ) { tempptr = *sptr; *sptr = ( *sptr )->nextptr; /* stacca il nodo */ free( tempptr ); /* cancella */ return value;

37 else { previousptr = *sptr; currentptr = ( *sptr )->nextptr; while ( currentptr!= NULL && currentptr->data!= value ) { previousptr = currentptr; currentptr = currentptr->nextptr; if ( currentptr!= NULL ) { tempptr = currentptr; previousptr->nextptr = currentptr->nextptr; free( tempptr ); return value; /* lista vuota?*/ int isempty( ListNodePtr sptr ) { return sptr == NULL; /* stampa la lista */ void printlist( ListNodePtr currentptr ) { if ( currentptr == NULL )

38 printf( "List is empty.\n\n" ); else { printf( "The list is:\n" ); while ( currentptr!= NULL ) { printf( "%c --> ", currentptr->data ); currentptr = currentptr->nextptr; printf( "NULL\n\n" ); Enter your choice: 1 to insert an element into the list. 2 to delete an element from the list. 3 to end.? 1 Enter a character: B The list is: B --> NULL? 1 Enter a character: A The list is: A --> B --> NULL? 1 Enter a character: C The list is: A --> B --> C --> NULL? 2 Enter character to be deleted: D D not found.? 2 Enter character to be deleted: B B deleted. The list is: A --> C --> NULL

39 visita di lista void printlista( ListaDiElem currentptr ) { if ( currentptr == NULL ) printf( Lista vuota.\n\n" ); else { printf( La lista è:\n" ); while ( currentptr!= NULL ) { printf( "%d --> ", currentptr->info ); currentptr = currentptr->nextptr; printf( "NULL\n\n" );

40 Esercizio 1 Si scriva una funzione C ricorsiva che data una lista l restituisce 1 se la lista è ordinata, 0 altrimenti. La lista vuota si ritiene ordinata, così come la lista contenente un solo elemento. Si consideri ad esempio la seguente lista: La funzione restituirà il valore 1, poiché ogni elemento contiene un valore maggiore dell elemento precedente. l

41 Soluzione 1 int list_is_ordered(listadielem L) { if (L == NULL) return 1; if (L->prox == NULL) return 1; return list_is_ordered(l->prox)&& (L->info < L->prox->info);

42 le liste semplici Cominciano con un puntatore al primo nodo Terminano con null Si attraversano in una sola direzione APPLICAZIONI: processi in SO, elenchi, Dato e puntatore NULL (punta a nulla

43 Pila (o stack) È una struttura dati con accesso limitato all elemento "in cima", che è quello inserito più recentemente (LIFO: last in, first out) Nomi standard delle operazioni primitive: Push Inserimento in cima Pop prelievo e rimozione dell elemento in cima, che è per definizione l'ultimo elemento inserito Top o Peek Prelievo senza rimozione (cioè "sola lettura") dell'elemento in cima

44 Applicazioni della pila Controllo di bilanciamento di simboli (parentesi, tag XML, blocchi C, ) Per ogni simbolo di "apertura" si impila un segnaposto che sarà rimosso quando si incontra il simbolo duale di "chiusura" Se il simbolo non corrisponde al segnaposto sulla pila, allora la sequenza non è bilanciata Esempio: {[][{[](){](){[()]()[{] ok {[{] () ko Implementazione di chiamate a funzione Pila di sistema e record di attivazione Valutazione di espressioni aritmetiche

45 Pila (o stack): implementazione PILA (stack): I nuovi nodi possono essere aggiunti e cancellati solo dalla cima (top) della pila La base della pila è indicata da un puntatore a NULL È una versione vincolata della lista concatenata: solo inserimento e cancellazione in testa push Aggiunge un nuovo nodo alla cima della pila Non restituisce nulla al chiamante (void) - restituisce il puntatore- MEGLIO! pop Cancella un nodo dalla cima della pila Memorizza il valore cancellato Restituisce un valore booleano al chiamante true se l operazione ha avuto successo NULL

46 Dichiarazione di stack (di interi) typedef struct stacknode { int Info; struct stacknode *Prox; Node; typedef Node *Stack; Stack pila1; struct definisce i campi di ogni elemento typedef rinomina il tipo structstacknode come Node typedef definisce il nuovo tipo Stack come puntatore al tipo Node pila é perciò il puntatore allo stack

47 push (come funzione, passaggio per valore) Stack Push (Stack pila, int el) { Node * punt; punt = malloc (sizeof(node)); punt->info = el; punt->prox = pila1; return punt; chiamata: pila1 = Push (pila1, new); pila = punt pila e l

48 Pop deve modificare il puntatore d accesso e restituire il valore in cima allo stack occorre una chiamata per reference int Pop (Stack *pila) {Stack temp; int popval; temp = *pila /*metto in temp l indirizzo del primo byte della pila */ popval = (*pila)->info; *pila = (*pila)->prox; free (temp); return popval; chiamata :testa = Pop(&pila1);

49 Implementazione completa in C void push( StackNodePtr *, int ); int pop( StackNodePtr * ); int isempty( StackNodePtr ); void printstack( StackNodePtr ); void instructions( void );

50 int main() { StackNodePtr stackptr = NULL; /* punta alla cima della pila */ int choice, value; do { instructions(); scanf( "%d", &choice ); switch ( choice ) { case 1: printf( "Enter an integer: " ); /* chiama push */ scanf( "%d", &value ); push( &stackptr, value ); printstack( stackptr ); break; case 2: if (!isempty( stackptr ) ) /* chiama pop */ printf( "The popped value is %d.\n", pop( &stackptr ) ); printstack( stackptr ); break; case 3: printf( "End of run.\n" ); break; default: printf( "Invalid choice.\n\n" ); break; while ( choice!= 3 ); return 0;

51 void instructions( void ) { printf( "Enter choice:\n"); printf( "1 to push a value on the stack\n"); printf( "2 to pop a value off the stack\n"); printf( "3 to end program\n\n> "); void push (StackNodePtr *topptr, int info) { StackNodePtr newptr; newptr = malloc( sizeof( StackNode ) ); if ( newptr!= NULL ) { newptr->data = info; newptr->nextptr = *topptr; *topptr = newptr; else printf( "%d not inserted. No memory available.\n", info );

52 int pop( StackNodePtr *topptr ) { StackNodePtr tempptr = *topptr; int popvalue = (*topptr)->data; *topptr = (*topptr)->nextptr; free( tempptr ); return popvalue; void printstack( StackNodePtr currentptr ) { if ( currentptr == NULL ) printf( "The stack is empty.\n\n" ); else { printf( "The stack is:\n" ); while ( currentptr!= NULL ) { printf( "%d --> ", currentptr->data ); currentptr = currentptr->nextptr; printf( "NULL\n\n" ); int isempty( StackNodePtr topptr ) { return topptr == NULL;

53 coda Come al check-in First-in, first-out (FIFO) I nodi sono rimossi dalla testa I nodi sono inseriti in coda = lista vincolata, solo inserimento in coda e rimozione del primo elemento Utile nella programmazione di sistema: code della stampante, pacchetti accodati nella rete, richieste di accesso a file condivisi gestione semplice di turni per l accesso a risorse condivise coda c1 c2 c3 c4 c5

54 Coda (queue) In una coda l accesso è ristretto all elemento inserito meno recentemente (FIFO) Le operazioni tipiche supportate dalla coda sono: accoda o enqueue o offer aggiunge un elemento in coda dequeue o poll o rimuovi preleva e cancella l elemento di testa getfront o peek preleva ma non cancella l elemento di testa

55 Dichiarazione di coda (di interi) typedef struct codanode { int Info; struct codanode *Prox; Node; typedef Node *Coda; Coda fila1; struct definisce i campi di ogni elemento typedef rinomina il tipo struct codanode come Node typedef definisce il nuovo tipo Coda come puntatore al tipo Node fila é perciò il puntatore alla coda

56 accoda (come per lista in coda) Coda Accoda (Coda fila, int Elem) { Node *punt; if (fila == NULL {punt = malloc (sizeof(node)); punt->info = Elem; punt->prox = NULL; return punt; else {fila->prox=accoda(fila->prox, Elem); return fila;/*il puntatore a fila*/ chiamata: fila1 = Accoda(fila1, Nuovo);

57 rimuovi e restituisci il valore int Rimuovi (Coda *fila) { Node *out; int value; out = fila; value = (*fila)->info; *fila = (*fila)->prox; free (out); return value; chiamata: Q = Rimuovi (&fila1);

58 In C void printqueue( QueueNodePtr ); int isempty( QueueNodePtr ); int dequeue( QueueNodePtr *, QueueNodePtr * ); void enqueue( QueueNodePtr *, QueueNodePtr *, int ); void instructions( void );

59 int main() { QueueNodePtr firstptr = NULL, lastptr = NULL; int choice, item; do { instructions(); scanf( "%d", &choice ); switch( choice ) { case 1: printf( "Enter an integer: " ); scanf( "\n%d", &item ); enqueue(&firstptr, &lastptr, item ); printqueue( firstptr ); break; case 2: if (!isempty( firstptr ) ) { item = dequeue( &firstptr, &lastptr ); printf( "%d has been dequeued.\n", item ); printqueue( firstptr ); break; case 3: printf( "End of run.\n" ); break; default: printf( "Invalid choice.\n\n" ); break; while ( choice!= 3 ); return 0;

60 void instructions( void ) { printf ( "Enter your choice:\n" printf ( " 1 to add an item to the queue\n" printf ( " 2 to remove an item from the queue\n" printf ( " 3 to end\n\n> " ); void enqueue( QueueNodePtr *firstptr, QueueNodePtr *lastptr, int value ) { QueueNodePtr newptr; newptr = malloc( sizeof( QueueNode ) ); if ( newptr!= NULL ) { newptr->data = value; newptr->nextptr = NULL; if ( isempty( *firstptr ) ) *firstptr = newptr; else ( *lastptr )->nextptr = newptr; *lastptr = newptr; else printf( "%c not inserted. No memory available.\n", value); 60

61 int dequeue( QueueNodePtr *firstptr, QueueNodePtr *lastptr ) { QueueNodePtr tempptr = *firstptr; int value = ( *firstptr )->data; *firstptr = ( *firstptr )->nextptr; if ( *firstptr == NULL ) *lastptr = NULL; free( tempptr ); return value; void printqueue( QueueNodePtr currentptr ) { if ( currentptr == NULL ) printf( "Queue is empty.\n\n" ); else { printf( "The queue is:\n" ); while ( currentptr!= NULL ) { printf( "%d --> ", currentptr->data ); currentptr = currentptr->nextptr; printf( "NULL\n\n" ); int isempty( QueueNodePtr firstptr ) { return fearstptr == NULL;

62 Insieme (o set) È come la lista, ma con il vincolo di non ammettere valori duplicati L ordine in cui appaiono gli elementi nella lista non è significativo Di solito, per motivi di convenienza, gli insiemi si realizzano tramite liste ordinate Così si velocizzano le operazioni di ricerca (dicotomica / binary search) e inserimento

63 Prototipi per l insieme int add ( Tipo item, Insieme * i ); aggiunge l elemento dato all insieme e restituisce un valore che indica se l operazione ha avuto successo int remove ( Tipo item, Insieme * i ); rimuove dall insieme l elemento indicato e restituisce un valore che indica se l operazione ha avuto successo int contains ( Tipo item, Insieme i ); verifica se l elemento dato è presente nell insieme

64 Rappresentazione di insiemi tramite array Per rappresentare insiemi di lettere? N = 26!! Sfruttiamo l'ordinamento delle lettere per metterle in corrispondenza con gli interi nell'array [A=0, B=1, Z=25] typedef int alfabeto[26]; o { emptyset = {0,0,0, 0 (26 zeri) {A solo a = {1,0,0, 0 (25 zeri) {A, Z alfabeto testacoda = {1,0 0,1 {A, C, F alfabeto acf = {1,0,1,0,0,1,0 0 (24 zeri)

65 insiemi tramite array operazioni base N.B. Gli insiemi sono intrinsecamente ordinati In virtù dell' associazione biunivoca tra indici ed elementi Siano dati i seguenti insiemi di lettere: S, T, U, I; Calcoliamo in U l'unione di S e T : i = 0; while( i < N ) { U[i] = S[i] T[i]; / assegna 0 o 1 / i = i + 1; Calcoliamo in I l'intersezione di S e T : i = 0; while( i < N ) { I[i] = S[i] && T[i]; / assegna 0 o 1 / i = i + 1;

66 Nested set nested set model tecnica per rappresentare gerarchie nei data base relazionali. Alternativi a alberi.

67 Esercizi Liste Da vecchi temi d esame

68 Esercizio 1 Due liste di interi si dicono equipotenti se sono di uguale lunghezza e, confrontando i valori in posizioni corrispondenti, risulta che i valori della prima lista maggiori dei corrispondenti valori nella seconda sono esattamente in numero uguale ai valori della seconda lista maggiori dei corrispondenti valori nella prima. Data la lista definita come: typedef struct EL { int valore; struct EL * next; Nodo; typedef Nodo * Lista; si descriva un algoritmo e si proponga una codifica per la funzione di prototipo int equipotenti ( Lista L1, Lista L2 ); che restituisce 1 se le liste sono equipotenti, 0 altrimenti.

69 soluzione1 int equipotenti ( Lista L1, Lista L2 ) { return controlla(l1, L2, 0); int controlla ( Lista L1, Lista L2, int bilancio ) { if ( L1 == NULL L2 == NULL ) return ( L1 == L2 && bilancio == 0 ); if ( L1->valore > L2->valore ) bilancio++; else if ( L1->valore < L2->valore ) bilancio--; return controlla( L1->next, > L2->next, bilancio );

70 Esercizio 2 Si consideri la seguente definizione: typedef struct Elem { char * parola; struct Elem * next; Nodo; typedef Nodo * Lista; 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 in C una funzione f( ), preferibilmente 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.

71 Soluzione 2 int f( Lista a ) { /* Versione ricorsiva */ if ( a == NULL a->next == NULL ) return 1; if (!simili(a->parola, a->next->parola) ) return 0; return f( a->next ); int f( Lista a ) { /* Versione iterativa */ while ( a!= NULL && a->next!= NULL ) { if (!simili(a->parola, a->next->parola) ) return 0; a = a->next; return 1; int f( Lista a ) { /* Versione "provocatoria" */ return ( a==null a->next==null simili(a->parola, a->next->parola) && f(a->next) );

72 Esercizio 2a Si consideri poi la definizione di una lista di catene di parole (da ogni NodoTesta inizia una Lista). typedef struct Elem2 { Lista catena; struct Elem2 * next; NodoTesta; typedef NodoTesta * ListaDiListe; Si codifichi (preferibilmente in modo ricorsivo: bonus +1) 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. [3 punti, +1 se in versione ricorsiva]

73 Soluzione 2a void deallocacatena( Lista a ) { if ( a!= NULL ) { deallocacatena( a->next ); free(a->parola); /* Bisogna deallocare anche il vettore dinamico */ free( a ); ListaDiListe sfrondalistadiliste( ListaDiListe b ) { if ( b!= NULL ) { ListaDiListe tmp = sfrondalistadiliste( b->next ); if (!f( b->catena ) ) { deallocacatena( b->catena ); free( b ); return tmp; else b->next = tmp; return b;

74 Esercizio 3 Si consideri la seguente definizione: typedef struct Elem { int x; int y; struct Elem * next; Punto; typedef Punto * Linea; Una linea spezzata è rappresentata da una lista di punti con coordinate intere. Definiamo una spezzata aperta non degenere (AND) se i suoi punti sono almeno due e tutti diversi tra loro. Consideriamo solo spezzate AND. La lunghezza di una spezzata è la somma delle distanze euclidee tra punti consecutivi. Date due spezzate A e B, diciamo che A e B sono disgiunte se non hanno punti in comune, che B è una scorciatoia di A se A e B hanno gli stessi estremi ma B ha lunghezza minore, che A contiene B se B è una sottosequenza di A, e che A estende B se A contiene B e hanno l'ultimo punto in comune, e infine definiamo la concatenazione di due liste disgiunte A e B come la linea C = A B ottenuta aggiungendo B in coda ad A. Se A e B non sono disgiunte, A B =.

75 Esercizio 3 - cont Si progettino e codifichino opportunamente le funzioni seguenti. int scorciatoia(linea A, Linea B) restituisce 1 se A è scorciatoia di B, 0 altrimenti int estende(linea A, Linea B) restituisce 1 se A estende B, 0 altrimenti Linea concatena(linea A, Linea B) restituisce C=A B riusando i nodi di A e B. float tortuosità(linea A) restituisce il rapporto tra la lunghezza di A e la distanza tra i suoi estremi È indispensabile definire, codificare e usare altre opportune funzioni di supporto per definire in modo più compatto e leggibile le funzioni richieste.

76 soluzione 3 int uguali( Punto a, Punto b ) { /* Punti uguali se coordinate uguali */ return ( (a.x == b.x) && (a.y == b.y) ); int numnodi( Linea A ) { /* Conteggio ricorsivo standard dei nodi */ if ( A == NULL ) return 0; return 1 + numnodi(a->next);

77 soluzione 3 - cont int AND( Linea A ) { Linea tmp; if ( numnodi(a) < 2 ) return 0; /* Se non è almeno un segmento, non è AND */ while( A!= NULL ) { /* Per ogni punto */ tmp = A->next; while(tmp!= NULL) { /*se ce n'è un altro uguale */ if ( uguali(*a, *tmp) ) return 0; tmp = tmp->next; A = A->next; return 1; /* Se arriviamo in fondo, è AND */

78 soluzione 3 - cont Definita la funzione AND(),ipotizziamo senza ledere la generalità che le linee passate come parametro alle altre funzioni siano AND, a cura dei rispettivi programmi chiamanti (che possono verificare i parametri prima di procedure all'invocazione). Ciò è coerente con l'indicazione della traccia "consideriamo solo spezzate AND". Punto * last( Linea A ) { /* Un puntatore all'ultimo punto */ if ( A == NULL A->next == NULL ) return A; return last(a->next);

79 soluzione 3 - cont float dist( Punto p, Punto q ) { return sqrt( (p.x-q.x)*(p.x-q.x)+(p.y-q.y)*(p.y-q.y) ); float lung( Linea A ) { if ( A == NULL A->next == NULL ) return 0.0; return dist(*a, *(A->next)) + lung(a->next); int lineeuguali( Linea a, Linea b ) { if ( a == NULL && b == NULL ) return 1; if ( a == NULL b == NULL ) return 0; return uguali(*a,*b)&&lineeuguali(a->next,b->next);

80 soluzione 3 - cont Passiamo quindi a definire le funzioni richieste: int scorciatoia( Linea A, Linea B ) { if ( uguali(*a, *B) && uguali(*last(a), *last(b)) ) return lung(a) < lung (B); return 0; int estende( Linea A, Linea B ) { /* N.B.: B è AND per ipotesi */ if ( A == NULL ) return 0; if ( uguali(*a, *B) ) return lineeuguali(a, B); return estende(a->next, B);

81 soluzione 3 - cont Linea concatena( Linea A, Linea B ) { (last(a))->next = B; return A; float tortuosità( Linea A ) { return lung(a) / dist(*a, *last(a));

82 Esercizio 4 La funzione ds( ) calcola la differenza simmetrica degli elementi di due liste ordinate in senso crescente e prive di duplicati, restituendola come una nuova lista (allocata allo scopo), anch'essa ordinata. La differenza simmetrica è costituita dagli elementi che appartengono a una delle due liste ma non all'altra lista (contiene cioè tutti gli elementi che non sono in comune alle due liste). Si usi questa definizione: typedef struct N { int valore; struct N * next; Nodo; typedef Nodo * Lista; Si codifichi la funzione in C. Si apprezza il ricorso ad eventuali funzioni ausiliarie.

83 Soluzione 4 Se entrambe le liste sono vuote, C è il risultato finale (C è una lista inizialmente vuota). Se una delle due liste è vuota: inserisci in coda a C una copia dell elemento corrente della lista non vuota; avanti ricorsivamente sulla lista vuota e la coda della lista non vuota. Se entrambe le liste sono non vuote (possiamo confrontare i valori): se i valori in testa alle due liste sono uguali, avanti ricorsivamente sul next di entrambe le liste, senza modificare C se i valori sono diversi, inserisci in coda a C una copia dell elemento con il valore minore; avanti ricorsivamente, avanzando sul next della sola lista che aveva il valore minore

84 Soluzione 4 - cont Lista inscoda( Lista L, int n) { if( L == NULL ) { L = (Lista) malloc(sizeof(nodo)); L->next = NULL; L->valore = n; else L->next = inscoda( L->next, n ); return L;

85 Soluzione 4 - cont Lista ds( Lista A, Lista B, Lista C ) { // Una versione "analitica" if( A == NULL && B == NULL ) return C; if( A == NULL ) { C = inscoda( C, B->valore ); return ds(a, B->next, C); if( B == NULL ) { C = inscoda( C, A->valore ); return ds(a->next, B, C); if( A->valore < B->valore ) { C = inscoda( C, A->valore ); return ds(a->next, B, C); if( A->valore > B->valore ) { C = inscoda( C, B->valore ); return ds(a, B->next, C); return ds(a->next, B->next, C);

86 Soluzione 4 - cont // Una versione equivalente ma meno prolissa Lista ds( Lista A, Lista B, Lista C ) { if( A == NULL && B == NULL ) return C; if( A == NULL ( B!= NULL && A->valore > B->valore ) ) { C = inscoda( C, B->valore ); return ds(a, B->next, C); if( B == NULL ( A!= NULL && A->valore < B->valore ) ) { C = inscoda( C, A->valore ); return ds(a->next, B, C); return ds(a->next, B->next, C);

87 Soluzione 4 - cont // Soluzione alternativa Lista creanodo( int val ) { Lista tmp = (Lista) malloc(sizeof(nodo)); tmp->next = NULL; tmp->valore = val; return tmp; Lista Copia( Lista L ) { // Alloca e restituisce una copia di L Lista tmp = L; if( tmp!= NULL ) tmp = creanodo( L->valore ); tmp->next = Copia( L->next ); return tmp;

88 Soluzione 4 - cont Lista ds( Lista A, Lista B ) { Lista tmp = NULL; if( A == NULL ) return Copia( B ); if( B == NULL ) return Copia( A ); if( A->valore < B->valore ) { tmp = creanodo( A->valore ); tmp->next = ds( A->next, B ); else if( A->valore > B->valore ) { tmp = creanodo( B->valore ); tmp->next = ds( A, B->next ); else tmp = ds( A-next, B->next ); return tmp; Si noti che non si effettua inserimento in coda e non si deve quindi scorrere più volte alcuna lista. Si noti che non è necessario propagare come parametro un riferimento alla lista in costruzione. Si noti anche come la scomposizione in funzioni aiuta a rendere la soluzione comprensibile. Si noti infine che le differenze simmetriche restituite dalle chiamate ricorsive alla funzione ds vengono agganciate "in coda" all'elemento di volta in volta costruito dalle singole attivazioni.

89 Soluzione 4 - cont //Soluzione ricorsiva Se entrambe le liste sono vuote, la differenza simmetrica (d.s.) è vuota. Se i due valori in testa sono uguali, tale valore non sarà nella d.s.: non si alloca memoria, ma si propaga il calcolo e se ne restituisce il risultato In ogni altro caso occorre allocare un nodo, e dunque lo si fa subito: Se B è vuota oppure il valore in testa a B è maggiore di quello in testa a A Il nuovo nodo riceve A->valore (che fa parte della d.s.) L'analisi continuerà su B e la coda di A altrimenti (cioè se A è vuota oppure il valore in testa a B è minore di quello in testa a A) Il nuovo nodo riceve B->valore (che fa parte della d.s.) L'analisi continuerà su A e la coda di B SI EFFETTUA LA CHIAMATA RICORSVA La lista restituita da tale chiamata viene attaccata in coda al nuovo elemento, che è il primo della d.s. Come nella seconda soluzione, il nuovo nodo viene allocato prima della chiamata ricorsiva, ma viene agganciato alla lista solo quando l'esecuzione della chiamata ricorsiva è terminata. In questo modo è possibile eseguire "in testa" l'inserimento che nella prima versione avviene "in coda", sfruttando la "fase discendente" della ricorsione quella cioè in cui si deallocano i record di attivazione.

90 Soluzione 4 - cont Lista ds( Lista A, Lista B ) { Lista tmp; if( A == NULL && B == NULL ) return NULL; if( B!= NULL && B!= NULL && A->valore == B->valore ) return ds(a->next, B->next); tmp = (Lista) malloc(sizeof(nodo)); if ( B == NULL (A!= NULL && A->valore < B->valore) ) { tmp->valore = A->valore; A = A->next; else { // qui è garantito che A == NULL B!= NULL && A->valore > B->valore tmp->valore = B->valore; B = B->next; tmp->next = ds(a, B); return tmp;