La presentazione è in caricamento. Aspetta per favore

La presentazione è in caricamento. Aspetta per favore

Algoritmi e strutture dati Alberi binari di ricerca (BST)

Presentazioni simili


Presentazione sul tema: "Algoritmi e strutture dati Alberi binari di ricerca (BST)"— Transcript della presentazione:

1 Algoritmi e strutture dati Alberi binari di ricerca (BST)

2 Algoritmi e strutture dati2 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

3 Algoritmi e strutture dati3 albero binario di ricerca/ errato!ok

4 Algoritmi e strutture dati4 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

5 Algoritmi e strutture dati5 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

6 Algoritmi e strutture dati6 rappresentazione collegata dei nodi public class BSTNode { /* Qui può essere presente un campo info */ protected Comparable key; // interface Comparable richiede metodo compareTo BSTNode left, right; // rappr. minima public BSTNode() {…} public BSTNode(Object el) {…} public BSTNode(Object el, BSTNode lt, BSTNode rt) {…} public void visit() { key.visit(); } public boolean isLeaf() {…} }

7 Algoritmi e strutture dati7 public interface Comparable public 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

8 Algoritmi e strutture dati8 public interface Comparable/2 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"

9 Algoritmi e strutture dati9 operazioni sui BST public interface BST { void clear(); boolean isEmpty(); BSTNode search(BSTNode p, Comparable el); void insert(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); void delete(Comparable el); }

10 Algoritmi e strutture dati10 altre operazioni sui BST BSTNode minimum(BSTNode v); BSTNode maximum(BSTNode v); BSTNode successor(BSTNode v); BSTNode predecessor(BSTNode v); D.: quali sono gli elementi max. e min. ?

11 Algoritmi e strutture dati11 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), …

12 Algoritmi e strutture dati12 ricerca in un BST BSTNode search(BSTNode p, Comparable el) { while (p != null) if (el.equals(p.key)) return p; else if (el.compareTo(p.key)<0) p = p.left; else p = p.right; return null; /* Se non lo trova */ }

13 Algoritmi e strutture dati13 Versione ricorsiva BSTNode search(BSTNode p, Comparable el) { if(p == null) return null; if (el.compareTo(p.key)<0) return search(p.left, el); else if (el.compareTo(p.key)>0) return search(p.right,el); else return p;/* Trovato !! */ }

14 Algoritmi e strutture dati14 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)

15 Algoritmi e strutture dati15 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) costo della ricerca in un BST/2

16 Algoritmi e strutture dati16 analisi del caso medio IPL (internal path length): somma lungh. percorsi radice-nodo, per tutti i nodi lungh. media percorso radice-nodo: IPL/(#nodi)

17 Algoritmi e strutture dati17 analisi del caso medio/2 chiavi 1,…,n presenti in un BST di n nodi (senza perdita di generalità) P n (i ): percorso medio in BST di n nodi avente chiave i in radice P n : percorso medio in BST di n nodi se k(radice) = i allora –sottoalbero sx ha i – 1 chiavi –sottoalbero dx ha n – i chiavi

18 Algoritmi e strutture dati18 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

19 Algoritmi e strutture dati19 inserimento in un BST/2 public void insert(Comparable el) { BSTNode p = root, prev = null; while (p != null) { prev = p; if (p.key.compareTo(el)<0) p = p.right; else p = p.left; } if (root == null) // albero vuoto; root = new BSTNode(el); else if (prev.key.compareTo(el)<0) prev.right = new BSTNode(el); else prev.left = new BSTNode(el); } fase 1 fase 2

20 Algoritmi e strutture dati20 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 la fase 2 si limita a collegare una nuova foglia

21 Algoritmi e strutture dati21 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 )

22 Algoritmi e strutture dati22 costo dell'inserimento in un BST ogni inserimento introduce una nuova foglia il costo è (proporzionale a) la lunghezza del ramo radice-foglia nel caso peggiore O(n )

23 Algoritmi e strutture dati23 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

24 Algoritmi e strutture dati24 cancellazione da un BST/2 cancellazione di una foglia basta individuare il nodo genitore e mettere a null la variabile membro opportuna (left o right) individuare il genitore significa sostanzialmente 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)

25 Algoritmi e strutture dati25 cancellazione da un BST/3 cancellazione di

26 Algoritmi e strutture dati26 cancellazione da un BST/4 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 u v w u v w u v u v w

27 Algoritmi e strutture dati27 cancellazione da un BST/4 cancellazione di

28 Algoritmi e strutture dati28 cancellazione da un BST/5 cancellazione di un nodo u con due figli (ci si riconduce ad uno dei casi precedenti – cancellazione per copiatura) individuare predecessore v (o successore) di u (secondo il valore della chiave) –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 o ha un solo figlio

29 Algoritmi e strutture dati29 cancellazione per copiatura u v u v copia chiave w w w u u w cancella v v

30 Algoritmi e strutture dati30 Cancellazione per copiatura/2 public void deleteByCopying(Comparable el) { BSTNode node, p = root, prev = null; while (p != null && !p.key.equals(el)) { prev = p; if (p.key.compareTo(el)<0) p = p.right; else p = p.left; } node = p; /* Cerca il nodo */ /* Continua alla prossima slide..... */

31 Algoritmi e strutture dati31 Cancellazione per copiatura/3 /* Dalla slide precedente.... */ if (p != null && p.key.equals(el)) { if (node.right == null) node = node.left; else if (node.left == null) node = node.right; /* Casi semplici: il nodo ha un solo figlio */ /* Continua.... */

32 Algoritmi e strutture dati32 Cancellazione per copiatura/4 /* Dalla slide precedente.... */ else { /* Due figli.... */ BSTNode tmp = node.left; BSTNode previous = node; while (tmp.right != null) { previous = tmp; tmp = tmp.right; } node.key = tmp.key; /* Copia anche info se presente */ if (previous == node) previous.left = tmp.left; else previous.right = tmp.left; } /* Continua... */

33 Algoritmi e strutture dati33 Cancellazione per copiatura/5 /* Dalla slide precedente.... */ if (p == root) /* Trova padre nuovo nodo */ root = node; else if (prev.left == p) prev.left = node; else prev.right = node; } else if (root != null) System.out.println(“Elemento assente”); else System.out.println(“Albero vuoto"); }

34 Algoritmi e strutture dati34 u 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 ) n/2 da cancellare predecessore v

35 Algoritmi e strutture dati35 Cancellazione per fusione u v x u: nodo da cancellare x: nodo predecessore di u v x w w

36 Algoritmi e strutture dati36 Domande Si implementi il metodo di visita in ordine simmetrico Cosa produce la visita simmetrica se le chiavi sono stringhe? Perché per implementare le basi di dati si usano alberi e non array?


Scaricare ppt "Algoritmi e strutture dati Alberi binari di ricerca (BST)"

Presentazioni simili


Annunci Google