La presentazione è in caricamento. Aspetta per favore

La presentazione è in caricamento. Aspetta per favore

1/32 heap binomiali. 2/32 Heap binomiale Una heap binomiale è un insieme di alberi binomiali. Un albero binomiale B k è un albero ordinato definito ricorsivamente.

Presentazioni simili


Presentazione sul tema: "1/32 heap binomiali. 2/32 Heap binomiale Una heap binomiale è un insieme di alberi binomiali. Un albero binomiale B k è un albero ordinato definito ricorsivamente."— Transcript della presentazione:

1 1/32 heap binomiali

2 2/32 Heap binomiale Una heap binomiale è un insieme di alberi binomiali. Un albero binomiale B k è un albero ordinato definito ricorsivamente per cui valgono le seguenti proprietà: I nodi dellalbero sono 2 k Laltezza dellalbero è k I nodi a profondità i sono esattamente, con i=0, 1,..., k La radice dellalbero 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 B i.

3 3/32 Alberi Binomiali: esempi B0B0 BkBk B k-1

4 4/32 Alberi Binomiali: esempi B0B0 B2B2 B1B1 B3B3

5 5/32 Alberi Binomiali: esempi B4B4

6 6/32 Alberi Binomiali: esempi BkBk B k-1 B k-2 B2B2 B1B1 B0B0

7 7/32 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 8/32 Heap Binomiali - Esempio head[H]

9 9/32 Heap Binomiali - Esempio head[H] p key deg child sibling

10 10/32 Heap Binomiali - Min 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 Ricerca della chiave minima input: una heap binomiale H con n nodi output: puntatore al nodo con chiave minima (è in una radice!)

11 11/32 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 12/32 Binomial-Heap-Union 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 Sibling[P] = P1; P1 = Sibling[P1] while P2 NIL do Sibling[P] = P2; P2 = Sibling[P2] Unisce H1 e H2, distruggendole.

13 13/32 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 elseif key[x] key[next_x] then sibling[x] = sibling[next_x]; Binomial-Link(next_x,x) elseif 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 14/32 Heap binomiale - Unione - Esempio H1H1 H2H2 head[H 1 ] head[H 2 ]

15 15/32 Heap Binomiali - Unione - esempio H 1 H 2 head[H]

16 16/32 Heap Binomiali - Unione - esempio H 1 H 2 head[H 1 ]

17 17/32 Heap Binomiali - Unione - Esempio H 1 H 2 head[H 1 ]

18 18/32 Heap Binomiali - Unione - Esempio H 1 H 2 head[H 1 ]

19 19/32 Heap Binomiali - Inserimento 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) Inserisce un nodo in una heap binomiale

20 20/32 Heap Binomiali - ExtractMin 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…) Elimina da una heap binomiale H il nodo con chiave minima e restituisce il puntatore a quel nodo

21 21/32 Heap Binomiali - ExtractMin (cont.) (… 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 22/32 Heap Binomiali - ExtractMin - Esempio head[H]

23 23/32 Heap Binomiali - ExtractMin - Esempio head[H] x

24 24/32 Heap Binomiali - ExtractMin - Esempio head[H] head[H]

25 25/32 Heap Binomiali - ExtractMin - Esempio head[H]

26 26/32 Heap Binomiali - ExtractMin - Esempio head[H]

27 27/32 Decremento di una chiave 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] Si assegna un nuovo valore k alla chiave di un nodo x di una heap binomiale H. Errore se k > key[x]

28 28/32 Decremento di una chiave - Esempio head[H] z y

29 29/32 Decremento di una chiave - Esempio head[H] z y

30 30/32 Decremento di una chiave - Esempio head[H] z y

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

32 32/32 Heap Binomiali - Sommario heap binomialiheap Min (log n) or (1) (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)


Scaricare ppt "1/32 heap binomiali. 2/32 Heap binomiale Una heap binomiale è un insieme di alberi binomiali. Un albero binomiale B k è un albero ordinato definito ricorsivamente."

Presentazioni simili


Annunci Google