heap concetti ed applicazioni
Welcome message from author
This document is posted to help you gain knowledge. Please leave a comment to let me know what you think about it! Share it to your friends and learn new things together.
Transcript
- Slide 1
- heap concetti ed applicazioni
- Slide 2
- maggio 2002ASD - Heap2 heap heap = catasta condizione di heap 1.albero binario perfettamente bilanciato 2.tutte le foglie sono a sinistra ma non un BST!! 3.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
- Slide 3
- maggio 2002ASD - Heap3 heap? 6768 89 661 65 665 67 464 6768 89 21 6665 34 66 56 67 89 67 1 6665
- Slide 4
- maggio 2002ASD - Heap4 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 1322 6 3223 1323 3324 4427 5681 min-heap
- Slide 5
- maggio 2002ASD - Heap5 operazioni su un (max-)heap insert chiave inserisce nuova chiave nello heap occorre mantenere la condizione di heap deleteMax cancella chiave max dallo heap occorre mantenere la condizione di heap getMax restituisce la chiave max nello heap non modifica lo heap
- Slide 6
- maggio 2002ASD - Heap6 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
- Slide 7
- maggio 2002 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 6768 89 431 6665 215 6667 464 65 66 67 1 43 21 5 4 66 68 67 89 64 4 5 6 7 8 9 10 11 3 2 1 0 12
- Slide 8
- maggio 2002ASD - Heap8 heap su array vantaggi grande efficienza in termini di spazio loccupazione 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 dellarray di supporto
- Slide 9
- maggio 2002ASD - Heap9 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
- Slide 10
- maggio 2002ASD - Heap10 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; }
- Slide 11
- maggio 2002ASD - Heap11 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 }
- Slide 12
- maggio 2002ASD - Heap12 algoritmi su heap operazioni getMax insert deleteMax altri algoritmi Array2Heap conversione di un array in heap HeapSort ordinamento di un array basato su heap
- Slide 13
- maggio 2002ASD - Heap13 getMax il max contenuto nella cella 0 dellarray 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"); }
- Slide 14
- maggio 2002ASD - Heap14 insert 1.inserisci elemento alla fine dello heap 2.while (elemento non radice) and (elemento > genitore(elemento)) 3.scambia elemento con genitore
- Slide 15
- maggio 2002ASD - Heap15 insert/2
- Slide 16
- maggio 2002ASD - Heap16 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); }
- Slide 17
- maggio 2002ASD - Heap17 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
- Slide 18
- maggio 2002ASD - Heap18 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);}
- Slide 19
- maggio 2002ASD - Heap19 deleteMax 1 1.sostituisci primo elemento con ultima foglia ed elimina ultima foglia 1.Invoca Heapify sulla radice
- Slide 20
- maggio 2002ASD - Heap20 deleteMax/2
- Slide 21
- maggio 2002ASD - Heap21 heap e code di priorit una coda di priorit un tipo astratto con le seguenti operazioni enqueue, inserimento in coda dequeue, estrazione dalla coda dellelemento avente priorit max la priorit in genere espressa da un intero gli heap sono strutture di dati eccellenti per limplementazione di code di priorit
- Slide 22
- maggio 2002ASD - Heap22 Heapsort/1 Ordinamento di un insieme di n interi Costruisci lHeap inserendo gli elementi nellHeap con insert. Complessit: O(n log n) Applica ripetutuamente deleteMax Complessit: O(n log n)
- Slide 23
- maggio 2002ASD - Heap23 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); }
- Slide 24
- maggio 2002ASD - Heap24 Costruzione di un Heap in O(n)/1 1.Disponi linsieme di elementi in un array 2.For (i= indice ultimo nodo non foglia; i>=0, i--) 3.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; }
- Slide 25
- maggio 2002ASD - Heap25
- Slide 26
- maggio 2002ASD - Heap26 Costruzione di un Heap in O(n)/2 Assumi n=2 k -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)/2 i di livello k-i-1. Heapify su nodo di livello k-i-1 provoca al pi i-1 scambi
- Slide 27
- maggio 2002ASD - Heap27 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)/2 i nodi i-1 scambi compiuti da Heapify
Related Documents
