Che cosa c è nella lezione. Questa lezione si occupa di strutture dati:

Transcript

1 Algoritmi e Programmazione Avanzata - teoria / Che cosa c è nella lezione Questa lezione si occupa di strutture dati: tipi di dato astratto le pile le code le liste gli alberi binari di ricerca le tabelle di hash. /

2 Algoritmi e Programmazione Avanzata - teoria / Definizione Tipo di Dato Astratto: Modello matematico sul quale è definito un insieme di operazioni. /

3 Modello: insieme di elementi generici Operazioni: unione (X,Y) inters (X,Y) diff (X,Y) Modello: intervallo di interi Operazioni: + - * : / Estensione dei tipi primitivi Tipi primitivi: quelli supportati da un linguaggio (int, float, char per il C) con le loro operazioni (+, -, *, /, % etc.). Tipi di Dati Astratti: estensione dell insieme dei tipi di dato supportati. /

4 Estensione Operatori: predefiniti, operazioni elementari sui tipi primitivi. Procedure come estensione degli operatori: nuove operazioni sui tipi primitivi nuove operazioni su nuovi tipi Tipi di Dato Astratto: associazione nuovo tipo nuovo insieme di operazioni. / Implementazione Definizione del Tipo di Dato Astratto indipendente da: linguaggio di programmazione scelta implementativa (struttura dati) /

5 Implementazione in C Definire in un file separato le procedure corrispondenti alle operazioni definite dal Tipo di Dato Astratto. Definire un tipo di dato corrispondente al Tipo di Dato Astratto. Lavorare sul Tipo di Dato Astratto esclusivamente utilizzando le procedure fornite. Campi dato visibili solo attraverso le funzioni. / Definizione del tipo: typedef SET_ELEM int; Esempi di procedure: SET_ELEM *unione (SET_ELEM *, SET_ELEM *); SET_ELEM *inters(set_elem *, SET_ELEM *); SET_ELEM *diff(set_elem *, SET_ELEM *); SET_ELEM *make_null(void); int size (SET_ELEM *); void dump (SET_ELEM *); /

6 Algoritmi e Programmazione Avanzata - teoria / Definizione Tipo di dato astratto con politica LIFO (Last In First Out) con operazioni: Push: inserisce nuovo elemento nella pila Pop: estrae dalla pila l ultimo elemento inserito Empty: vero se pila vuota Init: crea nuova pila /

7 Init() / Push (K) K /

8 Push (K) K K / K Push (K) K K /

9 Pop K K K / Pop K K /

10 Implementazione tramite vettore Vettore buff di N elementi Variabile top: indice dell ultimo elemento inserito Complessità delle operazioni T(n) = O() / Implementazione C / #define N int buff[n]; int top; void push(int val); int pop(void); int empty(void); void push(int val) { buff[++top] = val; return; } /

11 Implementazione C / int pop(void) { return(buff[top--]); } int empty(void) { if(top == ) return (); else return (); } / Algoritmi e Programmazione Avanzata - teoria /

12 Definizione Tipo di dato astratto con politica FIFO (First In First Out) con operazioni: Enqueue: inserisce un nuovo elemento nella coda Dequeue: estrae dalla coda il primo elemento inserito Empty: vero se coda vuota Init: crea nuova coda. / Dequeue Enqueue Init() /

13 Dequeue Enqueue Enqueue(K) K / Dequeue Enqueue Enqueue(K) K K /

14 Dequeue Enqueue Enqueue(K) K K K / Dequeue Enqueue Dequeue K K K /

15 Dequeue Enqueue Dequeue K K / Implementazione tramite vettore Vettore buffer di N+ elementi per code di N elementi Variabili: head: indice del primo elemento inserito tail: indice del primo elemento disponibile per l inserimento Vettore come buffer circolare Complessità delle operazioni T(n) = O() /

16 Buffer circolare Dequeue: incrementa head modulo N+ Enqueue: incrementa tail modulo N+ Inizialmente head =, tail = Coda piena (overflow): head = (tail + ) modulo N+ Coda vuota (underflow): head = tail / Coda con max elementi (N=) Coda vuota head tail /

17 Coda con max elementi (N=) Enqueue(A) head tail / Coda con max elementi (N=) A Enqueue(A) head tail /

18 Coda con max elementi (N=) A Enqueue(B) head tail / Coda con max elementi (N=) A B Enqueue(B) head tail /

19 Coda con max elementi (N=) A B Enqueue(C) head tail / Coda con max elementi (N=) A B C Enqueue(C) head tail /

20 Coda con max elementi (N=) A B C Enqueue(D) head tail / Coda con max elementi (N=) A B C D Enqueue(D) head tail /

21 Coda con max elementi (N=) A B C D Dequeue head tail / Coda con max elementi (N=) Dequeue A B C D head tail /

22 Coda con max elementi (N=) B C D Enqueue(E) head tail / Coda con max elementi (N=) B C D E Enqueue(E) head tail /

23 Coda con max elementi (N=) B C D E Enqueue(F) head tail / Coda con max elementi (N=) B C D E F Enqueue(F) tail head Coda piena /

24 Coda con max elementi (N=) B C D E F Dequeue tail head / Coda con max elementi (N=) B C D E F Dequeue tail head /

25 Coda con max elementi (N=) C D E F Enqueue(G) tail head / Coda con max elementi (N=) G C D E F Enqueue(G) head tail Coda piena /

26 Coda con max elementi (N=) G C D E F Dequeue head tail / Coda con max elementi (N=) C G D E F Dequeue tail head /

27 Coda con max elementi (N=) D G E F Dequeue tail head / Coda con max elementi (N=) E G F Dequeue tail head /

28 Coda con max elementi (N=) F G Dequeue head tail / Coda con max elementi (N=) G Dequeue head tail Coda vuota /

29 Implementazione in C #define DIM int buffer[dim+]; int tail=, head=; int enqueue(int elem); int dequeue(void); int empty(void); / Implementazione in C int enqueue(int elem) { if((tail+)==head (tail==dim && head==)) return(-); buffer[tail++] = elem; if(tail == (DIM+)) tail = ; return(); } /

30 Implementazione in C int dequeue(void) { int ret; if(head == tail) return(-); ret = buffer[head++]; if(head == (DIM+)) head = ; return(ret); } / Implementazione in C int empty(void) { if(head == tail) return(); else return(); } /

31 Algoritmi e Programmazione Avanzata - teoria / Definizione Struttura dati lineare: elementi allocati/deallocatiseparatamente elementi concatenati (e quindi accessibili) attraverso puntatori variabile head: accesso al primo elemento operazioni: - insert (in testa di linea non ordinata o in lista ordinata) - search - delete /

32 Definizione Vantaggi/svantaggi: memoria corrispondente agli elementi effettivamente utilizzata accesso mediante scansione Classificazione: liste ordinate / non ordinate / Definizione Operazioni: Insert(L, k): nserisce una chiave k nella lista L - liste non ordinate: in testa - liste ordinate: posizione corretta Search(L, k): cerca la chiave k nella lista L Delete(L, x): cancella la chiave k dalla lista L dato il puntatore x all elemento che la contiene. /

33 Lista concatenata semplice key next head(l) NIL Lista concatenata doppia previous key next head(l) NIL NIL / Inserimento in testa (lista non ordinata) head(l) Z P NIL /

34 Inserimento in testa (lista non ordinata) insert(l, x) x A NIL head(l) Z P NIL / Inserimento in testa (lista non ordinata) head(l) A next(x) = head(l) head(l) = x Z P NIL /

35 Implementazione C struct e { int key; struct e *next; }; struct e *insert(struct e *ptop, int val); struct e *search(struct e *ptop,int *val, int *status); struct e *newe( ); / Implementazione C struct e *newe ( ) /

36 Implementazione C struct e *newe ( ) Allocazione di un nuovo nodo / Implementazione C struct e *newe ( ) { struct e *eptr; } eptr = (struct e *) malloc (sizeof (struct e)); if (eptr==null) { fprintf (stderr, "Allocazione fallita."); exit (FAILURE); } return (eptr); /

37 Implementazione C struct e *insert (struct e *ptop,int val) / Implementazione C Inserimento in testa struct e *insert (struct e *ptop,int val) /

38 Implementazione C struct e *insert (struct e *ptop,int val) { struct e *pnew; pnew = newe (); pnew->key = val; pnew->next = ptop; / Implementazione C struct e *insert (struct e *ptop,int val) { struct e *pnew; pnew = newe (); pnew->key = val; pnew->next = ptop; next(x) = head(l) /

39 Implementazione C struct e *insert (struct e *ptop,int val) { struct e *pnew; pnew = newe (); pnew->key = val; pnew->next = ptop; ptop = pnew; / Implementazione C struct e *insert (struct e *ptop,int val) { struct e *pnew; pnew = newe (); pnew->key = val; pnew->next = ptop; ptop = pnew; head(l) = x /

40 Implementazione C struct e *insert (struct e *ptop,int val) { struct e *pnew; pnew = newe (); pnew->key = val; pnew->next = ptop; ptop = pnew; } return (ptop); / Ricerca Scansione della lista a partire da head Confronto chiave cercata / chiave corrente Terminazione: trovata la chiave cercata fine lista /

41 Implementazione C struct e *search (struct e *ptop,int *val,int *status) / Implementazione C struct e *search (struct e *ptop,int *val,int *status) ricerca /

42 Implementazione C struct e *search (struct e *ptop,int *val,int *status) { struct e *ptmp; *status = FAILURE; ptmp=ptop; while ((ptmp!=null) && (*status==failure)) { if (ptmp->key==*val) { *status = SUCCESS; } else { ptmp=ptmp->next; } } / Implementazione C if (*status==success) { fprintf (stdout,"trovato %d\n",ptmp->key); } else { fprintf (stdout,"non Trovato \n"); } } return (ptop); /

43 Cancellazione Richiede: una ricerca, che produce il puntatore x all'elemento da cancellare il riaggiustamento dei puntatori - all elemento da cancellare - all elemento precedente - all elemento seguente (lista concatenata doppia) / Cancellazione head(l) NIL P A Z NIL /

44 Cancellazione delete(l, x) x head(l) NIL P A Z NIL / Cancellazione head(l) NIL P A Z NIL prev[next[x]] = prev[x] next[prev[x]] = next[x] /

45 Complessità Inserzione in testa di lista non ordinata: T(n) = O() Ricerca: T(n) = O(n) Cancellazione (dato il puntatore all elemento da cancellare): T(n) = O() / Algoritmi e Programmazione Avanzata - teoria /

46 Definizione / Tipo di dato astratto con operazioni: search minimum maximum predecessor successor insert delete Implementano dizionari e code prioritarie. / Definizione / Proprietà: nodo x vale che: nodo y Left(x), key[y] key[x] nodo y Right(x), key[y] key[x] x Left(x) Right(x) /

47 Esempi / Attraversamenti Attraversamento: elenco dei nodi secondo una strategia: Pre-ordine: x, Left(x), Right(x) In-ordine: Left(x), x, Right(x) Post-ordine: Left(x), Right(x), x Complessità: T(n) = Q(n) Attraversamento in-ordine: ordinamento crescente delle chiavi. /

48 / Visita in pre-ordine /

49 Visita in pre-ordine / Visita in pre-ordine /

54 Visita in-ordine / Visita in-ordine /

60 Visita in post-ordine / Visita in post-ordine /

66 Search Ricerca ricorsiva di un nodo con chiave k: percorrimento dell albero dalla radice; terminazione: trovato k oppure giunti a una foglia; ricorsione: dal nodo x - su sottoalbero sinistro se k < key[x] - su sottoalbero destro se k key[x]. / k = /

67 k = / k = /

68 k = < / k = < /

69 k = / k = /

70 k = / k = > /

71 k = > / k = /

72 k = / k = /

73 k = > / k = > /

74 k = / k = /

75 k = = / k = = Trovato! /

76 Min e max Min: seguire il puntatore al sottoalbero sinistro finchè esiste. Max: seguire il puntatore al sottoalbero destro finchè esiste. / /

77 / /

78 min = / min = /

79 min = max = / Successor Successore di un nodo x: nodo con la più piccola chiave k > key[x]. Due casi: Right(x): succ(x) = min(right(x)) Right(x): succ(x) = primo antenato di x il cui figlio sinistro è anche un antenato di x. p[x] x x p[x] /

80 / x /

81 x / x /

82 x succ(x) / /

83 x / x /

84 succ(x) x / Predecessor Predecessore di un nodo x: nodo con la più grande chiave k < key[x]. Due casi: Left(x): pred(x) = max(left(x)) Left(x): pred(x) = primo antenato di x il cui figlio destro è anche un antenato di x. /

85 / x /

86 x / x /

87 x pred(x) / /

88 x / x /

89 pred(x) x / Insert Inserire in un albero binario di ricerca un nodo z con chiave key[z] mantenimento della proprietà: creazione del nuovo nodo z, con Left[z]=Right[z]=NIL; posizione di inserimento di z come foglia, simulando la ricerca di key[z]; aggiornamento dei puntatori. /

90 z T insert(t,z) / z T insert(t,z) /

93 T / Delete Cancellazione da un albero binario di ricerca di un nodo z mantenimento della proprietà mantenimento della struttura ad albero binario. Tre casi:. nodo z foglia. nodo z con solo figlio. nodo z con figli. /

94 Caso : foglia z / Caso : foglia delete(z): rimozione immediata. z /

95 Caso : foglia / Caso : figlio delete(z): z /

96 Caso : figlio delete(z): z x / Caso : figlio delete(z): il figlio x di z diventa figlio delpadre p di z. p z x /

97 Caso : figlio / z delete(z): Caso : figli /

98 z Caso : figli delete(z): si cancella y = succ(z) y / z Caso : figli delete(z): si cancella y = succ(z) si copia y su z y /

99 z Caso : figli delete(z): si cancella y = succ(z) si copia y su z y Nota: y può essere pred(z) / Caso : figli /

100 Complessità Le operazioni hanno complessità T(n) = O(h): albero con n nodi completamente bilanciato - altezza h = log n albero con n nodi completamente sbilanciato - altezza h = n O(log n) T(n) O(n) / /

101 Dizionario Tipo di dato astratto Modello: insieme finito di simboli. Operazioni: search insert delete.? corrispondenza biunivoca insieme finito di simboli e intervallo di interi. / Applicazioni Tabella dei simboli di un compilatore Chiave = nome di un identificatore Dati aggiuntivi = tipo, contesto, dichiarazione. Cache di file o URL Chiave = path Dati aggiuntivi = attributi e contenuto. /

102 Tabelle ad accesso diretto / Chiave k U = {,,, m-} Tutte le chiavi sono distinte. Vettore T[,,, m-]: se k, T[k] punta a k, altrimenti T[k] = NIL. Memorizzazione di un insieme K di K chiavi. / Tabelle ad accesso diretto / U (universo delle chiavi) T m- K (chiavi usate) dati associati chiave k x /

103 Operazioni Search(T, k) return(t[k]) Insert(T, x) T[key[x]] = x Delete(T, x) T[key[x]] = NIL / Vantaggi/svantaggi Complessità delle operazioni: T(n) = O() Occupazione di memoria S(n) = O( U ) = O(m) applicabile per m piccolo spreco di memoria per K << m. /

104 Tabelle di hash In generale: m grande (vettore T non allocabile) K << m. Tabella di hash: tipo di dato astratto con occupazione di spazio O( K ) e tempo medio di accesso O(). / Funzione di hash / La tabella di hash contiene K elementi ( K << U ) Funzione di hash h: mappa una chiave k in una posizione del vettore h(k) h: U fi {,,..., m- } Elemento x viene memorizzato nella locazione T[h(key[x])] /

105 Funzione di hash / U k k k k k m- T / Funzione di hash / U k k k k k m- T h(k ) /

106 Funzione di hash / U k k k k k m- T h(k ) h(k ) / Funzione di hash / U k k k k k m- T h(k ) h(k ) h(k ) /

107 Funzione di hash / U k k k k k m- T h(k ) h(k ) h(k ) h(k ) / Funzione di hash / U k k k k k m- T h(k ) h(k ) h(k )=h(k ) Collisione h(k ) /

108 Progetto della funzione di hash / Funzione ideale hashing uniforme semplice: se le chiavi k sono equiprobabili, allora i valori di h(k) devono essere equiprobabili. k: h( k) = j P( k) =, j =,, K, m m / Progetto della funzione di hash / In pratica: k non sono equiprobabili, anzi correlate: - usare tutti i bit della chiave - amplificare le differenze. chiavi come numeri interi (illimitati) - abc diventa a * + b * + c. /

109 Metodi Divisione: h(k) = k mod m m: primo non troppo vicino a potenza di. Evitare che m sia: - potenza di (usa solo gli ultimi m bit di k); - una potenza di (se i k sono numeri decimali); - p - (per stringhe di caratteri in base p, trasposizioni di caratteri collisioni). / / n = elementi previsti numero di confronti medio pari a nelle ricerche m = : numero primo vicino a / ma distante dalle potenze di h(k) = k mod /

110 / Moltiplicazione: data costante <A< h(k) = m (k A - k A ) k A rimescola i bit i k m (k A - k A ) espande l intervallo [,] nell intervallo [,m]. Scelta: m potenza di (estrazione di sotto-sequenza di bit); A = ( ) / =.. / Collisione Definizione: collisione: h(k i )=h(k j ) per k i k j Le collisioni sono inevitabili, occorre: minimizzarne il numero (buona funzione di hash); gestirle: - linear chaining - open addressing. /

111 Linear Chaining / Più elementi possono risiedere nella stessa locazione della tabella T lista concatenata. Operazioni: inserimento in testa alla lista ricerca nella lista cancellazione dalla lista. / Linear Chaining / U k k k k k k m- T /

112 Linear Chaining / U k k k k k k m- T k / Linear Chaining / U k k k k k k m- T k k /

113 Linear Chaining / U k k k k k k m- T k k k / Linear Chaining / U k k k k k k m- T k k k k /

114 Linear Chaining / U k k k k k k m- T k k k k k / Linear Chaining / U k k k k k k m- T k k k k k k /

115 Complessità / Ipotesi: Liste non ordinate: n = numero di elementi memorizzati m = dimensione della tabella di hash. Hashing semplice uniforme: h(k) ha egual probabilità di generare gli m valori di uscita. Definizione fattore di carico a=n/m (>, = o < ) / Complessità / Inserimento: T(n) = O() Ricerca: caso peggiore T(n) = Q(n) caso medio T(n) = O(+a) Cancellazione: T(n) = O() se disponibile il puntatore ad x e la lista è doppiamente linkata; come la ricerca se disponibile il valore di x, oppure il valore della chiave k, oppure la lista è semplicemente linkata. /

116 Open addressing Ogni cella di T può contenere un solo elemento. Tutti gli elementi sono memorizzati in T. Collisione: ricerca di cella non ancora occupata mediante probing: generazione di una permutazione delle celle = ordine di ricerca della cella libera. a h(k, i) : U {,,...,m- } fi {,,...,m- } chiave tentativo ( m-) / Funzioni di probing Linear probing h(k, i) = (h (k)+i) mod m Quadratic probing h(k, i) = (h (k)+ c i + c i ) mod m c e c Double hashing h(k, i) = (h (k)+ i h (k) ) mod m dove: h (k) = k mod m h (k) = + (k mod m ) m = m- o m- /

117 Operazioni / Insert: tentativo i= calcola h(k, i) se libero, inserisci chiave, altrimenti incrementa i ripeti fino a i=m Search: tentativo i= calcola h(k, i) se trovata chiave, termina con successo incrementa i ripeti fino a i=m o cella vuota (insuccesso). / Operazioni / Delete: operazione complessa che interrompe le catene di collisione. L open addressing è in pratica utilizzato solo quando non si deve mai cancellare. /

118 Complessità Ipotesi: hashing semplice uniforme probing uniforme. Tentativi di probing : per l inserimento: /( a) per la ricerca: - senza successo: /( a) - con successo: /a ln (/(- a)) + / a / Inserimento delle chiavi,,,,,,,, in tabella con m= con open addressing. /

119 ,,,,,,,, /,,,,,,,, Linear probing h(k, i) = (k mod + i) mod /

120 ,,,,,,,, Linear probing h(k, i) = (k mod + i) mod /,,,,,,,, Linear probing h(k, i) = (k mod + i) mod /

121 ,,,,,,,, Linear probing h(k, i) = (k mod + i) mod /,,,,,,,, Linear probing h(k, i) = (k mod + i) mod /

122 ,,,,,,,, Linear probing h(k, i) = (k mod + i) mod Collisione: h(, ) = /,,,,,,,, Linear probing h(k, i) = (k mod + i) mod Collisione: h(, ) = /

123 ,,,,,,,, Linear probing h(k, i) = (k mod + i) mod /,,,,,,,, Linear probing h(k, i) = (k mod + i) mod Collisione: h(, ) = /

128 ,,,,,,,, Linear probing h(k, i) = (k mod + i) mod primary clustering /,,,,,,,, Quadratic probing h(k, i) = (k mod +i+i ) mod /

129 ,,,,,,,, Quadratic probing h(k, i) = (k mod +i+i ) mod /,,,,,,,, Quadratic probing h(k, i) = (k mod +i+i ) mod /

130 ,,,,,,,, Quadratic probing h(k, i) = (k mod +i+i ) mod /,,,,,,,, Quadratic probing h(k, i) = (k mod +i+i ) mod /

131 ,,,,,,,, Quadratic probing h(k, i) = (k mod +i+i ) mod Collisione: h(, ) = /,,,,,,,, Quadratic probing h(k, i) = (k mod +i+i ) mod Collisione: h(, ) = /

132 ,,,,,,,, Quadratic probing h(k, i) = (k mod +i+i ) mod /,,,,,,,, Quadratic probing h(k, i) = (k mod +i+i ) mod Collisione: h(, ) = /

140 ,,,,,,,, Quadratic probing h(k, i) = (k mod +i+i ) mod Collisione: h(, ) = /,,,,,,,, Double hashing h(k, i) = (k mod +i(+k mod )) mod /

141 ,,,,,,,, Double hashing h(k, i) = (k mod +i(+k mod )) mod /,,,,,,,, Double hashing h(k, i) = (k mod +i(+k mod )) mod /

142 ,,,,,,,, Double hashing h(k, i) = (k mod +i(+k mod )) mod /,,,,,,,, Double hashing h(k, i) = (k mod +i(+k mod )) mod /

143 ,,,,,,,, Double hashing h(k, i) = (k mod +i(+k mod )) mod Collisione: h(, ) = /,,,,,,,, Double hashing h(k, i) = (k mod +i(+k mod )) mod Collisione: h(, ) = /

144 ,,,,,,,, Double hashing h(k, i) = (k mod +i(+k mod )) mod Collisione: h(, ) = /,,,,,,,, Double hashing h(k, i) = (k mod +i(+k mod )) mod /