Heap concetti ed applicazioni. maggio 2002ASD - Heap2 heap heap = catasta condizione di heap 1.albero binario perfettamente bilanciato 2.tutte le foglie.

heap

concetti ed applicazioni

maggio 2002 ASD - Heap 2

heap

• heap = catasta• condizione di heap

1. albero binario perfettamente bilanciato2. 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


heap?

67 68

89

661

66 65

66 5

66 67

4 64

67 68

89

21

66 65

3 4

66

5 6

67

6767

67 67

67 67

89

67

1

66 65


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

3223

13 23

33 24

44 27

56 81

min-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

• occorre mantenere la condizione di heap

• getMax– restituisce la chiave max nello heap

• non modifica lo 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

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

67 68

89

431

66 65

21 5

66 67

4 64

6566671432154

66686789

64

4

5

6

7

8

9

10

11

3

2

1

0

12


heap su array• vantaggi

– 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


rappresentazione in Javapublic 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…


rappresentazione in Java/2public 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;

}


rappresentazione in Java/3private 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}


algoritmi su heap

• operazioni– getMax– insert – deleteMax

• altri algoritmi– Array2Heap

• conversione di un array in heap

– HeapSort• ordinamento di un array basato su 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");}


insert

1. inserisci elemento alla fine dello heap

2. while (elemento non è radice) and (elemento > genitore(elemento))

3. scambia elemento con genitore


insert/2


insert/3Algorithm 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

storagei = j;j = getParentIndex(i);

}}


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


Heapifypublic void heapify(int i) {

if(isLeaf(i))return;

else {int j = 0; // inizializzazione

fittizia per tacitare compilatoretry {

j = getMaxChildIndex(i);}catch(Exception e) {

// only if i is a leaf.... already checked

}if(storage[i] < storage[j])

exchange(i, j);heapify(j);

} }


deleteMax 1

1. sostituisci primo elemento con ultima foglia ed elimina ultima foglia

1. Invoca Heapify sulla radice


deleteMax/2


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à


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)


Heapsort/2public 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)/11. Disponi l’insieme di elementi in un array2. 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;

}



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


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

)(2

1)1()1(

2

)1()1lg(

2

)1lg(

2

nOi

ninn

i

n

iii

Heap concetti ed applicazioni. maggio 2002ASD - Heap2 heap heap = catasta condizione di heap 1.albero binario perfettamente bilanciato 2.tutte le foglie.

Documents