1 / 17

Code a priorità (Heap)

Code a priorità (Heap). Definizione Heapify (mantenimento coda a priorità) Costruire un Heap Insert, Maximum e Extract-Max. Coda a priorità (Heap). Una coda a priorità può essere rappresentato da un albero binario completo.

francesca
Download Presentation

Code a priorità (Heap)

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. Code a priorità (Heap) Definizione Heapify (mantenimento coda a priorità) Costruire un Heap Insert, Maximum e Extract-Max

  2. Coda a priorità (Heap) • Una coda a priorità può essere rappresentato da un albero binario completo. • La chiave del padre è sempre maggiore di quella dei figli: key(i) ≤ key(parent(i)) . Albero binario completo: Sono riempiti tutti i livelli eccetto possibilmente l’ultimo. Altezza=Θ(log(n)) Coda a priorità: Il nodo a maggiore priorità (con la chiave più grande) sta in cima. Nota: si può ragionare in maniera analoga quando si pone che key(i) ≥ key(parent(i)). 16 10 14 8 7 9 3 2 4 1

  3. Heap tramite un Array • Una coda a priorità può essere implementato tramite un’array (A). A[PARENT(i)] ≥ A[i]. 1 16 3 2 10 PARENT(j) • return 14 4 5 7 6 8 7 9 3 LEFT(i) • return 2i 8 9 10 2 4 1 RIGHT(i) • return 2i+1 length[A] heap-size[A] n 1 2 3 4 5 6 7 8 9 10 A … 7 14 10 8 9 3 2 16 4 1

  4. Heapify (mantenimento coda a priorità) • Si sistema l’elemento A[i]: si suppone gli alberi con radice LEFT(i) e RIGHT(i) siano degli Heap. A[i] LEFT[i] RIGHT[i] HEAP HEAP

  5. Heapify (mantenimento coda a priorità) • Si sistema l’elemento A[i]: si suppone gli alberi con radice LEFT(i) e RIGHT(i) siano degli Heap. HEAPIFY(A,i) // sistema A[i] nel Heap • l ← LEFT(i) // figlio sx • r ← RIGHT(i) // figlio dx • if l ≤ heap-size[A] and A[l] > A[i] // cerca il maggiore fra padre e • then magg ← l // i due figli (se ci sono…) • else magg ← i • if r ≤ heap-size[A] and A[r] > A[magg] • then magg ← r • if magg ≠ i // il magg è uno dei due figli… • then scambia A[i] ↔ A[magg] • HEAPIFY(A,magg)

  6. Esempio Heapify • All’inizio si chiama HEAPIFY(A,2) 1 1 16 16 3 3 2 2 10 10 14 i 4 4 5 7 6 4 5 7 6 i 4 7 9 3 14 7 9 3 8 9 10 8 9 10 2 8 1 2 8 1

  7. Esempio Heapify • Il costo in termine di tempo è nel caso peggio l’altezza dell’albero. O(h) = O(log(n)) 1 16 3 2 10 14 4 5 7 6 8 7 9 3 i 8 9 10 2 4 1

  8. Costruire l’Heap BUILD-HEAP(A) // strategia bottom-up: dal basso verso l’alto • heap-size[A] ← length[A] // • for i ← length[A]/2 downto 1 // dalla metà in su • do HEAPIFY(A,i) // sotto la metà sono tutte foglie • Il costo di HEAPIFY è O(log(n)) e viene chiamato O(n) volte. Quindi un limite del caso peggiore è O(n log(n)). • In realtà, il caso peggiore può essere stimato come O(n). =2 Rappresenta il massimo numero di sottoalberi pieni ad altezza h (avendo a disposizione n elementi)

  9. Esempio costruzione Heap 6 7 8 9 10 1 2 3 4 5 A 3 2 9 10 14 16 8 7 1 4 Foglie Si comincia da qua 1 1 4 4 3 3 2 2 3 3 1 1 4 5 7 6 4 5 7 6 i 2 16 9 10 i 2 16 9 10 8 9 10 8 9 10 14 8 7 14 8 7

  10. Esempio costruzione Heap Strategia button-up: dal basso verso l’alto si chiama HEAPIFY su tutte i nodi interni. 1 1 4 4 3 3 2 2 10 i i 3 1 1 4 5 7 6 4 5 7 6 14 16 9 3 14 16 9 10 8 9 10 8 9 10 2 8 7 2 8 7

  11. Esempio costruzione Heap Strategia button-up: dal basso verso l’alto si chiama HEAPIFY su tutte i nodi interni. 1 1 i 16 4 3 3 2 2 10 3 14 16 4 5 7 6 4 5 7 6 8 7 9 3 14 7 9 10 8 9 10 8 9 10 2 4 1 2 8 1

  12. Altre operazioni • MAXIMUM(A): ritorna l’elemento a massima priorità, ossia quello in cima. • EXTRACT-MAX(A): estrae l’elemento a massima priorità, successivamente l’Heap andrebbe sistemato • INSERT(A): inserisce un nuovo elemento nel Heap.

  13. MAXIMUM e EXTRACT-MAX MAXIMUM(A) ha un tempo di esecuzione costante, O(1) MAXIMUM(A) // restituisci l’elem. a magg. priorità, • return A[1] // ossia quello in cima EXTRACT-MAX(A) ha un tempo di esecuzione O(log(n)),dovuto alla chiamata HEAPIFY(). EXTRACT-MAX(A) // Estrae elemento a maggiore priorità • ifheap-size[A] < 1 // heap vuoto? • then error “heap underflow” • max← A[1] // memorizza elem. In cima • A[1]← A[heap-size[A]] // metti l’ultimo elemento in cima • heap-size[A]← heap-size[A] – 1 // heap diminuisce di 1 elem. • HEAPIFY(A,1) // HEAPIFY sul 1° elem. • return max // restituisci l’elem. a magg. priorità

  14. HEAP-INSERT HEAP-INSERT(A, KEY) ha un tempo di esecuzione O(log(n)),nel caso peggiore si risale l’albero dalla foglia alla radice. HEAP-INSERT(A, key) // Inserisci elemento nell’Heap • heap-size[A]← heap-size[A] + 1 // aumenta Heap di 1 elemento • i← heap-size[A] // inizia dall’elem. inserito (ultimo) • while i > 1 and A[PARENT(i)]<key // il nuovo elem. Viene fatto • do A[i] ← A[PARENT(i)] // risalire… • i← PARENT(i) • A[i] ← key // fino a trovare il suo posto

  15. Inserimento in un Heap HEAP-INSERT(A, 15) key=15 L’Heap viene aumentato di un elemento. Si procede poi a risalire l’albero per trovare il suo posto. 1 1 16 16 3 3 2 2 10 3 14 14 4 5 7 6 4 5 7 6 i 8 7 9 3 8 7 9 10 11 8 9 10 8 9 11 10 7 2 4 1 i 2 4 1 8 Nuovo elemento key = 15

  16. Inserimento in un Heap HEAP-INSERT(A, 15) key=15 L’Heap viene aumentato di un elemento. Si procede poi a risalire l’albero per trovare il suo posto. 1 1 16 16 3 3 2 2 10 3 15 i 14 4 5 7 6 4 5 7 6 8 14 9 3 8 14 9 10 11 8 9 10 8 9 11 10 7 2 4 1 2 4 1 7

  17. Considerazioni • La struttura dati Heap gestisce una coda a priorità. • Viene estratto l’elemento a maggiore priorità (es. quello con chiave maggiore) • Si può invertire la relazione con il padre, se key(i) ≥ key(parent(i)). • In questo caso l’elemento a maggiore priorità è l’elemento più piccolo • Heap-sort: algoritmo di ordinamento che usa un Heap. Si estrae ogni volta l’elemento più piccolo fino ad ottenere un vettore ordinato. Tempo O(n log(n)).

More Related