algoritmi e strutture dati alberi binari di ricerca (BST)

Transcript

1 algoritmi e strutture dati alberi binari di ricerca (BST)

2 concetto di chiave insieme di campi di un record che caratterizza l'intero record es.: {<nome>, <cognome>, <codicefiscale>, <datanascita>, <indirizzo>} il <codicefiscale> è una possibile chiave spesso in una struttura dati vengono memorizzate coppie (<chiave>, <riferimento>), in cui <riferimento> è un riferimento per l'accesso ad un insieme di informazioni maggio 2003 ASD

3 chiavi in Java le chiavi sono spesso realizzate come riferimenti Comparable solo se occorre poter stabilire ordinamenti fra chiavi talvolta, a scopo esemplificativo, si usano come chiavi stringhe o interi facilita la descrizione di una struttura dati maggio 2003 ASD

4 interface Comparable da: documentazione API JFC richiede metodo int compareto(object o) returns a negative integer, zero, or a positive integer as this object is less than, equal to, or greater than the specified Object o The implementor must ensure sgn(x.compareto(y)) == -sgn(y.compareto(x)) for all x and y. (This implies that x.compareto(y) must throw an exception iff y.compareto(x) throws an exception.) The implementor must also ensure that the relation is transitive: (x.compareto(y)>0 && y.compareto(z)>0) implies x.compareto(z)>0 Finally, the implementer must ensure that x.compareto(y)==0 implies that sgn(x.compareto(z)) == sgn(y.compareto(z)), for all z maggio 2003 ASD

5 interface Comparable /2 da: documentazione API JFC It is strongly recommended, but not strictly required that (x.compareto(y)==0) == (x.equals(y)). Generally speaking, any class that implements the Comparable interface and violates this condition should clearly indicate this fact. The recommended language is "Note: this class has a natural ordering that is inconsistent with equals" maggio 2003 ASD

6 albero binario di ricerca albero binario che soddisfa la seguente proprietà per ogni nodo, tutte le chiavi nel suo sottoalbero sinistro sono della chiave v associata al nodo e tutti le chiavi nel suo sottoalbero destro sono di v maggio 2003 ASD

7 albero binario di ricerca/ ok errato! maggio 2003 ASD

8 albero binario di ricerca/3 indicato spesso come BST (binary search tree) utilizzabile quando le chiavi appartengono a un universo totalmente ordinato ipotesi semplificativa di lavoro: chiavi strettamente minori nei sottoalberi sinistri e strettamente maggiori nei sotto alberi destri maggio 2003 ASD

9 rappresentazione dei nodi in molti casi può essere la stessa usata negli alberi binari (classe BinaryNode) in alternativa, la si può estendere per le variabili membro possiamo usare lo specificatore di accesso private o protected le conseguenze sono differenti maggio 2003 ASD

10 rappresentazione collegata dei nodi public class BSTNode { protected Comparable key; BSTNode leftchild, rightchild; // rappr. minima public BSTNode() { } public BSTNode(Object el) { } public BSTNode(Object el, BSTNode lt, BSTNode rt) { } public void visit() { key.visit(); } public boolean isleaf() { } } maggio 2003 ASD

11 operazioni sui BST public interface BST { void clear(); boolean isempty(); BSTNode search(bstnode p, Comparable el); void insert(bstnode node); void remove(bstnode node); boolean isintree(comparable el); int getsize(); void inorder(bstnode p); void preorder(bstnode p); void postorder(bstnode p); void breadthfirst(); int treeheight(bstnode radice); } maggio 2003 ASD

12 altre operazioni sui BST BSTNode minimum(bstnode v); BSTNode maximum(bstnode v); BSTNode successor(bstnode v); BSTNode predecessor(bstnode v); maggio 2003 ASD

13 elementi o nodi? il metodo che implementa l operazione search può restituire elementi (Object) o nodi (BSTNode) Object viene rafforzato l incapsulamento variabili membro protected BSTNode operazioni su sottoalberi variabili membro private e metodi accessori/modificatori il dilemma vale anche per altri metodi successor, delete (parametro formale), maggio 2003 ASD

14 ricerca in un BST k(v) = chiave (tipo scalare) associata a nodo v rt(v) = figlio destro di v lt(v) = figlio sinistro di v algorithm search (key k, BSTNode root) if(root == null) return null; if(k == k(root)) return root; if (k < k(root)) return search(k, lt(root)); else return search(k, rt(root)); maggio 2003 ASD

15 ricerca in un BST/2 versione iterativa algorithm search (key k, BSTNode root) t = root; while(t!= null) if(k(t) > k) t = lt(t); else if(k(t) < k) t = rt(t); else return t; return null; in questo caso, la versione iterativa non richiede l'uso di una pila: perché? maggio 2003 ASD

16 costo della ricerca in un BST BST di n nodi caso peggiore O(n) caso medio dipende dalla distribuzione caso migliore O(1) (poco interessante) maggio 2003 ASD

17 costo della ricerca in un BST/2 nel caso di distribuzione uniforme delle chiavi il valore atteso dell'altezza dell'albero è O(lg n) N.B. L'altezza di un albero binario di n nodi varia in { lg 2 n + 1,, n} un BST con chiavi uniformemente distribuite ha un costo atteso di ricerca O(lg n) maggio 2003 ASD

18 analisi del caso medio IPL (internal path length): somma lungh. percorsi radice-nodo, per tutti i nodi lungh. media percorso radice-nodo: IPL/(#nodi) maggio 2003 ASD

19 analisi del caso medio/2 supp. chiavi 1,,n presenti in un BST di n nodi (senza perdita di generalità) P n (i): lungh. percorso medio in BST di n nodi avente chiave 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 chiavi sottoalbero dx ha n i chiavi P ( i ) n P n = = n i = (Pi 1 + 1)( i 1) + (Pn i + n P ( i ) 1 n =... = O(lgn) n 1)( n i ) maggio 2003 ASD

20 ricerca predecessore in BST data una chiave a, trovare la chiave b = pred(a), ovvero la più grande fra le chiavi < a operazione sfruttata nell'algoritmo di eliminazione dove si trova b rispetto a? se esiste sottoalbero sinistro si trova in tale sottoalbero se non esiste sottoalbero sinistro si trova sul percorso radice nodo contenente a maggio 2003 ASD

21 ricerca predecessore in BST /2 cerchiamo pred(k(u)) nel sottoalbero di radice u non può essere nel sottoalbero del figlio destro (chiavi > k(u)) il max nel sottoalbero del figlio sinistro è un candidato si tratta del "nodo più a destra", individuabile scendendo sempre a destra in tale sottoalbero, fino a trovare un nodo senza figlio destro x u w v non qui maggio 2003 ASD

22 ricerca predecessore in BST /3 cerchiamo pred(k(u)) "altrove" non può essere fuori dal percorso radice u (per le proprietà del BST) il miglior candidato di tale percorso è < del candidato nel sottoalbero sinistro di u (per le proprietà del BST) u maggio 2003 ASD

23 ricerca predecessore in BST /4 algorithm predecessor (key a, BSTNode root) t = root; pred = - ; while(t!= null) if(k(t) >= a) t = lt(t); else if(k(t) < a) { // discese a destra aumentano chiave pred = k(t); t = rt(t); } return pred; // se non esiste maggio 2003 ASD

24 ricerca predecessore in BST /5 costo ricerca predecessore proporzionale all'altezza dell'albero nel caso peggiore O(n) la ricerca del successore può essere gestita "simmetricamente" costo O(n) maggio 2003 ASD

25 inserimento in un BST nuovo nodo u viene inserito come foglia fase 1: cerca il nodo genitore v fase 2: inserisci u come figlio di v maggio 2003 ASD

26 inserimento in un BST/2 Algorithm insert(key r) p = root; while (p!= null) { prev = p; if (k(p) < r) p = rt(p); else p = lt(p); } if (root == null) // BST vuoto root = new BSTNode(r); else if (k(prev) < r) rt(prev) = new BSTNode(r); else lt(prev) = new BSTNode(r); fase 1 fase 2 maggio 2003 ASD

27 inserimento in un BST/3 la fase 1 termina quando si raggiunge un nodo del BST privo del figlio in cui avrebbe avuto senso continuare la ricerca non necessariamente una foglia è il nodo inserito che diviene foglia la fase 2 si limita a collegare una nuova foglia maggio 2003 ASD

28 inserimento in un BST/4 caso peggiore costo fase 1: O(n ) costo fase 2: O(1) costo totale: O(n ) caso medio (distrib. unif.) costo fase 1: O(lg n ) costo fase 2: O(1) costo totale: O(lg n ) maggio 2003 ASD

29 costo dell'inserimento in un BST ogni inserimento introduce una nuova foglia il costo è (proporzionale a) la lunghezza del ramo radice-foglia nteressato all'operazione nel caso peggiore: O(n) maggio 2003 ASD

30 cancellazione da un BST tre casi 1. cancellazione di una foglia 2. cancellazione di un nodo con un solo figlio 3. cancellazione di un nodo con due figli maggio 2003 ASD

31 cancellazione da un BST/2 1. cancellazione di una foglia individuare nodo genitore e metterne a null la variabile membro opportuna (leftchild o rightchild); se foglia = radice (unico nodo) mettere a null il riferimento alla radice individuare genitore significa effettuare una ricerca (come nella fase 1 dell'inserimento) un approccio alternativo è basato sulla tramatura dell'albero (i nodi contengono altri riferimenti, ad es., al genitore) maggio 2003 ASD

32 cancellazione da un BST/3 cancellazione di maggio 2003 ASD

33 cancellazione da un BST/4 2. cancellazione di un nodo u con un solo figlio v individuare genitore w di u; se u è radice v diviene la nuova radice se esiste w, sostituire al collegamento (w,u) il collegamento (w,v) w w w w v u v u v u v u maggio 2003 ASD

34 cancellazione da un BST/5 cancellazione di maggio 2003 ASD

35 cancellazione da un BST/6 3. cancellazione di un nodo u con due figli (ci si riconduce ad uno dei casi precedenti) individuare predecessore v (o successore) di u v non può avere due figli, altrimenti non sarebbe predecessore (successore) copiare la chiave di v al posto di quella di u cancellare nodo v v è foglia oppure ha un solo figlio: caso già trattato maggio 2003 ASD

36 copia chiave cancellazione da un BST/7 u u u u w v w v cancella v w v w maggio 2003 ASD

37 costo della cancellazione in un BST la cancellazione di un nodo interno richiede l'individuazione del nodo da cancellare nonché del suo predecessore (o successore) nel caso peggiore entrambi i costi sono lineari: O(n) + O(n) = O(n) da cancellare u v n/2 n/2 predecessore maggio 2003 ASD