Heap binomiali.

Presentazione sul tema: "Heap binomiali."— Transcript della presentazione:

1 heap binomiali

2 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 2k 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, ..., o i figli della radice, il figlio numero i è la radice del sottoalbero binomiale Bi.

3 Alberi Binomiali: esempi
Bk-1 Bk-1 Bk

4 Alberi Binomiali: esempi

5 Alberi Binomiali: esempi

6 Alberi Binomiali: esempi
 B0 B1 B2 Bk-2 Bk-1 Bk

7 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 alla chiave dei suoi genitori Non esistono due alberi binomiali in H le cui radici hanno lo stesso grado

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

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

10 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

11 Unione Collega tutti gli alberi binomiali le cui radici hanno lo stesso grado. Subroutine Binomial-Link(y,z) che collega gli alberi binomiali 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] child[z] = y degree[z] = degree[z]+1

12 Binomial-Heap-Union Unisce H1 e H2, distruggendole.
Binomial-Heap-Union(H1,H2): H = Make-Binomial-Heap() P = Head[H]; P1 = Head[H1]; P2 = Head[H2] while P1  NIL and P2  NIL do if Deg[P1] < Deg[P2] then Sibling[P] = P1; P1 = Sibling[P1] else Sibling[P] = P2; P2 = Sibling[P2] while P1  NIL do while P2  NIL do

13 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 BinomialLink(x,next_x) x = next_x next_x = sibling[x] return H

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

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

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

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

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

19 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’)

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

21 Heap Binomiali - ExtractMin (cont.)
H1 = Make-Binomial-Heap() if MKP  head[H] then sibling[MKP] = sibling[MinKey] else head[H] = sibling[MinKey] P = left[MinKey] while P  0 do S = sibling[P] sibling[P] = head[H1] head[H1] = P p[P] = 0 P = S H = Binomial-Heap-Union(H,H1)

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

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

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

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

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

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]

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

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

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

31 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)

32 Heap Binomiali - Sommario
Min (log n) or (1) (1) Extract-Min (log n) Decrease-Key Union (n) Insert Delete Make-Empty Is-Empty