Alberi Binari di Ricerca (ABR)

Transcript

1 Alberi Binari di Ricerca (ABR) (Binary Search Tree BST) Albero binario di ricerca E n albero binario che soddisfa le segenti proprietà: Ogni elemento ha na chiae (s ci è definito n ordinamento); de elementi non possono aere la stessa chiae (cioè le chiai sono niche); Le chiai in n sottoalbero sinistro non oto deono essere più piccole della chiae nella radice dell albero Le chiai in n sottoalbero destro non oto deono essere più grandi della chiae nella radice dell albero Anche i sottoalberi sinistro e destro sono alberi di ricerca binari 1

2 Albero binario di ricerca In altri termini, definito n ordinamento sll informazione dei nodi (es: interi, stringhe, ma anche strttre complesse con n campo chiae), n albero binario è n albero binario di ricerca se: Per ogni nodo N dell albero: L informazione associata ad ogni nodo nel sottoalbero sinistro di N è strettamente minore dell informazione associata ad N; L informazione associata ad ogni nodo nel sottoalbero destro di N è strettamente maggiore dell informazione associata ad N; Albero binario di ricerca: esempio ok errato!

3 Rappresentazione ABR in C Esattamente identica agli Alberi Binari già esaminati (con l nico incolo della presenza nel campo info di n alore che fnga da chiae) typedef int TipoInfoAlbero; /* etichetta di tipo intero */ strct nodoalbero { TipoInfoAlbero info; strct nodoalbero *destro, *sinistro; typedef strct nodoalbero NodoAlbero; typedef NodoAlbero *TipoAlbero; Perché si sano gli ABR? La ricerca di n elemento in n albero binario di ricerca è na operazione molto efficiente (se l albero è bilanciato) 3

4 Alberi bilanciati Un albero (binario) si dice bilanciato se, detta P la profondità dell albero, ttte le foglie stanno a liello P o P-1, e ttti i nodi interni hanno de figli, tranne al più n nodo al liello P-1 che ne ha no solo Bilanciato Non bilanciato 91 Ricerca in n ABR algoritmo cerca elem nell albero binario di ricerca Alb if Alb è oto then elem non è presente in Alb else if elem coincide con l etichetta della radice di Alb then elem `e stato troato else if elem precede l etichetta della radice di Alb then cerca elem nel sottoalbero sinistro di Alb else cerca elem nel sottoalbero destro di Alb 4

5 Ricerca in n ABR (ersione ricorsia) /* Effetta la ricerca di elem nell'albero binario di ricerca a. Il alore di ritorno e` il sottoalbero di a la ci radice e` pari ad elem, se elem e` presente in a, NULL altrimenti.*/ TipoAlbero RicercaAlbero(TipoAlbero a, TipoInfoAlbero elem) { TipoAlbero posiz; if (a == NULL) posiz = NULL; else if (elem == a->info) /* l'elemento e` stato troato */ posiz = a; else if (elem < a->info) /* cerca nel sottoalbero sinistro */ posiz = RicercaAlbero(a->sinistro, elem); else /* cerca nel sottoalbero destro */ posiz = RicercaAlbero(a->destro, elem); retrn posiz; Ricerca in n ABR (ersione iteratia) TipoAlbero RicercaAlbero(TipoAlbero a, TipoInfoAlbero elem) { while (a!= nll) { if (elem == a->info) /* l'elemento e` stato troato */ retrn a; else if (elem < a->info) /* cerca nel sottoalbero sinistro */ a = a->sinistro; else /* cerca nel sottoalbero destro */ a= a->destro; retrn NULL; in qesto caso, la ersione iteratia non richiede l'so di na pila: perché? 5

6 Costo della ricerca in n ABR ABR di n nodi caso peggiore Albero che degenera in lista O(n) caso medio dipende dalla distribzione O(lg n) per alberi bilanciati caso migliore O(1) (poco interessante) Costo della ricerca in n ABR nel caso di distribzione niforme delle chiai il alore atteso dell'altezza dell'albero èo(lgn) N.B. L'altezza di n albero binario di n nodi aria in { lg 2 n + 1,, n n BST con chiai niformemente distribite ha n costo atteso di ricerca O(lg n) 6

7 Analisi del caso medio IPL (internal path length): somma lngh. percorsi radice-nodo, per ttti i nodi lngh. media percorso radice-nodo: IPL/(#nodi) Analisi del caso medio spp. chiai 1,,n presenti in n BST di n nodi (senza perdita di generalità) P n (i): lngh. percorso medio in BST di n nodi aente chiae i in radice (IPL/#nodi) P n : percorso medio in BST di n nodi (IPL/#nodi) se k(radice) = i allora sottoalbero sx ha i 1 chiai sottoalbero dx ha n i chiai (Pi 1 + 1)( i 1) + (Pn i + 1)( n i ) P n ( i ) = n n P ( i ) i 1 n Pn = = =... = O(lgn) n 7

8 Visita in n ABR Di ttte le isite analizzate per n albero binario, nel caso di n ABR na rieste na particolare importanza: La isita in ordine simmetrico (inorder) prodce n elenco ordinato delle chiai! , 20, 22,, 57, 82, 88, 91, Ricerca predecessore in n ABR (1) Problema: data na chiae a, troare la chiae b = pred(a), oero la più grande fra le chiai < a operazione sfrttata nell'algoritmo di eliminazione doe si troa b rispetto a? se esiste sottoalbero sinistro si troa in tale sottoalbero se non esiste sottoalbero sinistro si troa sl percorso radice nodo contenente a 8

9 Ricerca predecessore in n ABR (2) Esiste n sottoalbero sinistro di. cerchiamo pred(k()) nel sottoalbero di radice non pò essere nel sottoalbero del figlio destro (chiai > k()) il max nel sottoalbero del figlio sinistro è n candidato si tratta del "nodo più a destra", indiidabile scendendo sempre a destra in tale sottoalbero, fino a troare n nodo senza figlio destro x w non qi Ricerca predecessore in n ABR (3) Non esiste n sottoalbero sinistro di cerchiamo pred(k()) sl cammino erso la radice non pò essere fori dal percorso radice (per le proprietà del BST) E il primo nodo con chiae minore di che si incontra sl cammino erso la radice 9

10 Ricerca predecessore in n ABR (4) TipoAlbero Predecessore(TipoAlbero a, TipoInfoAlbero elem) { TipoAlbero pred=null; while (a!=null) if (elem <= a->info) a = a->sinistro; else { pred = a; a = a->destro; retrn pred; Ricerca predecessore in n ABR (5) costo ricerca predecessore proporzionale all'altezza dell'albero nel caso peggiore O(n) la ricerca del sccessore si realizza in modo analogo e simmetrico. costo O(n) 10

11 Inserimento in n ABR Ogni noo nodo iene inserito come foglia fase 1: cerca il nodo genitore fase 2: inserisci come figlio di Inserimento in n ABR la fase 1 termina qando si ragginge n nodo del BST prio del figlio in ci arebbe ato senso continare la ricerca non necessariamente na foglia è il nodo inserito che diiene foglia la fase 2 si limita a collegare na noa foglia

12 Inserimento in n ABR (1/2) oid InserisciNodoAlbero(TipoAlbero *a, TipoInfoAlbero elem) { TipoAlbero pax, pre; pax = *a; pre = NULL; while (pax!= NULL) { // find a place for insert new node; pre = pax; if (pax->info == elem) retrn; else if (pax->info < elem) pax = pax->destro; else pax = pax->sinistro; /* pre pnta all'ltimo nodo incontrato drante la ricerca */ contina Inserimento in n ABR (2/2) contina pax = (TipoAlbero)malloc(sizeof(TipoNodoAlbero)); pax->info = elem; pax->sinistro = NULL; pax->destro = NULL; if (*a == NULL) /* se l'albero è oto inserisco l'elemento come radice */ *a = pax; else if (pre->info < elem) pre->destro = pax; else pre->sinistro = pax; 12

13 Costo dell inserimento in n ABR Ogni inserimento introdce na noa foglia il costo è (proporzionale a) la lnghezza del ramo radice-foglia interessato all'operazione nel caso peggiore: O(n) Costo dell inserimento in n ABR caso peggiore costo fase 1: O(n ) costo fase 2: O(1) costo totale: O(n ) caso medio (distrib. nif.) costo fase 1: O(lg n ) costo fase 2: O(1) costo totale: O(lg n )

14 Cancellazione da n ABR (1) Si possono presentare tre casi: 1. Il nodo da eliminare è na foglia 2. Il nodo da eliminare ha n solo figlio 3. Il nodo da eliminare ha de figli (caso più complesso) Cancellazione da n ABR (2) 1. cancellazione di na foglia indiidare nodo genitore e metterne a NULL il campo opportno (pntatore sinistro o destro); se foglia = radice (nico nodo) mettere a NULL il riferimento alla radice indiidare genitore significa effettare na ricerca (come nella fase 1 dell'inserimento) n approccio alternatio è basato slla tramatra dell'albero (i nodi contengono altri riferimenti, ad es., al genitore) 14

15 Cancellazione da n ABR (3) cancellazione di Cancellazione da n ABR (4) 2. cancellazione di n nodo con n solo figlio indiidare genitore w di ; se è radice diiene la noa radice se esiste w, sostitire al collegamento (w,) il collegamento (w,) w w w w 15

16 Cancellazione da n ABR (5) cancellazione di Cancellazione da n ABR (6) 3. cancellazione di n nodo con de figli (ci si ricondce ad no dei casi precedenti) indiidare predecessore (o sccessore) di non pò aere de figli, altrimenti non sarebbe predecessore (sccessore) copiare la chiae di al posto di qella di cancellare nodo è foglia oppre ha n solo figlio: caso già trattato 16

17 copia chiae Cancellazione da n ABR (7) w w w cancella w Cancellazione da n ABR (implementazione) oid CancellaNodoAlbero(TipoAlbero *a, TipoInfoAlbero elem) { TipoAlbero p = *a; TipoAlbero parent = NULL, pred; TipoInfoAlbero infotmp; while(p!= NULL){ if(elem > p->info) { parent = p; p = p->destro; else if(elem < p->info) { parent = p; p = p->sinistro; else break; if(p == NULL) retrn; // elem not in tree 17

18 Cancellazione da n ABR (implementazione) // 1st case: p is leaf if(p->sinistro == NULL && p->destro == NULL) if(parent == NULL) { // p is root, too free(p); *a = NULL; else if(parent->destro == p) { // p is rightchild free(p); parent->destro = NULL; else { // p is leftchild free(p); parent->sinistro = NULL; Cancellazione da n ABR (implementazione) // 2nd case: p has one child else if(p->sinistro == NULL) // p has only a rightchild if(parent == NULL) // p is root, too *a = p->destro; else if(parent->destro == p) // p is rightchild { parent->destro = p->destro; free(p); else // p is leftchild { parent->sinistro = p->destro; free(p); else if(p->destro == NULL) // p has only a leftchild if(parent == NULL) // p is root, too *a = p->sinistro; else if(parent->destro == p) // p is rightchild { parent->destro = p->sinistro; free(p); else // p is leftchild { parent->sinistro = p->sinistro; free(p); 18

19 Cancellazione da n ABR (implementazione) // 3rd case: p has 2 children (then it has a predecessor!) else { pred = Predecessore(p->sinistro, p->info); infotmp = pred->info; CancellaNodoAlbero(a,pred->info); // remoing node doesn't hae two children! p->info= infotmp; /* CancellaNodoAlbero */ Costo della cancellazione da n ABR la cancellazione di n nodo interno richiede l'indiidazione del nodo da cancellare nonché del so predecessore (o sccessore) nel caso peggiore entrambi i costi sono lineari: O(n) + O(n) = O(n) da cancellare predecessore n/2 n/2 19