ADT albero binario completo

Transcript

1 ADT albero binario completo Un albero binario completo è un albero binario in cui ogni livello, fino al penultimo, è completamente riempito. L'ultimo livello è riempito da sinistra a destra a 1 nodo b c 2 nodi livelli completamente riempiti: contengono il massimo numero possibile di nodi d e f g h i l m n 4 nodi l'ultimo livello può contenere un numero di nodi inferiore al massimo possibile, ma deve essere riempito da sinistra a destra

2 ADT albero binario completo L'ADT albero binario completo è un caso speciale dell'adt albero binario a b c d e f g ultimo nodo Metodi aggiuntivi: h i l m n add(e): aggiunge e restituisce un nuovo nodo esterno (foglia) v che memorizzerà l'elemento e in modo tale che il risultante albero sia un albero binario completo avente v come ultimo nodo remove(): rimuove l'ultimo nodo dell'albero restituendo il suo elemento

3 ADT albero binario completo Relativamente all'operazione di add si possono verificare sostanzialmente due casi: CASO 1 (ultimo livello non pieno) a a b c b c d e d e f

4 ADT albero binario completo Relativamente all'operazione di add si possono verificare sostanzialmente due casi: CASO 2 (ultimo livello pieno) a a b c b c d e f g d e f g h

5 ADT albero binario completo Interfaccia public interface CompleteBinaryTree<E> extends BinaryTree<E> { public Position<E> add(e elem); } public E remove();

6 ADT albero binario completo Implementazione con arraylist Tutti i nodi dell'albero binario completo sono memorizzati in un array list A a la radice è memorizzata all'indice 1 b c per ogni nodo v memorizzato all'indice i: d e f g - il suo figlio sinistro è memorizzato all'indice 2i - il suo figlio destro è memorizzato all'indice 2i + 1 h i l m n a b c d e f g h i l m n l'ultimo nodo è memorizzato in A[n] i 2i 2i+1

7 ADT albero binario completo Implementazione con arraylist a le operazioni di add e remove richiedono tempo O(1) viene coinvolto solo l'ultimo elemento dell'arraylist b c d e f g h i l m n a b c d e f g h i l m n i 2i 2i+1

8 ADT albero binario completo Implementazione con arraylist a le operazioni di add e remove richiedono tempo O(1) viene coinvolto solo l'ultimo elemento dell'arraylist b c d e f g h i l m n o a b c d e f g h i l m n o i 2i 2i+1

9 ADT albero binario completo Implementazione con arraylist a b c d e f g le operazioni di add e remove richiedono tempo O(1) viene coinvolto solo l'ultimo elemento dell'arraylist in caso venga usato un arraylist estensibile, si può dimostrare che le operazioni di add e remove richiedono O(1) in tempo ammortizzato h i l m n o a b c d e f g h i l m n o i 2i 2i+1

10 ADT albero binario completo Implementazione con arraylist public class ArrayListCompleteBinaryTree<E> implements CompleteBinaryTree<E> { protected IndexList<BTPos<E>> T; // indexed list of tree positions protected static class BTPos<E> implements Position<E> { E element; int index; // indice di questa posizione nell'array list public BTPos(E elt, int i) { element = elt; index = i; } public E element() { return element; } public int index() { return index; } public E setelement(e elt) { E temp = element; element = elt; return temp; } public String tostring() { return("[" + element + "," + index + "]"); } }...

11 ADT albero binario completo Implementazione con arraylist public ArrayListCompleteBinaryTree() { T = new ArrayIndexList<BTPos<E>>(); T.add(0, null); // the location at rank 0 is deliberately empty } /** Returns the number of (internal and external) nodes. */ public int size() { return T.size() - 1; } /** Returns whether the tree is empty. */ public boolean isempty() { return (size() == 0); } /** Returns whether v is an internal node. */ public boolean isinternal(position<e> v) throws InvalidPositionException { return hasleft(v); // if v has a right child it will have a left child } /** Returns whether v is an external node. */ public boolean isexternal(position<e> v) throws InvalidPositionException { return!isinternal(v); } /** Returns whether v is the root node. */ public boolean isroot(position<e> v) throws InvalidPositionException { BTPos<E> vv = checkposition(v); return vv.index() == 1; }...

12 ADT albero binario completo Implementazione con arraylist public boolean hasleft(position<e> v) throws InvalidPositionException { BTPos<E> vv = checkposition(v); return 2*vv.index() <= size(); } /** Returns whether v has a right child. */ public boolean hasright(position<e> v) throws InvalidPositionException { BTPos<E> vv = checkposition(v); return 2*vv.index() + 1 <= size(); } /** Returns the root of the tree. */ public Position<E> root() throws EmptyTreeException { if (isempty()) throw new EmptyTreeException("Tree is empty"); return T.get(1); } /** Returns the left child of v. */ public Position<E> left(position<e> v) throws InvalidPositionException, BoundaryViolationException { if (!hasleft(v)) throw new BoundaryViolationException("No left child"); BTPos<E> vv = checkposition(v); return T.get(2*vv.index()); }...

13 ADT albero binario completo Implementazione con arraylist public Position<E> right(position<e> v) throws InvalidPositionException { if (!hasright(v)) throw new BoundaryViolationException("No right child"); BTPos<E> vv = checkposition(v); return T.get(2*vv.index() + 1); } /** Returns the parent of v. */ public Position<E> parent(position<e> v) throws InvalidPositionException, BoundaryViolationException { if (isroot(v)) throw new BoundaryViolationException("No parent"); BTPos<E> vv = checkposition(v); return T.get(vv.index()/2); } /** Returns an iterable collection of the children of v. */ public Iterable<Position<E>> children(position<e> v) throws InvalidPositionException { PositionList<Position<E>> children = new NodePositionList<Position<E>>(); if (hasleft(v)) children.addlast(left(v)); if (hasright(v)) children.addlast(right(v)); return children; }

14 ADT albero binario completo Implementazione con arraylist public Iterable<Position<E>> positions() { PositionList<Position<E>> positions = new NodePositionList<Position<E>>(); for (int i =1; i < T.size(); i++) positions.addlast(t.get(i)); return positions; } /** Replaces the element at v. */ public E replace(position<e> v, E o) throws InvalidPositionException { BTPos<E> vv = checkposition(v); return vv.setelement(o); } /** Adds an element just after the last node (in a level numbering). */ public Position<E> add(e e) { int i = size() + 1; BTPos<E> p = new BTPos<E>(e,i); T.add(i, p); return p; } /** Removes and returns the element at the last node. */ public E remove() throws EmptyTreeException { if(isempty()) throw new EmptyTreeException("Tree is empty"); return T.remove(size()).element(); }...

15 ADT albero binario completo Esercizi Completare l'implementazione con i restanti metodi e aggiungere il metodo public Position<E> sibling(position<e> v) che prende in input un nodo e restituisce il suo fratello.

16 Heap Un heap è un albero binario che memorizza una collezione di entrate nei suoi nodi e che soddisfa le due seguenti proprietà: 1) (proprietà di ordinamento) ogni nodo diverso dalla radice memorizza un elemento la cui chiave è maggiore o uguale di quella del suo padre; 2) (proprietà strutturale) in ogni livello dell'albero c'è il massimo numero di nodi possibile, tranne che nell'ultimo 3 che è riempito da sinistra a destra, cioè deve essere un albero binario completo. 5 4 Tutte le foglie sono addossate a sinistra

17 Altezza di un heap Qual è il massimo numero di nodi di un heap di altezza h? h h =2 h 1 1

18 Altezza di un heap Qual è il minimo numero di nodi di un heap di altezza h? h h 1 1=2 h 1 1=2 h

19 Altezza di un heap Quindi: 2 h n 2 h 1 1 log n 1 1 h log n h = log n h h-1 Un heap con n entrate ha altezza h = log n

20 ADT Coda a Priorità Interfaccia public interface PriorityQueue<K, V> { public int size(); public boolean isempty(); /** Restituisce senza rimuoverla una entry con chiave minima. */ public Entry<K,V> min() throws EmptyPriorityQueueException; /** Inserisce una coppia key-value e restituisce la entry creata. */ public Entry<K,V> insert(k key, V value) throws InvalidKeyException; } /** Rimuove e restituisce una entry con chiave minima. */ public Entry<K,V> removemin() throws EmptyPriorityQueueException;

21 ADT Coda a Priorità Implementazione con heap L'ADT coda a priorità può essere implementato efficientemente con un heap. L'implementazione basata su heap consiste dei seguenti elementi: un heap, cioè un albero binario completo che memorizza nei suoi nodi entrate (chiave,valore) le cui chiavi soddisfano la proprietà di ordinamento dell'heap un comparatore, cioè un oggetto che definisce una relazione d'ordine totale tra le chiavi

22 ADT Coda a Priorità Implementazione con heap Inserimento di una nuova entrata con chiave

23 ADT Coda a Priorità Implementazione con heap Inserimento di una nuova entrata con chiave 4 1) eseguiamo prima un'operazione di add che preserva la proprietà di albero binario completo ma non quella di ordinamento

24 ADT Coda a Priorità Implementazione con heap Inserimento di una nuova entrata con chiave 4 1) eseguiamo prima un'operazione di add che preserva la proprietà di albero binario completo ma non quella di ordinamento 2) continuiamo a scambiare l'entrata del nuovo nodo z con quella di suo padre u fino a che chiave(z) chiave(u)

25 ADT Coda a Priorità Implementazione con heap Inserimento di una nuova entrata con chiave 4 1) eseguiamo prima un'operazione di add che preserva la proprietà di albero binario completo ma non quella di ordinamento 2) continuiamo a scambiare l'entrata del nuovo nodo z con quella di suo padre u fino a che chiave(z) chiave(u)

26 ADT Coda a Priorità Implementazione con heap Inserimento di una nuova entrata con chiave 4 1) eseguiamo prima un'operazione di add che preserva la proprietà di albero binario completo ma non quella di ordinamento 2) continuiamo a scambiare l'entrata del nuovo nodo z con quella di suo padre u fino a che chiave(z) chiave(u)

27 ADT Coda a Priorità Implementazione con heap Inserimento di una nuova entrata con chiave 4 nel caso pessimo si eseguono un numero di swap pari all'altezza dell'albero, cioè log n

28 ADT Coda a Priorità Implementazione con heap Rimozione (RemoveMin)

29 ADT Coda a Priorità Implementazione con heap Rimozione (RemoveMin) 1) copiamo l'entrata e dell'ultimo nodo nella radice

30 ADT Coda a Priorità Implementazione con heap Rimozione (RemoveMin) 1) copiamo l'entrata e dell'ultimo nodo nella radice 2) cancelliamo l'ultimo nodo

31 ADT Coda a Priorità Implementazione con heap Rimozione (RemoveMin) 1) copiamo l'entrata e dell'ultimo nodo nella radice 2) cancelliamo l'ultimo nodo 3) continuiamo a scambiare l'entrata e nel nodo u con quella del figlio di u avente la più piccola chiave fino a che la proprietà di ordinamento non verrà ristabilita

32 ADT Coda a Priorità Implementazione con heap Rimozione (RemoveMin) 1) copiamo l'entrata e dell'ultimo nodo nella radice 2) cancelliamo l'ultimo nodo 3) continuiamo a scambiare l'entrata e nel nodo u con quella del figlio di u avente la più piccola chiave fino a che la proprietà di ordinamento non verrà ristabilita

33 ADT Coda a Priorità Implementazione con heap Rimozione (RemoveMin) 1) copiamo l'entrata e dell'ultimo nodo nella radice 2) cancelliamo l'ultimo nodo 3) continuiamo a scambiare l'entrata e nel nodo u con quella del figlio di u avente la più piccola chiave fino a che la proprietà di ordinamento non verrà ristabilita

34 ADT Coda a Priorità Implementazione con heap Rimozione (RemoveMin) 1) copiamo l'entrata e dell'ultimo nodo nella radice 2) cancelliamo l'ultimo nodo 3) continuiamo a scambiare l'entrata e nel nodo u con quella del figlio di u avente la più piccola chiave fino a che la proprietà di ordinamento non verrà ristabilita

35 ADT Coda a Priorità Implementazione con heap Rimozione (RemoveMin) nel caso pessimo si eseguono un numero di swap pari all'altezza dell'albero, cioè log n

36 ADT Coda a Priorità Implementazione con heap Operazione Complessità size, isempty O(1) min O(1) insert O(log n) removemin O(log n)