heap concetti ed applicazioni maggio 2002 ASD Heap

heap concetti ed applicazioni maggio 2002 ASD - Heap

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 maggio 2002 ASD - Heap 2

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

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 maggio 2002 6 13 13 22 23 44 27 23 32 33 24 56 81 ASD - Heap min-heap 4

operazioni su un (max-)heap • insert chiave – inserisce nuova chiave nello heap • occorre mantenere la condizione di heap • delete. Max – cancella chiave max dallo heap • occorre mantenere la condizione di heap • get. Max – restituisce la chiave max nello heap • non modifica lo heap maggio 2002 ASD - Heap 5

rappresentazione degli heap • 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)=2 p(u)+1 – se v è il figlio destro di u allora p(v)=2 p(u)+2 89 67 66 maggio 2002 1 68 65 43 21 66 5 4 64 67 89 67 68 66 65 66 67 1 43 21 5 4 64 0 1 2 3 4 5 6 7 8 9 10 11 12

heap su array • vantaggi – grande efficienza in termini di spazio • l’occupazione può essere minima – facilità di navigazione • genitore i -> figli j – j = 2 i + 1, 2 i + 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 8

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 is. Leaf(int i) { return get. Left. Index(i) >= size; } public boolean is. Root(int i) { return i == 0; } public boolean is. Empty() { return size == 0; } public boolean is. Full() { return size == storage. length; } maggio 2002 ASD - Heap 10

rappresentazione in Java/3 private int get. Left. Index(int i) { return 2 * i + 1; } private int get. Right. Index(int i) { return get. Left. Index(i) + 1; } private int get. Parent. Index(int i) { return (i - 1) / 2; } public String to. String() {…} // implementazione delle operazioni fondamentali } maggio 2002 ASD - Heap 11

algoritmi su heap • operazioni – get. Max – insert – delete. Max • altri algoritmi – Array 2 Heap • conversione di un array in heap – Heap. Sort • ordinamento di un array basato su heap maggio 2002 ASD - Heap 12

get. Max • il max è contenuto nella cella 0 dell’array • operazione di costo costante O(1) public int get. Max() throws Exception { if(!is. Empty()) return storage[0]; else throw new Exception("get. Max 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 maggio 2002 ASD - Heap 15

insert/3 Algorithm insert(int k) { storage[size] = k; int i = size++; int j = get. Parent. Index(i); while(!is. Root(i) && (storage[i] > storage[j])) { exchange(i, j); // scambia celle di storage i = j; j = get. Parent. Index(i); } } maggio 2002 ASD - Heap 16

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(is. Leaf(i)) return; else { int j = 0; // inizializzazione fittizia per tacitare compilatore try { j = get. Max. Child. Index(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

delete. Max 1 1. sostituisci primo elemento con ultima foglia ed elimina ultima foglia 1. Invoca Heapify sulla radice maggio 2002 ASD - Heap 19

delete. Max/2 maggio 2002 ASD - Heap 20

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à maggio 2002 ASD - Heap 21

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 delete. Max Complessità: O(n log n) maggio 2002 ASD - Heap 22

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

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

maggio 2002 ASD - Heap 25

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 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 maggio 2002 ASD - Heap 27