heap binomiali Heap binomiale Una heap binomiale un

heap binomiali

Heap binomiale Una heap binomiale è un insieme di alberi binomiali. Un albero binomiale Bk è un albero ordinato definito ricorsivamente per cui valgono le seguenti proprietà: • I nodi dell’albero sono 2 k • L’altezza dell’albero è k • I nodi a profondità i sono esattamente con i=0, 1, . . . , k , • La radice dell’albero ha grado k. Il grado della radice è maggiore del grado di ogni altro nodo. Enumerando con k-1, k 2, . . . , 0 i figli della radice, il figlio numero i è la radice del sottoalbero binomiale Bi.

Alberi Binomiali: esempi B 0 Bk-1 Bk

Alberi Binomiali: esempi B 0 B 1 B 2 B 3

Alberi Binomiali: esempi B 4

Alberi Binomiali: esempi Bk-1 B 0 B 2 Bk-2 Bk B 1

Heap Binomiali - Definizione Una heap binomiale H è un insieme di alberi binomiali che soddisfa le seguenti proprietà: • Ogni albero binomiale è ordinato come una heap, cioè per ogni nodo si ha che la sua chiave è maggiore o uguale della chiave del padre • Non esistono due alberi binomiali in H le cui radici hanno lo stesso grado

Heap Binomiali - Esempio head[H] 10 1 12 18 6 25 11 27 8 14 17 38 29

Heap Binomiali - Esempio head[H] 10 0 12 1 p key deg child sibling 18 0 6 1 2 2 14 1 17 0 38 0 8 25 0 11 1 27 0 3 29 0

Heap Binomiali - Min Ricerca della chiave minima input: una heap binomiale H con n nodi output: puntatore al nodo con chiave minima (è in una radice!) Binomial-Heap-Minimum(H): y=NIL x=head[H] min = while x NIL do if key[x] < min then min = key[x]; y=x x = sibling[x] return y

Unione Collega tutti gli alberi binomiali le cui radici hanno lo stesso grado. Subroutine Binomial-Link(y, z) che collega gli alberi bonomiali y e z le cui radici hanno lo stesso grado: z diventa padre di y. Binomial-Link(y, z) p[y] = z sibling[y] = child[z] = y degree[z] = degree[z]+1

Binomial-Heap-Union Unisce H 1 e H 2, distruggendole. Binomial-Heap-Union(H 1, H 2): H = Make-Binomial-Heap() P = Head[H]; P 1 = Head[H 1]; P 2 = Head[H 2] while P 1 NIL and P 2 NIL do if Deg[P 1] < Deg[P 2] then Sibling[P] = P 1; P 1 = Sibling[P 1] else Sibling[P] = P 2; P 2 = Sibling[P 2] while P 1 NIL do Sibling[P] = P 1; P 1 = Sibling[P 1] while P 2 NIL do Sibling[P] = P 2; P 2 = Sibling[P 2]

Binomial-Heap-Union (cont. ) prev_x=NIL; x = head[H]; next_x = sibling[x] while next_x ≠ NIL do if deg[x] ≠ deg[next_x] or (sibling[next_x] ≠ NIL and deg[sibling[next_x]] == deg[x]) then prev_x = x; x = next_x else if key[x] ≤ key[next_x] then sibling[x] = sibling[next_x]; Binomial-Link(next_x, x) else if prev_x == NIL then head[H] = next_x else sibling[prev_x] = next_x Binomial. Link(x, next_x) x = next_x = sibling[x] return H

Heap binomiale - Unione - Esempio head[H 2] 18 H 2 head[H 1] H 1 12 7 3 6 37 15 25 28 33 41 8 29 10 44 30 23 22 48 31 17 45 32 24 55 50

Heap Binomiali - Unione - esempio head[H] 12 18 H 1 H 2 7 3 15 25 37 28 33 41 6 8 29 10 44 30 23 22 48 31 17 45 32 24 55 50

Heap Binomiali - Unione - esempio head[H 1] 12 H 1 H 2 7 3 15 18 25 37 28 33 41 6 8 29 10 44 30 23 22 48 31 17 45 32 24 55 50

Heap Binomiali - Unione - Esempio head[H 1] H 1 H 2 12 18 7 25 3 15 37 28 33 41 6 8 29 10 44 30 23 22 48 31 17 45 32 24 55 50

Heap Binomiali - Unione - Esempio head[H 1] H 1 H 2 12 6 3 18 15 7 28 33 25 41 8 37 29 10 44 30 23 22 48 31 17 45 32 24 55 50

Heap Binomiali - Inserimento Inserisce un nodo in una heap binomiale Binomial-Heap-Insert(H, x): H’ = Make-Binomial-Heap() p[x] = NIL child[x] = NIL sibling[x] = NIL deg[x] = 0 Head[H’] = x H = Binomial-Heap-Union(H, H’)

Heap Binomiali - Extract. Min Elimina da una heap binomiale H il nodo con chiave minima e restituisce il puntatore a quel nodo Binomial-Heap-Extract-Min(H): min = ; Min. Key = NIL; MKP = NIL P = Head[H]; PP = Head[H] while P NIL do if key[P] < min then min = Key[P]; Min. Key = P; MKP = PP PP = P; P = Sibling[P] if Min. Key == 0 then return fail (cont…)

Heap Binomiali - Extract. Min (cont. ) (… cont) H 1 = Make-Binomial-Heap() if MKP head[H] then sibling[MP] = sibling[Min. Key] else head[H] = sibling[Min. Key] P = left[Min. Key] while P 0 do S = sibling[P] = head[H 1] = P p[P] = 0 P = S H = Binomial-Heap-Union(H, H 1)

Heap Binomiali - Extract. Min Esempio head[H] 37 10 41 28 13 1 6 77 8 14 29 26 23 18 11 17 38 27 16 12 25 42

Heap Binomiali - Extract. Min Esempio head[H] x 37 10 41 28 13 1 6 77 8 14 29 26 23 18 11 17 38 27 16 12 25 42

Heap Binomiali - Extract. Min Esempio head[H] head[H’] 37 10 41 28 13 77 25 12 16 18 26 23 42 6 8 14 29 11 17 38 27

Heap Binomiali - Extract. Min Esempio head[H] 25 37 12 10 16 41 18 28 13 26 23 77 42 6 8 14 29 11 17 38 27

Heap Binomiali - Extract. Min Esempio head[H] 12 25 37 6 18 10 41 16 26 23 42 8 14 29 28 13 11 17 38 77 27

Decremento di una chiave Si assegna un nuovo valore k alla chiave di un nodo x di una heap binomiale H. Errore se k > key[x] Binomial-Heap-Decrease-Key(H, x, k) if k>key[x] then error key[x]=k, y=x; z=p[x] while z NIL and key[y] < key[z] do key[y] key[z] y = z z = p[y]

Decremento di una chiave Esempio head[H] 12 25 6 18 37 41 y 10 8 14 29 z 16 28 13 11 17 38 7 23 77 27 42

Decremento di una chiave Esempio head[H] 12 25 37 41 6 z 18 y 7 16 23 42 10 8 14 29 28 13 11 17 38 77 27

Decremento di una chiave Esempio head[H] 12 25 37 6 y 18 41 10 16 23 42 7 8 14 29 28 13 11 17 38 77 27 z

Eliminazione di una chiave Elimina un nodo x da uno heap binomiale H Binomial-Heap-Delete(H, x): Binomial-Heap-Decrease-Key(H, x, ) Binomial-Heap-Extract-Min(H)

Heap Binomiali - Sommario heap binomiali heap Min (log n) (1) Extract-Min (log n) Decrease-Key (log n) Union (log n) (n) Insert (log n) Delete (log n) Make-Empty (1) Is-Empty (1)