Tutorato di Algoritmi e Strutture Dati AA

Transcript

1 Tutorato di Algoritmi e Strutture Dati AA Maron Giulio 1 maggio 005 Indie 1 Invarianti Invarianti e onvenzioni per la srittura del odie Correttezza Insertion-Sort Correttezza List-Searh Complessità 4.1 Complessità di un frammento di odie Ordinamento tra funzioni Divide-et-impera Calolo della omplessità di un algoritmo riorsivo Massimo di un array Complessità di un algoritmo he ne usa un altro Exploding-Reursion Strutture dati elementari Liste: inserimento in oda Liste: eliminazione elemento Unione ordinata di liste Numero di nodi on una erta hiave in un albero binario aumentato Cammini di un albero binario Verifia proprietà max-heap Invarianti 1.1 Invarianti e onvenzioni per la srittura del odie Considerare il seguente problema di riera: Input : Una sequenza di n numeri A =< a 1,a,...,a n > ed un valore v. Output : Un indie i tale he v = A[i] oppure il valore speiale nil se v non appare in A. 1

2 Srivere lo pseudoodie per linear searh, he sorre la sequenza, erando v. Usando un invariante, dimostrare he l algoritmo è orretto. Assiurarsi he l invariante soddisfi le tre proprietà neessarie (inizializzazione, mantenimento, terminazione). [CLRS01, eserizio.1-3]. Linear-Searh(A, v) 1 for i 1 to length[a] do if A[i] = v 3 then return i 4 v non è presente. 5 return nil Invariante : all inizio del ilo for la sequenza A[1..i 1] non ontiene v; Inizializzazione : quando i = 1, la sequenza A[1..0] non ha elementi per ui non può ontenere v; Mantenimento : la sequenza A[1..i 1] non ontiene v; se A[i] = v, allora viene restituito i, ed è un i he soddisfa l output; altrimenti A[1..i] non ontiene v e, dopo l inremento di i, A[1..i 1] non ontiene v; Terminazione : se si ese dal ilo for, allora i = length[a] + 1 e per l invariante A[1.. i 1] = A[1.. length[a]] non ontiene v; allora viene restituito nil, soddisfando anora l output. 1. Correttezza Insertion-Sort Insertion-Sort(A) 1 for j to length[a] do key A[j] 3 Inserise A[j] nella sequenza ordinata A[1..j 1]. 4 i j 1 5 while i > 0 and A[i] > key 6 do A[i + 1] A[i] 7 A[i] key 8 i i 1 Invariante: all inizio di ogni iterazione del ilo for (linee 1-8), l array A[1.. j 1] ontiene gli elementi inizialmente ontenuti in A[1..j 1] ma ordinati; Inizializazione: quando j =, l array A[1..j 1] ontiene solo l elemento A[1], ossia quello iniziale he è ovviamente ordinato; Mantenimento: per provare il mantenimento dell invariante bisogna provare he l array A[1..j] sia ordinato alla fine del ilo, osihé all inremento di j risulti he l array A[1..j 1] è ordinato. Dobbiamo allora provare un invariante per il ilo while interno:

3 Invariante: all inizio di ogni iterazione del ilo while interno delle linee 5-8 vale he: 1. gli array A[1..i] e A[i + 1..j] sono ordinati;. il valore key è in A[i + 1]; 3. se i < j 1 (vale solo nel primo ilo), l elemento di A[i] è minore o uguale a A[i + ]; Inizializzazione: nel primo ilo i = j 1: 1. l array A[1..j 1] è ordinato (per l invariante del for ); l array A[j..j] ha un elemento solo ed è quindi trivialmente ordinato.. A[i + 1] = A[j] = key per l assegnamento iniziale; 3. i j 1; Mantenimento: mostriamo he tutte e tre le ondizioni dell invariante interna sono mantenute: 1. sappiamo he A[1..i] è ordinato per l invariante interna; allora anhe A[1..i 1] è ordinato e quindi possiamo derementare i; anhe A[i + 1..j] è ordinato, e per di più A[i] > key = A[i + 1]; sapendo inoltre he A[i] A[i + ], sambiare A[i] e A[i + 1] mantiene la sequenza A[i+1] A[i] A[i+] ordinata e l array A[i..j] è ordinato anhe dopo il deremento di i;. poihé A[i + 1] e A[i] vengono sambiati e key è originalmente in i + 1, il deremento di i mantiene la hiave in posizione i + 1 alla fine del ilo; 3. lo sambio ed il deremento di i ausa i seguenti spostamenti di elementi: dalla posizione i 1 alla posizione i; dalla posizione i alla posizione i+; poihé A[i 1] A[i] per l invariante interna, manteniamo l invariante A[i] A[i + ]; Terminazione: il ilo while termina quando i = 0 o quando abbiamo un i tale he A[i] <= key; esaminando i due asi: se i = 0 allora l invariante interna garantise he l array A[1..j] sia ordinato; se A[i] key allora l invariante interna garantise he A[1..i] e A[i j] siano ordinati; essendo key in posizione A[i + 1] e A[i] key, allora A[i] A[i + 1]; poihé l elemento più grande del primo array è più minore o uguale al più piolo elemento del seondo array, ne segue he l intero array A[1..j] è ordinato. Terminazione: il ilo for finise quando j supera n, ossia quando j = n + 1. Sostituendo n + 1 a j nella diitura dell invariante, ottieniamo he l array A[1..n] ontiene gli elementi originalmente in A[1..n] ma ordinati. Poihé A[1.. n] è l intero array abbiamo dimostrato la orrettezza dell algoritmo! Infine, è interessante notare he possiamo rimuovere la linea 7, sempliemente aggiornando il valore A[i + 1] alla fine del ilo, visto he non utilizziamo il suo valore all interno del while : 3

4 Insertion-Sort(A) 1 for j to length[a] do key A[j] 3 Inserise A[j] nella sequenza ordinata A[1..j 1]. 4 i j 1 5 while i > 0 and A[i] > key 6 do A[i + 1] A[i] 7 i i 1 8 A[i + 1] key 1.3 Correttezza List-Searh List-Searh prende in input una lista L ed una hiave k e ritorna un elemento x della lista tale he key[x] = k oppure nil se la lista non ontiene nessun elemento di hiave k. List-Searh(L, k) 1 x head[l] while x nil and key[x] k 3 do x next[x] 4 return x Invariante: all inizio di ogni iterazione del ilo while, nessun elemento prima di x nella lista ontiene la hiave k; Inizializazione: quando x = head[l], non i sono elementi prima di x, per ui non e ne possono essere he ontengono la hiave k; Mantenimento: all inizio del ilo while, gli elementi prima di x non ontengono la hiave k, per l invariante; la ondizione del while garantise he all interno del ilo key[x] k; allora spostare x all elemento dopo mantiene l invariante perhé gli elementi prima di x ontinueranno a non ontenere la hiave k; Terminazione: il ilo while finise quando x = nil oppure quando key[x] = k: se x = nil allora, per l invariante, tutti gli elementi prima di x non ontengono la hiave k ed essendo x oltre l ultimo elemento della lista, nessun elemento della lista ha hiave k; tornare x = nil soddisfa i requisiti dell output; se key[x] = k allora tornare x soddisfa l output. Complessità.1 Complessità di un frammento di odie Trovare la omplessità asintotia del seguente frammento di odie: 4

5 ... 1 temp A[1,1] max n 3 for i 1 to n 4 do for j 1 to max 5 do if A[i,j] > temp 6 then temp A[i,j] 7 max max/... Calolare il numero di volte he viene eseguito l assegnamento di linea 6 è impossibile non onosendo a priori il ontenuto dell array A. Per il alolo della omplessità si assume omunque il aso peggiore, per ui l assegnamento verrà eseguito tante volte quante il test dell if di riga 5. Il problema si ridue dunque a apire quante volte viene eseguito il ilo for interno (linee 4-6): ovviamente questo viene eseguito max volte, ma max varia ad ogni ilo del for esterno (linee 3-7), essendo dimezzato in riga 7. Si può desrivere il valore di max in funzione del valore di i: infatti max = n. Ora si sa quanto vale max per un i 1 arbitrario valore di i. Il ilo for interno verrà allora eseguito in tutto questo numero di volte: n max = i=1 = n( 1 n i=1 n n i 1 = n ( 1 i=1 ) n 1+1 ( 1 1 ) n = n 1 ( = n 1 1 ) }{{ n } 1 ) i 1 n 1 = n = n = Θ(n) k=0 ( ) k 1 = (( ) n 1 1) = Il numero di volte he vengono eseguite le rimanenti istruzioni è semplie da alolare: gli assegnamenti di righe 1- sono ovviamente Θ(1), e le istruzioni di inremento e onfronto del for esterno (riga 3 e riga 7) hanno omplessità Θ(n). Allora la omplessità del frammento di odie è: linea omplessità 1-3 (n + 1) 4-6 n ( 1 1 n ) 7 n totale: Θ(n). Ordinamento tra funzioni Innanzitutto riordare he verrà usata la seguente notazione: 5

6 f(n) = O(g(n)) def = f(n) O(g(n)),n 0, n n 0,0 f(n) g(n) Ordinare le seguenti funzioni, rispetto alla relazione f g def = f = O(g): n lg n,nlg n,nlg n,n + nlg n,n lg n,n n,n + n, n si notano subito due funzioni nella stessa lasse: nlg n = Θ(nlg n ) = Θ(nlg n) = Θ(nlg n) n + nlg n = O(n lg n),n 0 n > n 0,0 n + nlg n n lg n n + nlg n n lg n n +nlg n n lg n lg n + 1 n allora per = 3 ed un qualunque n 0 > 1 la diseguaglianza vale n + nlg n = Θ(n lg n ) = Θ(n ) infatti: 1,,n 0 n > n 0,0 1 n n + nlg n n 1 n n + nlg n n + nlg n n 1 + lg n n + lg n n allora per 1 = 1, = 3 ed un qualunque n 0 > 1 la diseguaglianza vale n + nlg n = Ω(nlg n),n 0 n > n 0,0 nlg n n + nlg n n lg n + 1 allora per = 1 ed un qualunque n 0 > 1 la diseguaglianza vale n + n = Θ( n ) 1,,n 0 n > n 0,0 1 n n + n n 0 1 n n + n n 1 n + 1 n n + 1 n allora per 1 = 1, = ed n 0 = 4 la diseguaglianza vale 6

7 n n = Ω( n ),n 0 n > n 0,0 n n n n n n la diseguaglianza vale per = 1 e n 0 = 1 n lg n = O( n ),n 0 n > n 0,0 n lg n n n lg n n n3 n lg n n n allora la diseguaglianza vale per = 1 e n 0 = 8 (n 0 si può ottenere on proedimenti analitii). L ordinamento finale risulta:.3 Divide-et-impera n n n n + n n lg n n + nlg n n lg n nlg n nlg n [CLRS01, eserizio.3-5]: osservare he, nell eserizio della riera lineare, nel aso in ui la sequenza A sia già ordinata, è possibile ontrollare direttamente se l elemento entrale della sequenza è v e, in aso non lo sia, sartare già mezza sequenza dalla riera. Binary searh è un algoritmo he ripete questo proedimento, dimezzando ogni volta la parte rimanente della sequenza. Srivere lo pseudoodie, iterativo o riorsivo, per binary searh. Dimostrare he il tempo di eseuzione è al più Θ(lg n). In altre parole, onsiderare il seguente problema di riera: Input : Una sequenza di n numeri ordinata A =< a 1,a,...,a n > ed un valore v. Output : Un indie i tale he v = A[i] oppure il valore speiale nil se v non appare in A. Srivere lo pseudoodie per binary searh, he era v nella sequenza usando un approio divide-et-impera e dimostrare he il tempo di eseuzione è al più Θ(lg n). Versione riorsiva: 7

8 Binary-Searh-R(A, v, p, r) 1 if p > r then return nil 3 q (p + r)/ 4 if A[q] = v 5 then return q 6 if A[q] > v 7 then return Binary-Searh-R(A, v, p, q 1) 8 else return Binary-Searh-R(A, v, q + 1, r) Binary-Searh(A, v) Binary-Searh-R(A, v, 1, length[a]) Versione iterativa: Binary-Searh(A, v) 1 p 1 r length[a] 3 while p r 4 do q (p + r)/ 5 if A[q] = v 6 then return q 7 if A[q] > v 8 then r q 1 9 else p q return nil Notare he, mentre per la dimostrazione della orrettezza della versione iterativa bisogna individuare degli invarianti, per l analisi della versione riorsiva è suffiiente utilizzare l ipotesi induttiva alla base del ragionamento induttivo he giustifia l approio riorsivo divide-et-impera. Dimostriamo la orrettezza di Binary-Searh-R rispetto al seguente problema: Input : Una sequenza di n numeri ordinata A =< a 1,a,...,a n >, un valore v e due indii p e r. Output : Un indie i tale he v = A[i] e p i r oppure il valore speiale nil se v non appare in A[p..r]. Poihé l algoritmo è riorsivo usiamo un ragionamento induttivo: aso base : Il aso di base si verifia quando p > r e quindi A[p..r] non ontiene elementi. In questo aso l algoritmo orrettamente restituise il valore speiale nil; aso riorsivo : Quando p r prima si alola q = (p + r)/ e poi si onfronta v on A[q]. 8

9 Se v = A[q] l algoritmo restituise orrettamente l indie q. Se v < A[q], poihé l array è ordinato, v ompare in A[p..r] se e solo se v ompare in A[p..q 1]. L algoritmo effettua una hiamata riorsiva on estremi p e q 1. Essendo q 1 p < r p, l ipotesi induttiva assiura la orrettezza di questa hiamata e quindi dell algoritmo. Se v > A[q], poihé l array è ordinato, v ompare in A[p..r] se e solo se v ompare in A[q + 1..r]. L algoritmo effettua una hiamata riorsiva on estremi q + 1 e r. Essendo r p < r q 1, l ipotesi induttiva assiura la orrettezza di questa hiamata e quindi dell algoritmo. Analizziamo ora la omplessità di Binary-Searh-R: deomposizione - divide : la divisione in sottoproblemi rihiede tempo ostante (il alolo di q), per ui è Θ(1); onquista - impera : i due sottoproblemi hanno pari dimensione n/; uno dei due viene sartato per ui la omplessità è sempliemente T(n/); omposizione : la omposizione rihiede tempo ostante perhé la soluzione al sottoproblema è la soluzione al problema originale, per ui è Θ(1); Allora la omplessità è desritta dalla seguente equazione riorsiva: { Θ(1) se n 1 T(n) = T( n ) + Θ(1) altrimenti Per risolvere l equazione riorsiva utilizziamo il metodo di sostituzione, individuando la funzione su ui sommettere tramite il metodo dell albero di riorsione. L albero di riorsione he si ottiene è quello di figura 1. Per ottenere l altezza dell albero, si osservi he al livello i la dimensione del problema è n i. Allora bisogna trovare il primo i tale he n i 1, il aso base: n 1 i n i i lg n i = lg n Applihiamo allora il metodo di sostituzione sommettendo sulla funzione O(lg n). Allora dobbiamo dimostrare he T(n) = lg n utilizzando l ipotesi induttiva he T( n ) = lg n T(n) = T( n ) + 1? lg n lg n + 1? lg n lg n lg + 1?? lg n lg 1 1 9

10 T(n) T(n/) T(n/4) lg n Total: O(lg n) Figura 1: Albero di riorsione di Binary-Searh-R. Quindi il passo induttivo è dimostrato per qualunque ostante 1. Ora è neessario trovare un aso base; per T(1) si ha: 1 = T(1) lg 1 = 0 Per T() = T( ) + 1 = però si ottiene un aso base valido: = T() lg = Il aso base è valido per una qualunque ostante. Allora abbiamo dimostrato he T(n) = O(lg n) tramite il metodo di sostituzione utilizzando una ostante =..4 Calolo della omplessità di un algoritmo riorsivo Calolare la omplessità del seguente algoritmo: Radix-Reursion(n) 1 if n then return 1 3 else return 1 + Radix-Reursion( n) Desriviamo dapprima la omplessità in termini di un equazione riorsiva: nel aso base (n ) il tempo rihiesto dal return in riga è ostante; nel 10

11 aso riorsivo il tempo rihiesto è quello della hiamata riorsiva più un tempo ostante; Allora la omplessità è desritta dalla seguente equazione riorsiva: { Θ(1) se n T(n) = T( n) + Θ(1) altrimenti Per risolvere l equazione utilizziamo il metodo di sostituzione. Abbiamo bisogno di una funzione su ui sommettere e si riava on l albero di riorsione di figura. lg lg n Total: O(lg lg n) Figura : Albero di riorsione di Radix-Reursion. Per ottenere l altezza dell albero bisogna osservare he ad ogni livello la dimensione del problema è n 1 i = n i. Allora bisogna trovare il primo i tale he n i, il aso base: n i i log n i lg log n i lg lg lg n i lg lg + lg lg n i lg 1 + lg lg n i lg lg n i = lg lg n per n 1 A questo punto abbiamo una funzione su ui sommettere on il metodo di sostituzione: O(lg lg n). Applihiamo il metodo, dimostrando he T(n) = lg lg n, usando l ipotesi induttiva T( n) = lg lg n: 11

12 T( n) + 1 lg lg n + 1 (lg lg n lg lg n) lg lg n lg n??? 1? 1 lg log n n? 1 lg? 1 1 lg lg n lg lg n Quindi per una qualunque ostante 1 il ragionamento induttivo vale. Ora basta trovare un aso base: si noti he per T() = 1 non si riese a provare 1 lg lg = lg 1 = 0. Allora è neessario trovare un altro aso base del ragionamento induttivo. Utilizzando n = 3, risulta il aso base T(3) = lg lg 3 he vale per ogni 4. Avendo trovato un aso base vale, seondo il ragionamento induttivo, he T(n) = O(lg lg n). Un altra possibile dimostrazione è utilizzando le sostituzioni di variabili. In modo partiolare, data: T(n) = T( n) + 1 si sostituise m = lg n: T( m ) = T( m ) + 1 ora sostituendo on la nuova funzione S(m) = T( m ) si ottiene: ( m ) S(m) = S + 1 la ui soluzione, già trovata in preedenza (eserizio Binary-Searh), è O(lg n). Si ha allora, riordando he m = lg n: T(n) = T( m ) = S(m) = O(lg m) = O(lg lg n).5 Massimo di un array Srivere un algoritmo he trovi il massimo elemento di un array utilizzando un approio divide-et-impera. Confrontarne poi la omplessità on l algoritmo Max. Max (A) 1 max A[1] for i to length[a] 3 do if A[i] > max 4 then max A[i] 5 return max 1

13 Max-R(A, p, r) 1 if p > r then return 3 q (p + r)/ 4 a Max-R(A,p,q) 5 b Max-R(A,q + 1,r) 6 if a > b 7 then return a 8 else return b Max(A) 1 return Max-R(A, 1, length[a]) La omplessità dell algoritmo è definita dalla seguente equazione riorsiva: { Θ(1) se n 1 T(n) = T( n ) + Θ(1) altrimenti Per risolvere l equazione si utilizzerà, ome sempre, il metodo dell albero di riorsione unito al metodo di sostituzione. L albero di riorsione è il seguente: T(n) T ( ) n T ( ) n T ( n 4 ) T ( ) n 4 T ( ) n 4 T ( n 4 ) log n 4 Ad ogni livello i i sono i sottoproblemi, ognuno di omplessità ostante, per ui la omplessità di ogni livello è i. Il numero dei livelli è dato dal minimo i tale he: n i 1 13 i

14 ossia i = lg n. Allora la omplessità totale è data da: lg n i = lg n i=0 = n 1 = Θ(n) Si può appliare ora il metodo di sostituzione sommettendo sulla funzione O(n). Si deve dimostrare he T(n) n utilizzando la sostituzione T( n ) n (ipotesi induttiva): T(n) = T( n ) + 1? n n + 1? n 1 0 Non si riese a dimostrare il passo induttivo. Allora si può usare una funzione più stretta, ossia n 1. Si deve dimostrare he T(n) n 1 usando l ipotesi induttiva he T( n ) n 1: T(n) = T( n ) + 1? n 1 ( n 1)? + 1 n Ora he è stato dimostrato il passo induttivo, si può erare un aso base; per T(1) si ha: 1 = T(1) 1 e questo vale per ogni..6 Complessità di un algoritmo he ne usa un altro Trovare la omplessità asintotia dell algoritmo ProB: ProA(n) 1 if n = 0 then return 3 else return + n ProA(n 1) ProB(n) 1 s 0 for i 1 to n 3 do s s + ProA(i) 4 return s Per alolare la omplessità di ProB è neessario alolare anhe la omplessità di ProA, hiamato da ProB. 14

15 ProA è un algoritmo riorsivo la ui omplessità è desritta dalla seguente equazione riorsiva: { Θ(1) se n = 0 T ProA (n) = T ProA (n 1) + Θ(1) altrimenti La soluzione è T ProA (n) = Theta(n), ome si può riavare appliando una delle tenihe per la soluzione di equazioni riorsive. La omplessità di ProB è data dalla omplessità delle istruzioni in riga e di riga 4 (he sono ovviamente Θ(1)), e dalla omplessità del ilo for. L istruzione di riga viene eseguita (n+1) volte. L istruzione di riga 3 effettua una somma, un assegnamento ed una hiamata di osto T ProA (i). Poihé i varia ad ogni ilo, per alolare il osto della riga si deve fare una sommatoria: n n n 1+1+T ProA (i) = n+ T ProA (i) = Θ(n)+ Θ(i) = Θ(n)+Θ(n ) = Θ(n ) i=1 i=1 Poihé la omplessità di questa riga è predominante su tutte le altre, la omplessità di ProB è Θ(n )..7 Exploding-Reursion Calolare la omplessità della seguente funzione: Exploding-Reursion(n) 1 if n = 1 then return 1 3 else k 0 4 for i 1 to n 5 do k k + Exploding-Reursion(n 1) 6 return k La omplessità dell algoritmo è definita dalla seguente equazione riorsiva: { Θ(1) se n 1 T(n) = nt(n 1) + Θ(n) altrimenti Per risolvere l equazione si utilizzerà, ome sempre, il metodo dell albero di riorsione unito al metodo di sostituzione. L albero di riorsione è piuttosto diffile, ed è il seguente: i=1 T(n) n T(n 1) n T(n 1) 15

16 n (n 1) n (n 1) T(n ) (n 1) T(n ) T(n ) (n 1) T(n ) n! Ad ogni livello i risultano esseri (n i)! sottoproblemi, ognuno di dimensione (n i). Dato he la dimensione al livello i-esimo è (n i), si riava failmente l altezza dell albero, erando il minimo i tale he n i = 1, il aso base: ne risulta i = n 1. Allora i varia i = 0...n 1. La omplessità di un sottoproblema al livello i-esimo è data da (n i). Allora la omplessità totale di un livello i è: n! (n i) (n i)! E la omplessità di tutto l albero è: n 1 i=0 n 1 n! (n i)! (n i) = n! i=0 n 1 1 (n i 1)! = n! Ogni termine dell ultima sommatoria è siuramente minore di 1, per ui l intera sommatoria è siuramente minore di n. Si può failmente dimostrare on proedimenti analitii he la serie è onvergente; anora, si può trovare esattamente a osa onverge riordando he la sommatoria orrisponde allo sviluppo della serie di Taylor di e on un polinomio fino all n-esimo grado. Per ui risulta: n 1 1 n! = en! = Θ(n!) i! i=0 i=0 1 i! 3 Strutture dati elementari 3.1 Liste: inserimento in oda Sviluppare una nuova operazione di inserimento in oda per le liste Tail-Insert(L, x): questa ritorna una sequenza omposta dalla sequenza L seguita dall elemento x. L operazione deve essere sviluppata per liste semplii, liste doppie e liste doppie irolari, e deve esserne valutata la omplessità. Notare he, dovendo sviluppare un operazione, si può manipolare la struttura dati direttamente. Inoltre, poihé la Tail-Insert modifia la struttura dati, quest ultima deve essere tornata. Liste semplii: 16

17 Tail-Insert(L, x) 1 next[x] nil if head[l] = nil 3 then head[l] x return L 4 y head[l] 5 while next[y] nil 6 do y next[y] 7 next[y] x 8 return L Liste doppie: Tail-Insert(L, x) 1 next[x] nil if head[l] = nil 3 then prev[x] nil head[l] x 4 return L 5 y head[l] 6 while next[y] nil 7 do y next[y] 8 next[y] x 9 prev[x] y 10 return L Liste doppie irolari: Tail-Insert(L, x) 1 next[x] nil[l] prev[x] prev[nil[l]] 3 next[prev[nil[l]]] x 4 prev[nil[l]] x 5 return L Complessità Tail-Insert: Liste singole Θ(n) Liste doppie Θ(n) Liste doppie irolari Θ(1) 3. Liste: eliminazione elemento Sviluppare una funzione di eliminazione di un elemento Key-Delete(L, k): questa elimina dalla lista L il primo elemento di hiave k, se esiste, e ritorna la lista L modifiata. La funzione deve essere sviluppata per liste semplii, liste doppie e liste doppie irolari, e deve esserne valutata la omplessità. 17

18 Notare he, dovendo sviluppare una funzione, si devono utilizzare le operazioni definite sulle liste. L astrazione fornita dalle funzioni sull implementazione della struttura dati lista permettono oltretutto di avere un unia implementazione della funzione. Infatti, per tutte le liste, lo pseudo-odie è: Key-Delete(L, k) 1 x List-Searh(L, k) if x = nil 3 then return L 4 else return List-Delete(L, x) Complessità Key-Delete: List-Searh List-Delete Key-Delete Liste singole Θ(n) + Θ(n) = Θ(n) Liste doppie Θ(n) + Θ(1) = Θ(n) Liste doppie irolari Θ(n) + Θ(1) = Θ(n) 3.3 Unione ordinata di liste Sviluppare un algoritmo per l unione di due liste ordinate in un unia lista ordinata. List-Merge(L 1,L ) 1 Aggiunge alla fine delle liste: key[x] 3 Tail-Insert(L 1,x) 4 key[y] 5 Tail-Insert(L,y) 6 Crea una nuova lista L: 7 head[l] nil 8 Sorre le liste fino ad esaurire gli elementi: 9 x head[l 1 ] 10 y head[l ] 11 while key[x] or key[y] 1 do if key[x] key[y] 13 then z next[x] 14 L Tail-Insert(L, x) 15 x z 16 else z next[y] 17 L Tail-Insert(L, y) 18 y z 19 return L 18

19 3.4 Numero di nodi on una erta hiave in un albero binario aumentato Sviluppare un algoritmo he aggiunga ad ogni nodo di un albero binario un ampo ount he indihi il numero di nodi he hanno una erta hiave k. Tree-Key-Count (x, k) 1 if x = nil then return 0 3 else if key[x] = k 4 then k 1 5 else k 0 6 k k + Tree-Key-Count (lef t[x], k) 7 k k + Tree-Key-Count (right[x], k) 8 ount[x] k 9 return k Tree-Key-Count(T, k) 1 Tree-Key-Count (root[t], k) 3.5 Cammini di un albero binario Sviluppare un algoritmo he stampi tutti i ammini di un albero binario, utilizzando una lista per mantenere i nodi attraversati. Tree-All-Paths-R(x, L) 1 if x = nil then List-Print(List-Reverse(L)) 3 L List-Delete(L, head[l]) 4 else key[y] key[x] 5 L List-Insert(L, y) 6 Tree-All-Paths-R(lef t[x], L) 7 Tree-All-Paths-R(right[x], L) Tree-All-Paths(T) 1 head[l] nil Tree-All-Paths-R(root[T], L) 3.6 Verifia proprietà max-heap Dato un albero binario, verifiare la seguente proprietà (detta max-heap): ogni nodo dell albero ha hiave maggiore di entrambi i figli. 19

20 Tree-Test-Max-Heap (x, k) 1 if x = nil then return true 3 if k > key[x] 4 then return Tree-Test-Max-Heap (lef t[x], key[x]) 5 and Tree-Test-Max-Heap (right[x],key[x]) 6 else return false Tree-Test-Max-Heap(T) 1 Tree-Test-Max-Heap (root[t], ) Riferimenti bibliografii [CLRS01] Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest and Clifford Stein. Introdution to Algorithms, seond edition. The MIT Press/MGraw-Hill,