concetti ed applicazioni heap concetti ed applicazioni

heap heap = catasta condizione di heap non è una struttura ordinata albero binario perfettamente bilanciato tutte le foglie sono “a sinistra” ma non è un BST!! ogni nodo contiene una chiave maggiore o eguale di quelle presenti negli eventuali figli non è una struttura ordinata le visite in ampiezza e in pre- in- post-ordine non forniscono un ordinamento delle chiavi maggio 2002 ASD - Heap

heap? 67 68 89 66 1 65 5 4 64 67 68 89 2 1 66 65 3 4 5 6 67 67 1 66 65 89 maggio 2002 ASD - Heap

max- e min-heap la struttura definita è detta max-heap variante: min-heap ogni nodo contiene una chiave minore o eguale di quelle presenti negli eventuali figli 13 22 6 32 23 33 24 44 27 56 81 min-heap maggio 2002 ASD - Heap

operazioni su un (max-)heap insert chiave inserisce nuova chiave nello heap occorre mantenere la condizione di heap deleteMax cancella chiave max dallo heap getMax restituisce la chiave max nello heap non modifica lo heap maggio 2002 ASD - Heap

rappresentazione degli heap tutte le rappresentazione usate per gli alberi binarie sono ammissibili rappresentazione collegata, eventualmente con puntatori figli-genitore rappresentazione tramite array particolarmente efficiente maggio 2002 ASD - Heap

rappresentazione tramite array ogni nodo v è memorizzato in posizione p(v) se v è la radice allora p(v)=0 se v è il figlio sinistro di u allora p(v)=2p(u)+1 se v è il figlio destro di u allora p(v)=2p(u)+2 65 66 67 1 43 21 5 4 68 89 64 6 7 8 9 10 11 3 2 12 67 68 89 43 1 66 65 21 5 4 64 maggio 2002

heap su array vantaggi svantaggio grande efficienza in termini di spazio l’occupazione può essere minima facilità di navigazione genitore i -> figli j j = 2i + 1, 2i + 2 figlio i -> genitore j j = (i – 1) / 2 svantaggio implementazione statica possono essere necessari progressivi raddoppiamenti/dimezzamenti dell’array di supporto maggio 2002 ASD - Heap

rappresentazione in Java public class Heap { public static final int DEFAULTCAPACITY = 50; private int[] storage; private int size; public Heap() { this(DEFAULTCAPACITY); } public Heap(int dim) { storage = new int[dim]; size = 0; // metodi… maggio 2002 ASD - Heap

rappresentazione in Java/2 public boolean isLeaf(int i) { return getLeftIndex(i) >= size; } public boolean isRoot(int i) { return i == 0; public boolean isEmpty() { return size == 0; public boolean isFull() { return size == storage.length; svantaggio implementazione statica possono essere necessari progressivi raddoppiamenti/dimezzamenti dell’array di supporto maggio 2002 ASD - Heap

rappresentazione in Java/3 private int getLeftIndex(int i) { return 2 * i + 1; } private int getRightIndex(int i) { return getLeftIndex(i) + 1; private int getParentIndex(int i) { return (i - 1) / 2; public String toString() {…} // implementazione delle operazioni fondamentali svantaggio implementazione statica possono essere necessari progressivi raddoppiamenti/dimezzamenti dell’array di supporto maggio 2002 ASD - Heap

algoritmi su heap operazioni altri algoritmi getMax insert deleteMax Array2Heap conversione di un array in heap HeapSort ordinamento di un array basato su heap maggio 2002 ASD - Heap

getMax il max è contenuto nella cella 0 dell’array operazione di costo costante O(1) public int getMax() throws Exception { if(!isEmpty()) return storage[0]; else throw new Exception("getMax requested to empty heap"); } maggio 2002 ASD - Heap

insert 1. inserisci elemento alla fine dello heap 2. while (elemento non è radice) and (elemento > genitore(elemento)) 3. scambia elemento con genitore maggio 2002 ASD - Heap

insert/2 maggio 2002 ASD - Heap

insert/3 Algorithm insert(int k) { storage[size] = k; int i = size++; int j = getParentIndex(i); while(!isRoot(i) && (storage[i] > storage[j])) { exchange(i, j); // scambia celle di storage i = j; j = getParentIndex(i); } maggio 2002 ASD - Heap

Heapify(i) operazione heapify(i) considera l'albero avente radice nella cella i e, qualora non rispetti la condizione di heap attraverso una sequenza di scambi while (i non è foglia) and (i < un figlio) scambia i con il suo figlio maggiore maggio 2002 ASD - Heap

Heapify public void heapify(int i) { if(isLeaf(i)) return; else { int j = 0; // inizializzazione fittizia per tacitare compilatore try { j = getMaxChildIndex(i); } catch(Exception e) { // only if i is a leaf.... already checked if(storage[i] < storage[j]) exchange(i, j); heapify(j); } } maggio 2002 ASD - Heap

deleteMax 1 sostituisci primo elemento con ultima foglia ed elimina ultima foglia Invoca Heapify sulla radice maggio 2002 ASD - Heap

deleteMax/2 maggio 2002 ASD - Heap

heap e code di priorità una coda di priorità è un tipo astratto con le seguenti operazioni enqueue, inserimento in coda dequeue, estrazione dalla coda dell’elemento avente priorità max la priorità è in genere espressa da un intero gli heap sono strutture di dati eccellenti per l’implementazione di code di priorità svantaggio implementazione statica possono essere necessari progressivi raddoppiamenti/dimezzamenti dell’array di supporto maggio 2002 ASD - Heap

Heapsort/1 Ordinamento di un insieme di n interi Costruisci l’Heap inserendo gli elementi nell’Heap con insert. Complessità: O(n log n) Applica ripetutuamente deleteMax Complessità: O(n log n) maggio 2002 ASD - Heap

Heapsort/2 public static void heapSort(int[] data) { Heap aHeap = array2heap(data); for(int i = aHeap.size - 1; i > 0; i--) { aHeap.exchange(0, i); aHeap.size--; aHeap.heapify(0); } System.arraycopy(aHeap.storage, 0, data, 0, aHeap.storage.length); maggio 2002 ASD - Heap

Costruzione di un Heap in O(n)/1 Disponi l’insieme di elementi in un array For (i= indice ultimo nodo non foglia; i>=0, i--) Invoca heapify (i) public static Heap array2heap(int[] data) { Heap aHeap = new Heap(data.length); aHeap.size = data.length; System.arraycopy(data, 0, aHeap.storage, 0, data.length); for(int i = aHeap.getParentIndex(aHeap.size-1); i >= 0; i--) aHeap.heapify(i); return aHeap; } maggio 2002 ASD - Heap

maggio 2002 ASD - Heap

Costruzione di un Heap in O(n)/2 Assumi n=2k-1, heap di k-1 livelli Heapify invocata (n+1)/2 volte sui nodi dal penultimo livello fino al primo. (n+1)/4 nodi del penultimo livello. Heapify richiede al più 1 scambio (n+1)/2i di livello k-i-1. Heapify su nodo di livello k-i-1 provoca al più i-1 scambi maggio 2002 ASD - Heap

Costruzione di un Heap in O(n)/2 Heap di n nodi ha al più lg(n) livelli i-esimo livello dal basso: (n+1)/2i nodi i-1 scambi compiuti da Heapify maggio 2002 ASD - Heap