Upload
others
View
0
Download
0
Embed Size (px)
Citation preview
Binomial Heaps
Manoj Kumar
DTU, Delhi
Binomial Heaps
• Known as mergeable heaps.
• Supports following five operations:
1. MAKE-HEAP(): creates and returns a new heap with
no elements.
2. INSERT(H, x): Inserts node x, into heap H.2. INSERT(H, x): Inserts node x, into heap H.
3. MINIMUM(H): returns a pointer to the node in heap H
whose key is minimum.
4. EXTRACT-MIN(H): deletes the node from heap H
whose key is minimum, returning pointer o the node.
5. UNION(H1,H2): creates and returns new heap that
contains all the elements of heaps H1 and H2. H1 and
H2 are destroyed in this process.
Binomial Heaps: Definitions
Binomial Heap: Collection of binomial trees
(satisfying some properties).
Binomial Trees
• Definition is inductive.
• These are ordered trees, i.e., order of children is
important.
1
32
1
23Different Trees
54 54
Binomial Trees
• Base Case: B0 = single node is a binomial tree.
• Inductive Step:
BBk = is a binomial tree.Bk-1
Bk-1
ExamplesB0
B1
B2
B3
B4
depth # nodes
0 1
1 4
2 6
3 4
4 1
Another Way to Look at Bk
L
BB0
Bk-1
Bk-2
B2
B1
Bk
Properties of Binomial Trees
Lemma 1: For the binomial tree Bk,
1. There are 2k nodes.
2. Tree height is k.
3. nodes at depth i, i = 0, 1, …, k [binomial coefficients].
i
k3. nodes at depth i, i = 0, 1, …, k [binomial coefficients].
4. Root has degree k, other nodes have smaller degree. ith
child of root is root of subtree Bi, where i = k–1, k–2, …,
0 [Bk–1 is Left Most, B0 is Right Most].
i
Proof: Inductive
1. Binomial tree Bk consists of two copies of Bk-1, so
Bk has 2k-1 + 2k-1 = 2k nodes.
2. The way in which two copies of are connected,
height of Bk is one greater than height of Bk-1. So the
height of B is (k-1)+1= k.height of Bk is (k-1)+1= k.
Bk-1
Bk-1
Bk
Proof: Inductive
3. Let D(k,i) be the number of nodes at depth I of binomial tree
Bk. Since Bk is composed of two copies of Bk-1 linked
together, a node at depth i in Bk-1 appears in Bk once at depth
i and once at depth i+1.
Thus number of nodes in Bk at depth i is the number of nodes at
depth i in Bk-1 plus the number of nodes at depth i-1 in Bk-1. depth i in Bk-1 plus the number of nodes at depth i-1 in Bk-1.
Thus
D(k,i) = D(k-1,i) + D(k-1,i-1)
= + =
i
1-k
1-i
1-k
i
k
Bk-1
Bk-1
Bkdepth i in Bk
depth i in this Bk-1
depth i–1 in this Bk-1
proof
4. Root degree of Bk = 1 + root degree of Bk-1
= 1 + k–1 , induction hypothesis
= k
Corollary : The maximum degree in an n-node binomial tree is lg n.
Binomial Heaps
• Binomial heap H is a set of binomial trees satisfying following
binomial-heap properties:
1 Each binomial tree in H is Heap ordered: the key of a
node is greater than or equal to the key of it’s parent.
iImplies root of a binomial tree has the smallest key in that tree.tree.
2 There is at most one binomial tree in H whose root has a
given degree.
iImplies B.H. with n nodes has at most lg n + 1 B.T.’s.
Think of n in binary: ⟨blg n, …, b0⟩, i.e.,
B.H contains Bi iff bi is 1.
∑=
=
n lg
1i
i
i 2bn
Representing Binomial Heaps
10
25
18
12
1
27
17 3811
29148
6
parentEach node is
head[H]
parent
key
degree
child sibling
Each node isrepresented by astructure like this
10
25
18
12
1
27
17 3811
29148
6head[H]
Operations on Binomial Heaps
MAKE-BINOMIAL-HEAP(): simply allocates and
return an object H, where head[H] = NIL.
Running time is Θ(1)
MAKE-BINOMIAL-HEAP()1. Create new head node H2. head[H]�NIL3. return H
Operations on Binomial Heaps
BINOMIAL-HEAP-MINIMUM(H)1. y � NIL;2. x � head[H];3. min � ∞;4. while x ≠ NIL do5. if key[x] < min then5. if key[x] < min then6. min � key[x];7. y � x8. x � sibling[x]9. return y
Time is O(lg n).
Linking Two Binomial Trees
BINOMIAL-LINK(y,z)1. p[y] � z;2. sibling[y] � child[z];
Linking two binomial trees whose roots have same degree.
2. sibling[y] � child[z];3. child[z] �y;4. degree[z] � degree[z] + 1
Bk-1
Bk-1Bk-1 Bk-1
yy
zz
Link
UNION
UnionH1, H2 H1 ∪ H2
H1 = H2 =
First, simply merge the two root lists by root degree (like merge sort).
Remaining Problem: Can have two trees with the same root degree.
UNION…
prev-x x next-x
Union traverses the new root list like this:
Depending on what x, next-x, and sibling[next-x] point to, Unionlinks trees with the same root degree.
Note: We may temporarily create three trees with the same rootdegree.
UNION…
12
33
41
28
15
25
7head[H1]18
37
3
50
31 1748
441029
6
32 2445
222330
8
head[H2]
Union
37
3
50
31 1748
441029
6
55
32 2445
222330
8
33
41
28
15
25
7
head[H]
18
12
prev-x x
55
Union
UNION:Example
12
33
41
28
15
25
7head[H1] 18
37
3
50
31 1748
441029
6
55
32 2445
222330
8
head[H2]
55
18
37
3
50
31 1748
441029
6
55
32 2445
222330
8
12
33
41
28
15
25
7head[H]
Merge
x next-x
UNION:Example…
18
37
3
50
31 1748
441029
6
32 2445
222330
8
12
33
41
28
15
25
7head[H]x next-x
55
Case 3
37
3
50
31 1748
441029
6
55
32 2445
222330
8
33
41
28
15
25
7head[H]
18
12
x next-x
UNION:Example…
37
3
50
31 1748
441029
6
55
32 2445
222330
8
33
41
28
15
25
7head[H]
18
12
x next-x
Case 255
37
3
50
31 1748
441029
6
55
32 2445
222330
8
33
41
28
15
25
7head[H]
18
12
prev-x x next-x
UNION:Example…
Case 4
37
3
50
31 1748
441029
6
32 2445
222330
8
33
41
28
15
25
7head[H]
18
12
prev-x x next-x
Binomial Heaps - 22
Case 455
37
3
50
31 1748
441029
6
55
32 2445
222330
8
33
41
28
15
25
7
head[H]
18
12
prev-x x next-x
UNION:Example…
37
3
50
31 1748
441029
6
32 2445
222330
8
33
41
28
15
25
7
head[H]
18
12
prev-x x next-x
Case 3 55
37
3
50
31 1748
441029
6
55
32 2445
222330
8
33
41
28
15
25
7
head[H]
18
12
prev-x x next-x
UNION:Example…
37
3
50
31 1748
441029
6
55
32 2445
222330
8
33
41
28
15
25
7
head[H]
18
12
prev-x x next-x
Case 1
37
3
50
31 1748
441029
6
55
32 2445
222330
8
33
41
28
15
25
7
head[H]
18
12
prev-x x next-x = NIL⇒⇒⇒⇒ terminates
55Case 1
Note: Union isO(lg n).
Code for UNIONBINOMIAL-HEAP-UNION(H1, H2)1. H � MAKE-BINOMIAL-HEAP();2. head[H] � BINOMIAL-HEAP-MERGE(H1, H2); /* simple merge of root lists */3. Free the objects H1 and H2, but not the list they point to4. if head[H] = NIL5. then return H 6. prev-x � NIL;7. x � head[H];8. next-x � sibling[x];9. while next-x ≠ NIL9. while next-x ≠ NIL10. do if (degree[x] ≠ degree[next-x]) or
(sibling[next-x] ≠ NIL and degree[sibling[next-x]] = degree[x])11. then prev-x � x;12. x � next-x;13. else if key[x] ≤ key[next-x] 14. then sibling[x] � sibling[next-x];15. BINOMIAL-LINK(next-x, x)16. else if prev-x = NIL 17. then head[H] � next-x 18. else sibling[prev-x] � next-x 19. BINOMIAL-LINK(x, next-x);20. x � next-x21. next-x � sibling[x]22. return H
Cases 1 & 2
Cases 1 & 2
Case 3
Case 3Case 4Case 4
Case 4
Case 4
Case 4
a b c dprev-x x next-x sibling[next-x]
a b c dprev-x x next-x sibling[next-x]
prev-x x next-x sibling[next-x]
BkBkBk
Bk Bl
Case 2
Case 1 a b c dprev-x x next-x
Bk Bl
a b c dprev-x x next-x
BkBkBk
prev-x x next-xa b c d
prev-x x next-x sibling[next-x]
a b c dprev-x x next-x sibling[next-x]
Bk Bk
BkBkBl
Bl
key[x] > key[next[x]]
key[x] ≤≤≤≤ key[next[x]]
Case 3
Case 4
a
c
b dprev-x x next-x
Bk
Bk
Bl
Bk+1
a
b
c d
Bk
Bk
Bl
prev-x x next-x
INSERT
BINOMIAL-HEAP-INSERT(H, x)1. H′ � MAKE-BINOMIAL-HEAP();2. p[x] � NIL;
Inserts node x into binomial heap H, assuming that node x already been allocated and key[x] has already been filled.
parent
key
degree
x
2. p[x] � NIL;3. child[x] � NIL;4. sibling[x] � NIL;5. degree[x] � 0;6. head(H′) � x;7. H �BINOMIAL-HAP-UNION(H, H′)
Time O(lg n).
degree
child sibling
INSERT:Example
12
33
41
28
15
25
7head[H]2head[H’]
12 157head[H] 2
2
33
41
28
15
25
7head[H]
12
33
41
28
15
25
head[H]
INSERT: Example…
7 33
41
28
15
12
2head[H]
25
7
33
41
28
1512
2head[H]
25
Extract-Minimum
• Extracts the node with minimum key from binomial
heap H, and returns a pointer to the extracted node
BINOMIAL-HEAP-EXTRACT-MIN(H)1. remove minimum key root x from H’s root list;2. H′ � Make-B-H();
′
2. H Make-B-H();3. root list of H′ = x’s children in reverse order;4. H � Union(H, H′);5. return x
Time O(lg n).
Extract-Min: Example
41
37
42
23 1826
251216
1
17 3811
29148
6
13
77
28
10head[H]
27
41
37
42
23 1826
251216
1
27
17 3811
29148
6
13
77
28
10head[H]x
Extract-Min: Example
41
37
13
77
28
10head[H]
42
2318 26
25 12 16
27
17 3811
29148
6head[H′]
25
27
17 3811
29148
6
42
23 7726
132816
10
18
41
37
12head[H]
Decrease-Key
BINOMIAL-HEAP-DECREASE-KEY(H, x, k)1. if k > key[x] 2. then error “new key is greater than current key” 3. key[x] � k;
Decreases the key of a node x in a binomial heap H to a new value k.
3. key[x] k;4. y � x;5. z � p[y];6. while z ≠ NIL and key[y] < key[z] 7. do exchange key[y] and key[z];8. exchange other satellite fields of y and z9. y � z;10. z � p[y]
O(lg n)
Decrease-Key Example25
27
17 3811
29148
6
42
23 7726
132816
10
18
41
37
12head[H]
42
Decrease key 26 to 7
25
27
17 3811
29148
6
42
23 777
132816
10
18
41
37
12head[H]
y
z
25
27
17 3811
29148
6
42
23 7716
13287
10
18
41
37
12head[H]
y
z
42
25
27
17 3811
29148
6
42
23 7716
132810
7
18
41
37
12head[H]
y
z
DELETE a node
BINOMIAL-HEAP-DELETE(H, x)1. BINOMIAL-HEAP-DECREASE-KEY(H, x, −∞);2. BINOMIAL-HEAP-EXTRACT-MIN(H)
Time is O(lg n)