Esercizi su ABR. Prof. E. Fachini - Intr. Alg. 1

Transcript

1 Esercizi su ABR Confronto proprietà ABR e Max-Heap. Verifica stato dell albero a seguito di inserimento e cancellazione di uno stesso elemento e viceversa. Proprietà del cammino radice-foglia individuato da una ricerca. Fusione di due ABR. Il successivo calcolato dalla radice Costruzione di un ABR bilanciato nel numero dei nodi, a partire da un array ordinato. Visita inorder iterativa di un ABR. Calcolo del rango di una chiave in un ABR. Selezione di un nodo in un ABR di un dato rango. Verifica della proprietà di essere un ABR. Stampa delle chiavi in un intervallo. Prof. E. Fachini - Intr. Alg. 1

2 Capire ABR e maxheap Rispondere alle seguenti domande: 1. E possibile che un ABR T, completo almeno fino al penultimo livello, contenente almeno tre nodi ed avente chiavi distinte soddisfi anche le proprietà di ordinamento tra padri e figli di un Max-heap? Se si, mostrare un esempio di tale albero. Se no, dimostrarne l impossibilità. La risposta è no, il figlio destro deve avere una chiave maggiore di quella della radice in un ABR, mentre deve essere minore in un Max-Heap. 2. E possibile che un ABR T, contenente almeno tre nodi ed avente chiavi distinte soddisfi anche le proprietà di ordinamento tra padri e figli di un Max-heap? Se si, mostrare un esempio di tale albero. Se no, dimostrarne l impossibilità. La risposta è sì, basta prendere un albero degenere a sinistra, allora ogni figlio ha chiave minore del padre. Prof. E. Fachini - Intr. Alg. 2

3 Capire un ABR Se si inserisce un elemento k in un ABR (BST) T e poi lo si cancella si ottiene lo stesso albero T. Si motivi la risposta. Sì, perchè il nodo inserito è una foglia che viene eliminata senza altri cambiamenti sull albero.

4 Capire un ABR Se si cancella un elemento k da ABR (BST) T e poi lo si reinserisce si ottiene sempre lo stesso albero T? Si motivi la risposta.

5 Capire un ABR - sol NO, perchè se il nodo cancellato non è una foglia poi viene però reinserito come foglia. Esempio: 85 eliminazione di inserimento di

6 Capire un ABR 2 Supponiamo che l operazione di ricerca di una chiave k in un albero binario di ricerca termini su di una foglia. Consideriamo tre insiemi: A, l insieme delle chiavi alla sinistra del cammino di ricerca; B, l insieme delle chiavi del cammino di ricerca; C, l insieme delle chiavi alla destra del cammino di ricerca. Si potrebbe credere che se a A, b B e c C, allora a b c. Si produca un esempio che contraddice questa affermazione, specificando gli insieme A,B e C. Il cammino della ricerca è il cammino determinato dai confronti necessari a trovare k nell albero.

7 Capire un ABR se a A, b B e c C, allora a b c Ma non è sempre vero! Si produca un esempio che contraddice questa affermazione, specificando gli insiemi A, B e C. l insieme delle chiavi alla sinistra del cammino di ricerca A= {20,15,17,25} l insieme delle chiavi del cammino di ricerca B={50,30,40,35,33} l insieme delle chiavi alla destra del cammino di ricerca A= {85,55,90,100}

8 Capire un ABR - sol Caso 1: k=60 A={35} B={30,40,50,45} C={52,55,70,85,100} e 35 è in A, ma è > 30 che è in B Caso 2: k=52 A={30,35,40,45} B={50,52,55,85} C={70,100} e 70 è in C, ma è < 85 che è in B

9 Capire un ABR Dati due alberi binari di ricerca T1 e T2, supponiamo che le chiavi in T1 siano tutte minori di quelle in T2 e che la radice contenga un campo aggiuntivo con l altezza dell albero. Si scriva un algoritmo per ottenere un albero binario di ricerca su tutte le chiavi in T1 e in T2 in O(h), dove h è l altezza minima tra quelle dei due alberi. L albero ottenuto deve avere altezza pari a quella del sotto albero di altezza massima +1. a T1 b T2 Qui h1, l altezza di T1, è minore di h2, l altezza di T2. a T1 b T2 Qui h2, l altezza di T2, è minore di h1, l altezza di T1.

10 Capire un ABR - sol a T1 b T2 Sappiamo che le chiavi in T1 sono tutte minori di quelle in T2. Se h1< h2: prendiamo il massimo in T1, c, e lo togliamo da T1. Sia T1 l albero ottenuto da T eliminando c. Creiamo un nodo radice con chiave c. Le due radici di T1 e T2 diventano i figli sinistro e destro, rispettivamente, della nuova radice. Infatti tutte le chiavi di T1 sono minori di c e per ipotesi tutte le chiavi di T2 sono maggiori di c. Tempo di esecuzione O(h1), per il minimo, più O(1) per le altre operazioni. a T1 c b T2

11 Capire un ABR - sol a b T1 T2 Se invece h2, l altezza di T2 è minore di h1, l altezza di T1, procediamo diversamente. Prendiamo il minimo in T2, c, e lo togliamo da T2. Sia T2 l albero ottenuto da T eliminando c. Creiamo un nodo radice con chiave c. Le due radici di T1 e T2 diventano i c figli sinistro e destro, a rispettivamente, della nuova radice. Infatti tutte le chiavi di T1 sono minori di c per ipotesi e tutte le chiavi di T2 sono maggiori di c. Tempo di esecuzione O(h2), per il minimo, più O(1) per le altre operazioni. T1 T2 b

12 Capire un ABR Se non si dispone del puntatore al padre, si può calcolare il nodo che ha la chiave successiva di una data, scendendo lungo puntatori padre-figlio partendo dalla radice? Naturalmente se il nodo ha il sotto albero destro, si continua a prendere il minimo nel sotto albero destro, che può essere calcolato scendendo di padre in figlio.

13 Successivo calcolato dalla radice Si parte dalla radice e si scende a destra se la chiave del nodo è più piccola di x se invece la chiave del nodo è maggiore di x, si scende a sinistra, salvando il riferimento al nodo, per rimpiazzarlo se si scende ancora a sinistra su un nodo di chiave più piccola e maggiore di x. L ultimo più grande di x sarà il successivo cercato w < x w z y < x T3 x z < x y > x T1 t t > x salvo y salvo t T2 Prof. E. Fachini - Intr. Alg. 13

14 Calcolo alternativo del successivo Successivo (T,x) input: T è il riferimento alla radice di un albero binario prec: T è un ABR, x un nodo di T output: il riferimento al nodo la cui chiave è il valore successivo a quella di x in T, se presente, NIL altrimenti if (x.right NULL) return Minimun(x.right) y = T succ = NIL while (x y) %y è un nodo del cammino da T a x e se succ NIL è il più vicino a y tale che succ.key > x.key if (x.key < y.key) succ = y y = y.left else %(x.key > y.key) y = y.right return succ Prof. E. Fachini - Intr. Alg. 14

15 Costruzione ABR bilanciato Dato un vettore ordinato A di interi si definisca un algoritmo che costruisce un ABR (BST) bilanciato nel numero dei nodi in O(n) passi. Un ABR è bilanciato nel numero dei nodi se i due sottoalberi di ogni nodo hanno un numero di elementi che differisce in valore assoluto al più di 1.

16 Costruzione ABR sol Si può pensare di prendere come radice l elemento intermedio A[m] con m = n/2 e allora se n = 2p, si inseriscono p-1 elementi sottoalbero sinistro e p nel sottoalbero destro, se invece n=2p+1 si inseriscono p elementi sia nel sottoalbero sinistro che nel destro. Quindi i due sottoalberi in ogni caso avranno un numero di elementi che differisce in valore assoluto al più di 1. Il sottalbero sinistro conterrà gli elementi da A[1] a A[m-1], che sono più piccoli di A[m] A[m] Il sottalbero destro conterrà gli elementi da A[m+1] a A[n] che sono più grandi di A[m]

17 ABRBil(A, i, j) Soluzione Input: un array di interi A e due interi i e j. precond: A è un vettore ordinato e 0 i j A.length output: un ABR bilanciato nel numero dei nodi costruito sugli elementi di A In ogni chiamata la porzione di array su cui si lavora è quella compresa tra A[i] e A[j-1]. if (i j-1) then m = (i+j)/2; T = new(a[m]) new crea un nuovo nodo puntato da T con chiave A[m] e puntatori ai figli e al padre nil T.left = ABRBil(A,i,m) if (T.left) then T.left.p = T T.right = ABRBil(A,m+1,j) T(n) = 2T(n/2)+Θ(1) if (T.right) then T.right.p = T return T else return NIL La chiamata iniziale è ABRBil(A, 0, n).

18 Capire un ABR Se si inserisce un elemento k in un ABR (BST) T e poi lo si cancella si ottiene lo stesso albero T. Si motivi la risposta. Sì perchè il nodo inserito è una foglia che viene eliminata senza altri cambiamenti sull albero.

19 Capire un ABR Se si cancella un elemento k da ABR (BST) T e poi lo si reinserisce si ottiene sempre lo stesso albero T? Si motivi la risposta.

20 Capire un ABR - sol NO, perchè se il nodo cancellato non è una foglia poi viene però reinserito come foglia. Esempio: 85 eliminazione di inserimento di

21 Capire un ABR Si utilizzi la funzione Successor per implementare una versione iterativa della visita inorder per un ABR. Si dimostri che la visita ha complessità O(n). Quest ultimo punto non è banale, si tratta di riflettere sul numero di attraversamenti di un arco padre-figlio necessari per completare la visita.

22 Visita Inorder ABR Un modo alternativo per eseguire una visita inorder di un albero binario di ricerca ( non di un albero qualunque!). VisitaItInorderABR(u): 1. determinare il minimo, x, di u, visitarlo e 2. calcolare il successivo di x, y, visitarlo e 3. ripetere il punto 2 dopo aver copiato y in x e fino a che il successivo è nullo. Il limite inferiore è Ω(n) perchè tutti i nodi sono visitati. Si tratta di dimostrare che VisitaItInorderABR ha complessità O(n). Prof. E. Fachini - Intr. Alg. 22

23 Il successivo Successor(T,x) input: T punta alla radice e x a un nodo di un ABR prec: T e x non sono nulli output: il puntatore al nodo di chiave successiva a quella di x in T 15 if x.right nil then return Minimum(x.right) 17 y = x.p while y nil and x == y.right do x = y y = x.p return y se x = se x = 30 Complessità O(h) 90 Prof. E. Fachini - Intr. Alg. 23

24 Visita Inorder ABR Inorder(T) input: T punta alla radice di un albero binario prec: T è ABR non nullo output:la sequenza delle chiavi di T in ordine crescente x = Minimum(T) %x è il puntatore al nodo di chiave minima in T repeat print x.key x = Successor(x) until x nil Prof. E. Fachini - Intr. Alg. 24

25 Visita Inorder ABR Dimostreremo che ogni arco (u,v), con v=u.left o v=u.right, viene attraversato al più due volte. Poichè gli archi sono n-1, si ottiene una complessità asintotica O(n). Prova induttiva dell affermazione: se un albero binario ha n nodi allora ha n-1 archi. Prof. E. Fachini - Intr. Alg. 25

26 Visita Inorder ABR VisitaItInorderABR u: 1. determinare il minimo, x, di u, visitarlo e 2. calcolare il successivo di x, y, visitarlo e 3. copiare y in x e ripetere il punto 2 fino a che il successivo è nullo. u min(r) max(r) Partendo dalla radice si attraverseranno gli archi del cammino più a sinistra nella chiamata di MINIMUM, questi archi potranno essere riattraversati quando si cercherà il successivo di un nodo che non ha figlio destro Prof. E. Fachini - Intr. Alg. 26

27 Attraversamenti arco (u,v), v figlio sinistro v L u max(l) SUCCESSOR(max(L)) = u Caso 1. v è figlio sinistro di u. Poiché le chiavi dei nodi nel sotto albero sinistro di u sono minori di u tutto il sotto albero sinistro di u è visitato prima di u e questo comporta che l arco (u,v) è attraversato una volta da padre a figlio. Quando si cerca il successivo del massimo si deve tornare a u, quindi si riattraversa l arco (u,v) da figlio a padre. Il successivo di u si trova o nel suo sottoalbero destro o tra i suoi antenati, quindi l arco (u,v) non verrà più attraversato. Prof. E. Fachini - Intr. Alg. 27

28 Attraversamenti arco (u,v), v figlio destro u v Caso 2. v è figlio destro di u. Quando si cerca il successivo di u, si deve prendere il minimo nel sottoalbero radicato in v, R, quindi bisogna scendere lungo l arco (u,v), da padre a figlio. min(r) R max(r) Il successivo del massimo di R si trova tra gli antenati di u, quindi l arco (u,v) verrà attraversato da figlio a padre. Infine il successivo del successivo di max(r) è nel sottoalbero destro di quel nodo o fra i suoi antenati, quindi non si attraverserà di nuovo l arco (u,v) Prof. E. Fachini - Intr. Alg. 28

29 Rango di un nodo in un ABR Dato un ABR T non nullo e un puntatore a un suo nodo x si scriva un algoritmo che fornisce in output il rango della chiave di x in T, cioè il numero degli elementi di chiave minore a quella di x in T. Si supponga che T sia rappresentato in memoria con anche il puntatore al padre. Poiché abbiamo l ipotesi che le chiavi sono tutti diverse, ci limitiamo a calcolare il numero dei nodi con chiave minore. Prof. E. Fachini - Intr. Alg. 29

30 Rango sol ricorsiva a T1 Se T ha un solo nodo e x=t allora la risposta è 0 c b T2 Se T ha due sotto alberi e la chiave di x è uguale a quella della radice, allora il rango è il numero dei nodi nel sotto albero sinistro. Se la chiave di x è minore di quella della radice, allora x è nel sotto albero sinistro e posso chiamare la funzione su quel sotto albero e il risultato vale per T. Se invece la chiave di x è maggiore di quella della radice bisogna sommare al numero di nodi minori di x nel sotto albero destro, ottenuto con una chiamata della funzione su quel sotto albero, il numero dei nodi nel sotto albero sinistro più la radice. Prof. E. Fachini - Intr. Alg. 30

31 Rango sol ricorsiva, psudocodice Rango(T,x) input: il puntatore alla radice T di un albero binario e a un suo nodo x output: il numero dei nodi in T di chiave minore di quella di x if T == NIL then return 0 if T.key == x.key then return nnodi(t.left) if x.key < T.key then return Rango(T.left,x) else return nnodi(t.left) Rango(T.right,x) %x.key > T.key nnodi(t) input: un albero binario T output: il numero dei nodi di T if T==NIL then return 0 return nnodi(t.left) + nnodi(t.right) +1 Tempo di esecuzione in θ(n), se n è il numero dei nodi di T Prof. E. Fachini - Intr. Alg. 31

32 Rango sol ricorsiva, analisi Rango(T,x) if T == NIL then return 0 if T.key == x.key then return nnodi(t.left) if x.key < T.key then return Rango(T.left,x) else return nnodi(t.left) Rango(T.right,x) %x.key > T.key Tempo di esecuzione nel caso peggiore O(n). Precisando meglio se x ha rango k possiamo dire che il tempo di esecuzione è in O(h + k). Infatti fin tanto che x.key è minore di T.key scendiamo di padre in figlio, e da quando la chiave di x è maggiore o uguale a quella di T in poi si calcola il numero dei nodi di chiave minore o uguale a x. Prof. E. Fachini - Intr. Alg. 32

33 Rango sol 2 Dato un ABR T non nullo e un puntatore a un suo nodo x si può calcolare il numero dei precedenti di x, applicando la funzione predecessore al nodo x e incrementando una variabile ogni volta che il nodo ottenuto non è nullo. Prof. E. Fachini - Intr. Alg. 33

34 Rango1(T,x) Soluzione 2 rango Input: un albero binario T e un suo nodo prec:t è un ABR non vuoto e x NIL postc: restituisce il rango di z = PREDECESSOR(x) k = 0 while z NIL do z è il precedente di y e k contiene il numero dei nodi di T con chiave a tale che a x.key, tra y e x. y = z k = k+1 z = PREDECESSOR(y) return k Tempo di esecuzione in O(k + h), dove k è il rango del nodo x e h è l altezza dell albero. Se x è il minimo si ha O(h). Il risultato si ottiene con un analisi analoga a quella della visita inorder in cui si usa la funzione successor. All uscita dal ciclo z è NIL perchè si è calcolato il precedente del minimo y, e k contiene il numero dei nodi di T con chiave a tale che a x.key Prof. E. Fachini - Intr. Alg. 34

35 Rango sol 3 Dato un ABR T non nullo e un puntatore a un suo nodo x si può calcolare il numero dei successivi del minimo minori di x, applicando la funzione che individua il successivo a partire dal minimo, incrementando una variabile inizializzata a 0 fino a che non si arriva al nodo x. Prof. E. Fachini - Intr. Alg. 35

36 Rango 3 ABR Rango3(T,x) Input: un albero binario T e un suo nodo prec: x NIL postc: restituisce il rango di della chiave di x k = 0 if T == NIL return 0 z = MINIMUM(T) while x.key > z.key do z è l elemento di rango k in T z = SUCCESSOR(z) k = k+1 Complessità O(k + h), dove k è il rango del nodo x e h è l altezza dell albero. All uscita dal ciclo vale y.key = x.key perchè x è un nodo dell albero e quindi k è il rango di x. return k Prof. E. Fachini - Intr. Alg. 36

37 Ricerca di un nodo di rango r Dato un ABR T non nullo e un valore r si scriva un algoritmo che fornisce in output il riferimento (puntatore) al nodo di rango r in T, se presente, NIL altrimenti. Il rango qui è il numero degli elementi minori, quindi se per esempio il numero dato in input è il numero dei nodi dell albero meno 1 si dovrà dare in output il nodo di chiave massima. Prof. E. Fachini - Intr. Alg. 37

38 Ricerca di un nodo di rango r Se T ha un solo nodo e r=0 allora la risposta è T a c b Se T ha due sotto alberi e il numero dei nodi nel sotto albero sinistro è uguale al rango r dato in input allora il nodo è T. x x Se il numero dei nodi nel sotto albero sinistro è maggiore del rango r dato in input, il nodo x deve trovarsi nel sotto albero sinistro e il suo rango nel sotto albero coincide con il rango in T. Altrimenti, il nodo x deve trovarsi a destra, se c è, ma per trovarlo si deve cercare nel sotto albero destro un nodo il cui rango è r meno il numero numero dei nodi nel sotto albero sinistro più 1 per la radice. Prof. E. Fachini - Intr. Alg. 38

39 Select1(T,r) Select Input: un albero binario T e valore r prec: 0 r<nnodi(t) output: il riferimento al nodo di rango r if T == NIL then return NIL n = nnodi(t.left) if n == r then return T if n > r then return Select1(T.left,r) else return Select1(T.right,r-n-1) Complessità O(n 2 ), nel caso peggiore, perché se l albero è degenere a sinistra si calcola n-1 volte il numero dei nodi del sottoalbero sinistro. Ma il numero dei nodi può essere calcolato risalendo nell albero e confrontando di volta in volta il numero ottenuto con il rango per individuare il nodo cercato, come nella Select2 della pagina successiva. Prof. E. Fachini - Intr. Alg. 39

40 Pseudocodice Select2 Select2(T,r) if r < 0 return NIL if T = NIL or (T è una foglia and r==0) then return T if (D,n) = SelectAus(T, r) and D nil then return D SelectAus(T,r) Input: un albero binario T e un intero r prec: T è un ABR e r 0 output: dà (T,n) dove se T nil allora è il nodo la cui chiave ha rango r in T e n è il numero di nodi attraversati per trovare T, se un nodo di rango r non c è, perché r nnodi(t), allora T=nil if T = NIL then return (T,0) (D,n) = SelectAus(T.left, r) if r == n then return (T,n+1) l incremento per evitare di restituire il nodo nel quale si rientra if r > n then (D,m) = SelectAus(T.right, r - n -1) else m=0 il controllo evita chiamate a destra inutili, perché il nodo è stato trovato, ma m va valorizzato return (D,n+m+1) Tempo di esecuzione O(r + h). Prof. E. Fachini - Intr. Alg. 40

41 Verso Select3 Si potrebbe pensare di diminuire di 1 il parametro r del rango ad ogni chiamata e restituire il nodo che si raggiunge con r=0. Ma questa soluzione non è così semplice come potrebbe sembrare perché al rientro da una chiamata il parametro riprende il suo valore e quindi i decrementi vanno perduti. Per salvarne il valore risalendo occorre fornirlo come risultato della chiamata, insieme al puntatore. al rientro dalla chiamata su y, r =r-nnodi(l) se r =0 risposta x, se r =1 la risposta è z T = y L x z R la chiamata su z, cerca un nodo il cui rango sia diminuito del numero di nodi nel sotto albero sinistro + radice T A B 60 C Select su A, con r =2 select su B con r=2 rientro su A r=1, chiamata a su C con r=0, quindi risposta (C,0)

42 Pseudocodice Select3 Select3(T,r) if r < 0 return NIL if T = NIL or (T è una foglia and r==0) then return T if (D,r) = SelectAus(T, r) and r == 0 then return D else return NIL SelectAus(T,r) Input: un albero binario T e un intero r prec: T è un ABR e r 0 output: dà (T,n) dove T è il nodo la cui chiave ha rango r in T se n = 0, altrimenti il puntatore alla radice con r if T NIL then if T è una foglia then return (T,r) if (T.left NIL) then (D, r) = SelectAus(T.left, r) if r == 0 then return (D,r) if r > 0 then r = r-1 r viene decremento a ogni rientro da sinistra, quindi alla radice contiene r diminuito del numero di nodi nel sottoalbero sinistro if r == 0 then return (T,0) if (T.right NIL) then return (T,r) if r == 1 then return (T.right,0) (D,r) = SelectAus(T.right, r-1) if r == 0 then return (D,r) Tempo di esecuzione O(r + h). Prof. E. Fachini - Intr. Alg. 42

43 Ricerca di un nodo di rango r, versione iterativa Dato un ABR T non nullo e un valore r si scriva un algoritmo che fornisce in output il riferimento (puntatore) al nodo di rango r in T, se presente, NIL altrimenti. SelectIt(T,r) Input: un albero binario T e un intero r prec: T è un ABR e r 0 postc: restituisce il nodo la cui chiave ha rango r in T Tempo di esecuzione O(r + h). if T == NIL return T k = 0 z = MINIMUM(T) while k < r and z nil do z è il nodo di rango k in T z = SUCCESSOR(z) k = k+1 All uscita dal ciclo se vale k = r e z nil allora z ha rango r. Se z = nil allora r è maggiore o uguale al numero dei nodi di T e la risposta è nil return z Prof. E. Fachini - Intr. Alg. 43

44 A è un ABR? Si scriva un algoritmo che preso in input un albero binario T dà in output vero se st è un ABR falso altrimenti. Prof. E. Fachini - Intr. Alg. 44

45 Verificare che un albero binario è un ABR ABR1(T) input: un albero binario T, con chiavi distinte output: vero se T è ABR, falso altrimenti if (T == NIL) return 1 if (T.left!= NIL and T.left.key > T.key) return 0 if (T.right!= NIL and T.right.key < T.key) return 0 return (ABR1(T.left) and ABR1(T.right)) /* vero se, ricorsivamente, il sottoalbero sinistro e il destro sono ABR */ Sbagliato!! Perchè?

46 Definizione ricorsiva di ABR T = x L R T è un ABR se L e R sono ABR e max(l) < x < min(r)

47 Algoritmo di Verifica basato sulla definizione ABR2(T) input: un albero binario T postc: restituisce vero se T è ABR, con chiavi distinte if (T == NIL) return 1 if (T.left!= NIL and MaximumRic(T.left) > T.key) return 0 if (T.right!= NIL and MinimumRic(T.rigth) < T.key) return 0 return (ABR2(T.left) and ABR2(T.right)) /*vero se, recursivamente, il sottoalbero sinistro e il destro sono ABR */ Qui MaximumRic(T) e MinimumRic(T) danno in output il valore della chiave massima rispettivamente minima in T Tempo di esecuzione? O(nh), se h è l altezza e n il numero dei nodi dell albero binario T. Troppo.

48 Verificare che un albero binario è un ABR - 2 Sappiamo che una visita inorder su un ABR visita le chiavi in ordine crescente. Si potrebbe pensare di portarsi dietro il precedente e controllare di volta in volta che sia minore del nodo correntemente visitato: ABR2(T) Input: un puntatore alla radice di un albero binario output: vero se T è un ABR, falso altrimenti prec = nil ABRaus(T,prec) ABRaus(T,prec) if T= nil return true if ABRaus(T.left,T) if T.key > prec.key return ABRaus(T.right,T) else return false Sbagliato!! Perchè? Prof. E. Fachini - Intr. Alg. 48

49 Verificare che un albero binario è un ABR - 2 ABRaus(T,prec) if T= nil return true if ABRaus(T.left,T) if T.key > prec.key return ABRaus(T.right,T) else return false ABRaus(T, nil) ABRaus(A, T) ABRaus(B, A) se B.key < A.key ABRaus(C, A) se C.key < A.key così si esaurisce la chiamata su A e si rientra nella chiamata su T e si controlla se A.key T.key! Risposta sì, ma invece T non è un ABR! Dovremmo portarci dietro 60, che è il valore del nodo ultimo visitato, ma non possiamo in questo modo. Ma questa soluzione non fa i conti con il fatto che quando si rientra in una chiamata i parametri riprendono i loro valori e quindi prec è sempre il valore del figlio da cui si risale! A B C T Prof. E. Fachini - Intr. Alg. 49

50 Proprietà dell ABR 50 < >50 >30 e < 50 <20 < >20 e < >30 e < > 85 <85 e > <100 e > 85 >15 e < >30 e < 35 Ogni volta che scendiamo di padre in figlio: se il figlio è un figlio destro posso aggiornare il limite inferiore ai valori che possono trovarsi nel sotto albero destro, usando la chiave del padre se il figlio è un figlio sinistro posso aggiornare il limite superiore ai valori che possono trovarsi nel sotto albero sinistro, usando la chiave del padre. Scendendo di padre in figlio controllo per ogni nodo che si trovi nell intervallo di valori determinati dal limite inferiore corrente e il limite superiore corrente, in questo modo verifico se si tratta di un ABR. Se questi vincoli sono rispettati per tutti i nodi, l albero è un albero binario di ricerca

51 Verso un algoritmo di verifica efficiente T = x - < x < y z < x e x > - > x e < L R T = x - < x < < y e x > - < x e x > - y z > x e < <x e >y >x e <z > z e < L1 R1 L2 R2

52 Algoritmo di verifica efficiente T = x max = + min = - max = y min = - max = x min = - L1 y min = y max = x R1 L2 z min = x max = z min = x max = + R2 min = z max = + Si modifica la visita inorder passando in due parametri i valori min e max da considerare: se si scende al figlio sinistro, la chiave del padre è il nuovo valore di max, se si scende a destra la chiave del padre è il nuovo valore di min.

53 ABR3(T) input: T è un albero binario postc:restituisce vero se T è ABR, con chiavi distinte min = - ; max = return(abr_aus(t, min,max)) ABR_Aus(T,min,max) input: T è un albero binario, min e max due interi output: vero se T è un ABR if (T == NIL) return 1 if (T.key min T.key max ) return 0 return (ABR_Aus(T.left, min,t.key) and ABR_Aus(T.right,T.key,max)) /*vero se, ricorsivamente, i nodi nel sottoalbero sinistro sono tra min e T.key e quelli del destro sono tra T.key e max */

54 Verificare che un albero binario è un ABR ABR_Aus(T,min,max) input: T è un albero binario, min e max due interi output: restituisce vero se T è un ABR if (T == NIL) return 1 if (T.key min T.key max ) return 0 return (ABR_Aus(T.left, min,t.key) and ABR_Aus(T.right,T.key,max)) /*vero se, ricorsivamente, i nodi nel sottoalbero sinistro sono tra min e T.key e quelli del destro sono tra T.key e max */ ABR_Aus(T, -, ) 100 Tempo di esecuzione? ABR_Aus(T.left, -, 100) min=- <50< max= O(n), se n il numero dei nodi dell albero binario T. ABR_Aus(T.left, -, 50) min=- <10< max= ABR_Aus(T.right, 50, 100) min=50<80< max= ABR_Aus(T.left, 50, 80) 90 ABR_Aus(T.right, 80, 100)

55 Intervallo chiavi 1. Dato un ABR T e due chiavi a e b (non necessariamente presenti nell albero) si scriva un algoritmo che fornisce in output, ordinate, le chiavi x dell albero tali che a x b. Soluzione semplice, ma inefficiente, infatti visita sempre tutti i nodi con una visita inorder, con un tempo di esecuzione O(n), se n è il numero dei nodi. StampaTra(T,a,b) Input: un puntatore T e due chiavi prec:t è un ABR e a b, min(t) a b max(t) output: stampa le chiavi di T comprese tra a e b if T nil then StampaTra(x.left,a,b) if T.key a and T.key b then print x.key StampaTra(x.right,a,b) Prof. E. Fachini - Intr. Alg. 55

56 Intervallo chiavi sol Soluzione alternativa, che fa riferimento alla visita inorder alternativa che abbiamo visto. L idea è cercare a in T, facendo in modo di ottenere il puntatore al nodo di chiave a o al padre della foglia in cui a sarebbe inserita nell albero; quindi si stampano tutte le chiavi dei nodi successivi, di chiave minore o uguale a b. StampaTraEff(T,a,b) Input: un puntatore T e due chiavi prec:t è un ABR e a b, min(t) a b max(t) output: stampa le chiavi di T comprese tra a e b if T nil then y = Tree-Search-Mod(T,a) y è un nodo di chiave a o il padre della foglia in cui si sarebbe inserita a while y nil and y.key b do if y.key a then print(y.key) y = SUCCESSOR(y) return Complessità O(m + h), se m è il numero dei nodi con chiavi comprese tra a e b e h è l altezza dell albero. Prof. E. Fachini - Intr. Alg. 56