heap heap heap? max- e min-heap concetti ed applicazioni heap = catasta condizione di heap non è una struttura ordinata

Transcript

1 heap heap concetti ed applicazioni 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 maggio 2002 ASD - Heap 2 heap? maggio 2002 ASD - Heap 3 la struttura definita è detta max-heap max- e min-heap variante: min-heap ogni nodo contiene una chiave minore o eguale di quelle presenti negli eventuali figli maggio 2002 ASD - Heap min-heap

2 operazioni su un (max-)heap rappresentazione degli 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 maggio 2002 ASD - Heap 5 tutte le rappresentazione usate per gli alberi binarie sono ammissibili rappresentazione collegata, eventualmente con puntatori figligenitore rappresentazione tramite array particolarmente efficiente maggio 2002 ASD - Heap 6 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 maggio vantaggi heap su array 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 svantaggio j = (i 1) / 2 implementazione statica possono essere necessari progressivi raddoppiamenti/dimezzamenti dell array di supporto 12 maggio 2002 ASD - Heap 8

3 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 9 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; maggio 2002 ASD - Heap 10 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 operazioni getmax insert deletemax altri algoritmi Array2Heap algoritmi su heap conversione di un array in heap HeapSort ordinamento di un array basato su heap maggio 2002 ASD - Heap 11 maggio 2002 ASD - Heap 12

4 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 13 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 14 insert/2 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 15 maggio 2002 ASD - Heap 16

5 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 17 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 18 deletemax 1 deletemax/2 1. sostituisci primo elemento con ultima foglia ed elimina ultima foglia 1. Invoca Heapify sulla radice maggio 2002 ASD - Heap 19 maggio 2002 ASD - Heap 20

6 heap e code di priorità Heapsort/1 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 Ordinamento di un insieme di n interi Costruisci l Heap inserendo gli elementi nell Heap con insert. Complessità: O(n log n) gli heap sono strutture di dati Applica ripetutuamente deletemax eccellenti per l implementazione di Complessità: O(n log n) maggio 2002 ASD - Heap 21 maggio 2002 ASD - Heap 22 code di priorità 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); Costruzione di un Heap in O(n)/1 1. Disponi l insieme 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; maggio 2002 ASD - Heap 23 maggio 2002 ASD - Heap 24

7 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 maggio 2002 ASD - Heap 25 maggio 2002 ASD - Heap 26 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 lg( n+ 1) ( n + 1) lg( n+ 1) i! 1 " ( i! 1) = ( n + 1) " = O( n) i i i= 2 2 i= 2 2 maggio 2002 ASD - Heap 27