Soluzione: Algoritmo Heap-Sort Un array A[1..n] può essere interpretato come un albero binario: A[1] è la radice, A[2i] e A[2i+1] sono i figli di A[i]

Presentazione sul tema: "Soluzione: Algoritmo Heap-Sort Un array A[1..n] può essere interpretato come un albero binario: A[1] è la radice, A[2i] e A[2i+1] sono i figli di A[i]"— Transcript della presentazione:

1 Soluzione: Algoritmo Heap-Sort Un array A[1..n] può essere interpretato come un albero binario: A[1] è la radice, A[2i] e A[2i+1] sono i figli di A[i] A[  i / 2  ] è il padre di A[i]

2 a 10 a 11 a9a9 a 12 a2a2 a8a8 a4a4 a5a5 a6a6 a7a7 a3a3 a1a1 a1a1 a2a2 a3a3 a4a4 a5a5 a6a6 a7a7 a8a8 a9a9 a 10 a 11 100 2 1212 10 2 11 2 101 2 1 2 3 4 5 6 7 8 9 10 11 12 1100 2 110 2 111 2 1000 2 1001 2 1010 2 1011 2 Albero binario quasi completo

3 “A[i] è maggiore o uguale di ogni suo discendente in A[1..n]” Proprietà di un heap (mucchio) Diciamo che A[1..n] è un (è ordinato a) max-heap se ogni elemento A[i] soddisfa la seguente proprietà: Per brevità indicheremo questa proprietà con H(i)

4 6132 8 4 5740 7 9982757404361 4 1 23 5 1 2 3 4 5 6 7 8 9 10 11 12 12 67 891011 Un max-heap

5 7134 6 4 8927 0 5 564089274371 4 1 23 5 1 2 3 4 5 6 7 8 9 10 11 12 12 67 891011 2 2 4 2 24 2 9 92 98 89 8 0 08 7 0 07 0 6 60 9 6 69 7 6 67 6 5 56 9 5 59 8 5 58 5 5 Costruzione di un max-heap

6 6132 8 4 5740 7 9 982757404361 4 1 23 5 1 2 3 4 5 6 7 8 9 10 11 12 12 67 891011 29 28 2 82 2 7 72 6 2 62 2 2 1 18 1 7 17 1 6 16 1 2 12 1 1 1 71 7 1 71 1 4 41 1 173 36 3 36 3 5 53 4 3 43 3 363 35 3 53 4 3 43 3 3 Ordinamento dell’array

7 Max-Heapfy(A,i) l = 2i, r =2i+1 m = i if l  A.heapsize and A[l] > A[m] m = l if r  A.heapsize and A[r] > A[m] m = r if m  i t = A[i], A[i] = A[m], A[m] = t Max-Heapfy(A,m)

8 Build-Max-Heap (A) A.heapsize = A.length for i =  A.lenght/2  downto 1 Max-Heapfy(A,i)

9 Heap-Sort (A) Build-Max-Heap(A) for i = A.length downto 2 t = A[i], A[i] = A[1], A[1] = t A.heapsize = A.heapsize - 1 Max-Heapfy(A,1)

10 Abbiamo visto che la complessità nel caso pessimo di ogni algoritmo di ordinamento sul posto che confronta e scambia tra loro elementi consecutivi dell’array è  (n 2 ). Per ottenere algoritmi più efficienti dobbiamo quindi operare confronti e scambi tra elementi “distanti” dell’array. L’algoritmo Heap-Sort confronta elementi non consecutivi e possiamo quindi sperare che la sua complessità sia minore.

11 In effetti Heap-Sort richiede tempo O(n log n) per ordinare un array di n elementi (vedi Libro 6.2, 6.3, 6.4)

12 Implementazione di code con priorità Gli heap binari si possono usare, oltre che per ordinare un array, anche per implementare delle code con priorità. Le code con priorità sono delle strutture dati in cui è possibile immagazzinare degli oggetti x a cui è attribuita una priorità x.key ed estrarli uno alla volta in ordine di priorità.

13 Possono inoltre essere definite anche: Increase-Key(S,x,p): aumenta la priorità di x Change-Key(S,x,p): cambia la priorità di x Le operazioni fondamentali sulle code con priorità sono: Insert(S, x): aggiunge x alla coda S Maximum(S): ritorna x  S con x.key massima Extract-Max(S): toglie e ritorna x  S con x.key massima.

14 Heap-Maximum(A) // A è un max-heap if A.heapsize < 1 error “underflow” else return A[1] Heap-Extract-Max(A) // A è un max-heap if A.heapsize < 1 error “underflow” else max = A[1] A[1] = A[A.heapsize] A.heapsize = A.heapsize - 1 Max-Heapfy(A,1) return max

15 12 13 12 1 2 3 4 5 6 7 8 9 10 11 12 13 6132 8 4 5740 7 9 4 1 23 5 12 67 891011 Heap-Insert 982757404361 12 4 4 7 7 9 9

16 “A[i] è maggiore o uguale di ogni suo discendente” usa la proprietà simmetrica: Per realizzare Heap-Insert e Heap-Increase-Key ci serve una Max-Heapfy diversa che invece della proprietà: “A[i] è minore o uguale di ogni suo ascendente” entrambe, se vere per ogni elemento dell’array, ci assicurano l’ordinamento a max-heap di A.

17 Max-HeapfyR(A,i) // solo A[i] può non soddisfare la proprietà while i >1 and A[ ⌊ i/2 ⌋ ].key < A[i].key scambia A[ ⌊ i/2 ⌋ ] con A[i] // solo A[ ⌊ i/2 ⌋ ] può non soddisfarla i = ⌊ i/2 ⌋ La nuova versione Max-HeapfyR ricostruisce lo heap quando tutti gli elementi dell’array sono minori o uguali dei loro ascendenti tranne al più quello in posizione i.

18 Heap-Increase-Key(A,i,p) // A max-heap if p < A[i].key error “la nuova priorità è minore” else A[i].key = p Max-HeapfyR(A,i) Max-Heap-Insert(A,x) // A max-heap A.heapsize = A.heapsize+1 A[A.heapsize] = x Max-HeapfyR(A,A.heapsize)

19 Heap-Change-Key(A,i,p) // A max-heap if p < A[i].key A[i].key = p Max-Heapfy(A,i) else A[i].key = p Max-HeapfyR(A,i) Possiamo facilmente realizzare anche una Heap-Change-Key nel modo seguente: