Lezione 15. Algoritmi su gli alberi binari: visite

Transcript

1 Lezione 15 Alberi binari di ricerca Algoritmi su gli alberi binari: visite Dato un puntatore alla radice di un albero vogliamo scandire in modo sistematico tutti i nodi di tale albero In una lista abbiamo una unica possibilità: quella di seguire il link al nodo successivo Con un albero binario sono possibili 3 strategie: preordine o ordine anticipato: si visita prima il nodo e poi i sottoalberi sinistro e destro inordine o ordine simmetrico: si visita prima il sottoalbero sinistro e poi il nodo e poi il sottoalbero destro postordine o ordine posticipato: si visita prima il sottoalbero sinistro, poi quello destro e poi il nodo 1

2 Visita in ordine simmetrico Inorder-Tree-Walk(x) 1 if x NIL 2 then Inorder-Tree-Walk(left[x]) 3 stampa(key[x]) 4 Inorder-Tree-Walk(right[x]) Visualizzazione si parte in 2 viene chiamata la funzione sul figlio sinistro siamo in 1 viene chiamata la funzione sul figlio sinistro non esiste figlio sinistro e la ricorsione termina torniamo in 1 stampiamo 1 viene chiamata la funzione sul figlio destro non esiste figlio destro e la ricorsione termina torniamo in 1 la funzione termina torniamo in 2 stampiamo 2. 2

3 Visualizzazione viene chiamata la funzione sul figlio destro siamo in 8 viene chiamata la funzione sul figlio sinistro siamo in 4 viene chiamata la funzione sul figlio sinistro non esiste figlio sinistro e la ricorsione termina torniamo in 4 stampiamo 4 viene chiamata la funzione sul figlio destro non esiste figlio destro e la ricorsione termina la funzione termina torniamo in 8 stampiamo 8 viene chiamata la funzione sul figlio destro siamo in 9 Visualizzazione viene chiamata la funzione sul figlio sinistro non esiste figlio sinistro e la ricorsione termina torniamo in 9 stampiamo 9 viene chiamata la funzione sul figlio destro non esiste figlio destro e la ricorsione termina torniamo in 9 la funzione termina torniamo in 8 la funzione termina torniamo in 2 la funzione termina 3

4 Visita in ordine anticipato Inorder-Tree-Walk(x) 1 if x NIL 2 then stampa(key[x]) 3 Inorder-Tree-Walk(left[x]) 4 Inorder-Tree-Walk(right[x]) Visualizzazione si parte in 2 stampiamo 2 viene chiamata la funzione sul figlio sinistro siamo in 1 stampiamo 1 viene chiamata la funzione sul figlio sinistro non esiste figlio sinistro e la ricorsione termina torniamo in 1 viene chiamata la funzione sul figlio destro non esiste figlio destro e la ricorsione termina torniamo in 1 la funzione termina torniamo in 2 4

5 Visualizzazione viene chiamata la funzione sul figlio destro siamo in 8 stampiamo 8 viene chiamata la funzione sul figlio sinistro siamo in 4 stampiamo 4 viene chiamata la funzione sul figlio sinistro non esiste figlio sinistro e la ricorsione termina torniamo in 4 viene chiamata la funzione sul figlio destro non esiste figlio destro e la ricorsione termina la funzione termina torniamo in 8 viene chiamata la funzione sul figlio destro siamo in 9 Visualizzazione viene chiamata la funzione sul figlio sinistro non esiste figlio sinistro e la ricorsione termina torniamo in 9 viene chiamata la funzione sul figlio destro non esiste figlio destro e la ricorsione termina torniamo in 9 la funzione termina torniamo in 8 la funzione termina torniamo in 2 la funzione termina 5

6 Visita in ordine posticipato Inorder-Tree-Walk(x) 1 if x NIL 2 then Inorder-Tree-Walk(left[x]) 3 Inorder-Tree-Walk(right[x]) 4 stampa(key[x]) Algoritmi ricorsivi su alberi binari Capita di dover determinare dei parametri strutturali di un albero avendo in ingresso solo il link alla radice Si può sfruttare la struttura ricorsiva degli alberi ed realizzare versioni ricorsive delle funzioni di interesse Consideriamo una funzione per determinare il numero di nodi ed una per determinare l altezza dell albero 6

7 Funzioni ricorsive int count(link h) { if (h == NULL) return 0; return count(h->l) + count(h->r) + 1; } int height(link h) { int u, v; if (h == NULL) return -1; u = height(h->l); v = height(h->r); if (u > v) return u+1; else return v+1; } Ricerca Molte applicazioni richiedono un insieme dinamico che fornisca solo operazioni di: inserimento cancellazione ricerca massimo/minimo predecessore/successore (il più piccolo/grande elemento maggiore/minore di un elemento dato) 7

8 Alberi Binari di ricerca Gli alberi binari di ricerca sono strutture dati dinamiche che forniscono le operazioni richieste (insert, delete, search, maximum, predecessor, etc) in tempo limitato asintoticamente dall altezza dell albero, cioè per le varie operazioni si ha T(n)=O(h) Alberi Binari di Ricerca Un albero binario di ricerca è un albero binario in cui le chiavi soddisfano la: proprietà dell albero binario di ricerca sia x un nodo key di left[x] key di x key di right[x] key di x

9 Ordinamento delle chiavi In un albero binario di ricerca l operazione di ordinamento viene eseguita semplicemente attraversando i nodi dell albero in modo ricorsivo la visita deve essere una visita in ordine simmetrico Visualizzazione Root[t] Sequenza stampata:

10 La ricerca L idea è di confrontare la chiave di un nodo x con la chiave cercata nel caso che non coincidano si cerca solo nel sottoalbero in cui potrà trovarsi è possibile sapere quale sia il sottoalbero perché tutti i nodi del sottoalbero destro contengono chiavi maggiori della chiave di x (e nel sottoalbero sinistro chiavi minori) PseudoCodice per la Ricerca (versione ricorsiva) Tree-Search(x,k) 1 if x = NIL o k=key[x] 2 then return x 3 if k < key[x] 4 then return Tree-Search(left[x],key) 5 else return Tree-Search(right[x],key) 10

11 Tempo di calcolo La procedura discende a partire dalla radice l albero e restituisce un puntatore al nodo la cui chiave coincide con la chiave cercata nel caso in cui essa non esista la procedura discende comunque fino ad una foglia e restituisce un puntatore nullo Il tempo impiegato è proporzionale alla lunghezza del cammino percorso, ovvero limitato dalla altezza dell albero pertanto T(n)=O(h) per albero binario completo T(n)=O(lg n) per albero degenere (lista) T(n)=O(n) Nota E possibile scrivere qualsiasi procedura ricorsiva in forma non ricorsiva (e viceversa) La forma ricorsiva è spesso più elegante e compatta ma non la più efficiente Di seguito si da una procedura non ricorsiva per la ricerca in un albero binario 11

12 PseudoCodice per la Ricerca (versione iterativa) Iterative-Tree-Search(x,k) 1 while x NIL e k key[x] 2 do if k < key[x] 4 then x left[x] 5 else x right[x] 6 return x Determinazione della chiave massima e minima La chiave massima in un albero binario dovrà trovarsi nel sottoalbero destro della radice e nel sottoalbero destro del figlio destro della radice e così via Analogamente per la chiave minima che dovrà essere nel sottoalbero sinistro Pertanto per determinare l elemento massimo è sufficiente discendere tutti i nodi da figlio destro in figlio destro fino ad arrivare alla foglia (e analogamente con i figli sinistri per il minimo) 12

13 Massimo Massimo=20 9 Minimo Minimo=

14 Minimo e massimo Tree-Minimum(x) 1 while left[x] NIL 2 do x left[x] 3 return x Tree-Maximum(x) 1 while right[x] NIL 2 do x right[x] 3 return x Successore e predecessore Dato un nodo nell albero di ricerca talvolta si richiede di determinare il suo successore (o predecessore) secondo l ordinamento fornito dalle chiavi. Se tutte le chiavi sono distinte, il successore di un nodo x è il nodo con la più piccola chiave maggiore della chiave di x Con gli alberi binari di ricerca è possibile determinare il successore (predecessore) di un nodo senza dover confrontare le chiavi 14

15 Successore: idea intuitiva Si considerano due casi: il nodo x ha un figlio destro il nodo x non ha un figlio destro Nel primo caso: si considera il sottoalbero destro che contiene sicuramente nodi con chiavi maggiori della chiave di x in questo sottoalbero il nodo con la chiave più piccola è la foglia alla estrema sinistra, cioè il nodo restituito dalla procedura Tree-Minimum Successore di nodo con figlio dx: visualizzazione 6 15 Successore di sottoalbero destro minimo 15

16 Successore di nodo senza figlio dx: idea intuitiva Nel caso in cui x non ha un figlio destro allora il predecessore deve essere un antenato p di x dal punto di vista di p, x deve essere un discendente appartenente ad un sottoalbero sinistro infatti le chiavi nel sottoalbero sx hanno chiave minore antenati ha x in sottoalbero dx? SI ha x in sottoalbero sx? NO Successore di x = 4? Successore di nodo senza figlio dx: idea intuitiva perché la chiave di p sia la più piccola possibile allora p deve essere l antenato più prossimo altrimenti se consideriamo un antenato lontano è vero che ha chiave maggiore, ma.. esisterà un antenato meno lontano e più piccolo! Antenati che hanno x in sottoalbero sx Successore di x = 4 16

17 Idea intuitiva Per determinare questo nodo antenato è sufficiente risalire gli antenati di x fino a quando non si trova un nodo antenato che è un figlio sinistro di un nodo y. Il nodo y è il nodo cercato, il predecessore Si mantengono pertanto i puntatori a due generici antenati x e y e si risale fino a quando x=left[y] Visualizzazione Successore di

18 PseudoCodice Successore Tree-Successore(x) 1 if right[x] NIL 2 then return Tree-Minimum(right[x]) 3 y p[x] 4 while y NIL e x = right[y] 5 do x y 6 y p[x] 7 return y Predecessore La procedura per la determinazione del predecessore è simmetrica a quella vista per il successore il predecessore si troverà nel sottoalbero sinistro (se questo esiste), e sarà l elemento massimo di questo sottoalbero se non esiste sottoalbero sinistro il predecessore sarà l antenato più prossimo che ha un figlio destro che è antenato del nodo in questione 18

19 PseudoCodice Predecessore Tree-Predecessore(x) 1 if left[x] NIL 2 then return Tree-Maximum(left[x]) 3 y p[x] 4 while y NIL e x = left[y] 5 do x y 6 y p[x] 7 return y Inserzione Per inserire un nuovo valore k in un albero binario di ricerca, si prepara un nodo z tale che: possieda come chiave key[z]=k e non abbia collegamenti left[z]=right[z]=p[k]=nil si cerca la posizione in cui inserirlo si modificano i campi di z per allacciarlo all albero binario di ricerca 19

20 Inserzione Per trovare la posizione giusta ci si muove a partire dalla radice spostandosi sul sottoalbero destro o sinistro come in una ricerca si prosegue però fino ad arrivare ad un punto in cui fallirebbe la ricerca a questo punto si inserisce il nuovo nodo Visualizzazione: inserzione di key

21 Pseudocodice Inserzione Tree-Insert(T,z) 1 y NIL 2 x root[t] 3 while x NIL 4 do y x 5 if key[z]<key[x] 6 then x left[x] 7 else x right[x] 8 p[z] y 9 if y=nil 10 then root[t] z 11 else if key[z] < key[y] 12 then left[y] z 13 else right[y] z ricerca della posizione Pseudocodice Inserzione Tree-Insert(T,z) 1 y NIL 2 x root[t] 3 while x NIL 4 do y x 5 if key[z]<key[x] 6 then x left[x] 7 else x right[x] 8 p[z] y 9 if y=nil 10 then root[t] z 11 else if key[z] < key[y] 12 then left[y] z 13 else right[y] z Inserzione del nodo z caso: inserzione primo elemento caso: inserzione elemento generico a dx o sx del nodo trovato 21

22 Cancellazione La procedura di cancellazione è più laboriosa in quanto si deve tenere conto di tre casi possibili dato un nodo z i casi sono: z non ha figli z ha un unico figlio z ha due figli Caso 1: Nel caso in cui z non abbia figli si elimina direttamente il nodo z

23 Caso 2: Nel caso in cui z abbia un unico figlio si rimuove z e si collega il figlio al posto di z il secondo caso è identico al caso di eliminazione di un nodo da una lista concatenata Caso 3: Nel caso in cui z abbia 2 figli si determina il successore x di z si copia il contenuto di x al posto di quello di z infine si elimina il vecchio nodo x (caso 1 o 2) Nota: il successore di x non può avere 2 figli perché non può avere un figlio sx (altrimenti sarebbe questo il successore)

24 PseudoCodice Cancellazione Tree-Delete(T,z) 1 if left[z]=nil o right[z]=nil 2 then y z 3 else y Tree-Successor(z) 4 if left[y] NIL 5 then x left[y] 6 else x right[y] 7 if x NIL 8 then p[x] p[y] 9 if p[y] = NIL 10 then root[t] x 11 else if y=left[p[y]] 12 then left[p[y]] x 13 else right[p[y]] x 14 if y z 15 then key[z] key[y] 17 return y Determinazione del nodo da cancellare caso 1 o 2 PseudoCodice Cancellazione Tree-Delete(T,z) 1 if left[z]=nil o right[z]=nil 2 then y z 3 else y Tree-Successor(z) 4 if left[y] NIL 5 then x left[y] 6 else x right[y] 7 if x NIL 8 then p[x] p[y] 9 if p[y] = NIL 10 then root[t] x 11 else if y=left[p[y]] 12 then left[p[y]] x 13 else right[p[y]] x 14 if y z 15 then key[z] key[y] 17 return y Determinazione del nodo da cancellare caso 3 24

25 PseudoCodice Cancellazione Tree-Delete(T,z) 1 if left[z]=nil o right[z]=nil 2 then y z 3 else y Tree-Successor(z) 4 if left[y] NIL 5 then x left[y] 6 else x right[y] 7 if x NIL 8 then p[x] p[y] 9 if p[y] = NIL 10 then root[t] x 11 else if y=left[p[y]] 12 then left[p[y]] x 13 else right[p[y]] x 14 if y z 15 then key[z] key[y] 17 return y in x si memorizza l unico figlio del nodo da rimuovere (può essere NIL) PseudoCodice Cancellazione Tree-Delete(T,z) 1 if left[z]=nil o right[z]=nil 2 then y z 3 else y Tree-Successor(z) 4 if left[y] NIL 5 then x left[y] 6 else x right[y] 7 if x NIL 8 then p[x] p[y] 9 if p[y] = NIL 10 then root[t] x 11 else if y=left[p[y]] 12 then left[p[y]] x 13 else right[p[y]] x 14 if y z 15 then key[z] key[y] 17 return y Se x esiste si attacca all albero 25

26 PseudoCodice Cancellazione Tree-Delete(T,z) 1 if left[z]=nil o right[z]=nil 2 then y z 3 else y Tree-Successor(z) 4 if left[y] NIL 5 then x left[y] 6 else x right[y] 7 if x NIL 8 then p[x] p[y] 9 if p[y] = NIL 10 then root[t] x 11 else if y=left[p[y]] 12 then left[p[y]] x 13 else right[p[y]] x 14 if y z 15 then key[z] key[y] 17 return y Se il nodo eliminato era la radice allora la nuova radice è x PseudoCodice Cancellazione Tree-Delete(T,z) 1 if left[z]=nil o right[z]=nil 2 then y z 3 else y Tree-Successor(z) 4 if left[y] NIL 5 then x left[y] 6 else x right[y] 7 if x NIL 8 then p[x] p[y] 9 if p[y] = NIL 10 then root[t] x 11 else if y=left[p[y]] 12 then left[p[y]] x 13 else right[p[y]] x 14 if y z 15 then key[z] key[y] 17 return y Se il nodo eliminato era un figlio sx allora si aggiorna il puntatore sx altrimenti dx 26

27 PseudoCodice Cancellazione Tree-Delete(T,z) 1 if left[z]=nil o right[z]=nil 2 then y z 3 else y Tree-Successor(z) 4 if left[y] NIL 5 then x left[y] 6 else x right[y] 7 if x NIL 8 then p[x] p[y] 9 if p[y] = NIL 10 then root[t] x 11 else if y=left[p[y]] 12 then left[p[y]] x 13 else right[p[y]] x 14 if y z 15 then key[z] key[y] 17 return y Se il nodo eliminato ha richiesto la determinazione del successore allora copia la chiave del successore PseudoCodice Cancellazione Tree-Delete(T,z) 1 if left[z]=nil o right[z]=nil 2 then y z 3 else y Tree-Successor(z) 4 if left[y] NIL 5 then x left[y] 6 else x right[y] 7 if x NIL 8 then p[x] p[y] 9 if p[y] = NIL 10 then root[t] x 11 else if y=left[p[y]] 12 then left[p[y]] x 13 else right[p[y]] x 14 if y z 15 then key[z] key[y] 17 return y Restituisci il nodo eliminato per una eventuale deallocazione 27

28 Esercizio Implementare un albero binario di ricerca: Classe Nodo Classe Albero Ricerca Massimo/Minimo Inserzione Stampa #include<iostream> #include<cassert> using namespace std; Implementazione C++ template<class T, class LessClass > class TreeClass{ private: struct Node{Node *left, *right, * parent; T key;}; Node *root; public: TreeClass():root(0){} void insert(t); void print(){p_print(root); cout<<endl;} bool search(t user_key){return p_search(root, user_key);} T minimum(); T maximum(); private: void p_print(node *); bool p_search(node * x, T user_key); }; 28

29 Implementazione C++ template<class T, class LessClass > void TreeClass<T, LessClass>::p_print(Node *x){ if(x!=0){ p_print(x->left); cout<<x->key<<" "; p_print(x->right); } } template<class T, class LessClass > bool TreeClass<T, LessClass>::p_search(Node * x, T usr_key){ LessClass less; if(x==0) return false; if(!less(x->key,usr_key) &&!less(usr_key,x->key)) return true; //ugualianza if(less(usr_key,x->key)) p_search(x->left, usr_key); else p_search(x->right, usr_key); } template<class T, class LessClass > void TreeClass<T,LessClass>::insert(T usr_key){ LessClass less; //inizializzazione del nodo da aggingere Node * z=new Node; assert(z); z->key=usr_key; z->left=0; z->right=0; z->parent=0; //ricerca della giusta posizione di inserzione Node * y=0; Node * x=root; while(x!= 0){ y=x; if(less(z->key, x->key)) x=x->left; else x=x->right; } //settaggio dei puntatori z->parent=y; if(y==0) root=z; else if(less(z->key, y->key)) y->left=z; else y->right=z; } 29

30 Implementazione C++ template<class T, class LessClass > T TreeClass<T, LessClass>::minimum(){ assert(root); Node * x=root; while(x->left!=0) x=x->left; return x->key; } template<class T, class LessClass > T TreeClass<T, LessClass>::maximum(){ assert(root); Node * x=root; while(x->right!=0) x=x->right; return x->key; } Implementazione C++ template<class T> struct LessClass{ bool operator()(const T & a, const T & b)const{return a<b;} }; int main(){ //integer example int v[]={2,5,8,1,3,4,7,9,6,0}; TreeClass<int, LessClass<int> > T; for(int i=0;i<10;i++) T.insert(v[i]); T.print(); cout<<"searching 5:"<< (T.search(5)? "Found":"Not found")<<endl; cout<<"searching 11:"<< (T.search(11)? "Found":"Not found")<<endl; cout<<"searching maximum:"<<t.maximum()<<endl; cout<<"searching minimum:"<<t.minimum()<<endl; 30

31 Implementazione C++ //char example char c[]="this_is_a."; TreeClass<char, LessClass<char> > Tc; for(int i=0;i<10;i++) Tc.insert(c[i]); Tc.print(); cout<<"searching s:"<< (Tc.search('s')? "Found":"Not found")<<endl; cout<<"searching v:"<< (Tc.search('v')? "Found":"Not found")<<endl; cout<<"searching maximum:"<<tc.maximum()<<endl; cout<<"searching minimum:"<<tc.minimum()<<endl; } cout<<endl; return 0; 31