CS473-Algorithms
Lecture
BINOMIAL HEAPS
CS 473
Lecture X
Binomial Heaps
DATA STRUCTURES: MERGEABLE HEAPS
MAKE-HEAP ( )
Creates & returns a new heap with no elements.
INSERT (H,x)
Inserts a node x whose key field has already been
filled into heap H.
MINIMUM (H)
Returns a pointer to the node in heap H whose key
is minimum.
CS 473
Lecture X
Mergeable Heaps
EXTRACT-MIN (H)
Deletes the node from heap H whose key is
minimum. Returns a pointer to the node.
DECREASE-KEY (H, x, k)
Assigns to node x within heap H the new value k
where k is smaller than its current key value.
CS 473
Lecture X
Mergeable Heaps
DELETE (H, x)
Deletes node x from heap H.
UNION (H1, H2)
Creates and returns a new heap that contains all
nodes of heaps H1 & H2.
Heaps H1 & H2 are destroyed by this operation
CS 473
Lecture X
Binomial Trees
A binomial heap is a collection of binomial
trees.
The binomial tree Bk is an ordered tree defined
recursively
Bo Consists of a single node
.
.
.
Bk Consists of two binominal trees Bk-1
linked together. Root of one is the
leftmost child of the root of the other.
CS 473
Lecture X
Binomial Trees
B k-1
B k-1
Bk
CS 473
Lecture X
Binomial Trees B
B1
B1
B0
B1
B0
B1
B2
B3
B3
B2
B0
B1
CS 473
B4
Lecture X
Binomial Trees
B2
Bk-2
B1
Bo
Bk-1
CS 473
Bk
Lecture X
Properties of Binomial Trees
LEMMA: For the binomial tree Bk ;
1. There are 2k nodes,
2. The height of tree is k,
k
3. There are exactly
nodes at depth i for
i
i = 0,1,..,k and
4. The root has degree k > degree of any other
node if the children of the root are numbered
from left to right as k-1, k-2,...,0; child i is the
root of a subtree Bi.
CS 473
Lecture X
Properties of Binomial Trees
PROOF: By induction on k
Each property holds for the basis B0
INDUCTIVE STEP: assume that Lemma
holds for Bk-1
1. Bk consists of two copies of Bk-1
| Bk | = | Bk-1 | + | Bk-1| = 2k-1 +2k-1 = 2k
2. hk-1 = Height (Bk-1) = k-1 by induction
hk=hk-1+1 = k-1 +1 = k
CS 473
Lecture X
10
Properties of Binomial Trees
3. Let D(k,i) denote the number of nodes at depth i of a Bk ;
d=1
d=i-1
D(k-1, i)
D(k-1,i -1)
Bk-1
D(k,i)=D(k-1,i -1) + D(k-1,i) =
Bk-1
true by induction
k-1
i -1
CS 473
d=i
d=i
Lecture X
k-1
i
k
=
i
11
Properties of Binomial Trees(Cont.)
4.Only node with greater degree in Bk than those
in Bk-1 is the root,
The root of Bk has one more child than the root
of Bk-1,
Degree of root Bk=Degree of Bk-1+1=(k-1)+1=k
CS 473
Lecture X
12
Properties of Binomial Trees (Cont.)
Bk-3
B1 B0
B2
Bk-2
B1 B0
Bk-3
B2
Bk-2
CS 473
Bk-1
Lecture X
13
Properties of Binomial Trees (Cont.)
COROLLARY: The maximum degree of any
node in an n-node binomial tree is lg(n)
The term BINOMIAL TREE comes from the
3rd property.
k
i.e. There are i nodes at depth i of a Bk
k
terms
i
CS 473
are the binomial coefficients.
Lecture X
14
Binomial Heaps
A BINOMIAL HEAP H is a set of BINOMIAL
TREES that satisfies the following Binomial
Heap Properties
1. Each binomial tree in H is HEAP-ORDERED
CS 473
the key of a node is the key of the parent
Root of each binomial tree in H contains the
smallest key in that tree.
Lecture X
15
Binomial Heaps
2. There is at most one binomial tree in H whose
root has a given degree,
n-node binomial heap H consists of at most
[lgn] + 1 binomial trees.
Binary represantation of n has lg(n) + 1 bits,
n b
lgn
,b
lgn -1
, ....b1, b0> =
lgn
i=0
bi 2i
By property 1 of the lemma (Bi contains 2i nodes) Bi
appears in H iff bit bi=1
CS 473
Lecture X
16
Binomial Heaps
Example: A binomial heap with n = 13 nodes
3 2 1 0
13 =< 1, 1, 0, 1>2
Consists of B0, B2, B3
head[H]
10
B0
12
B2
25
18
11
27
CS 473
Lecture X
14
17
38
29
B3
17
Representation of Binomial Heaps
Each binomial tree within a binomial heap is stored in
the left-child, right-sibling representation
Each node X contains POINTERS
p[x] to its parent
child[x] to its leftmost child
sibling[x] to its immediately right sibling
Each node X also contains the field degree[x] which
denotes the number of children of X.
CS 473
Lecture X
18
Representation of Binomial Heaps
HEAD [H]
10
10
parent
key
degree
child
10
10
10
10
10
10
ROOT LIST (LINKED LIST)
10
10
10
10
10
10
10
10
10
10
10
10
10
10
sibling
10
10
10
CS 473
Lecture X
19
Representation of Binomial Heaps
Let x be a node with sibling[x] NIL
Degree [sibling [x]]=degree[x]-1
if x is NOT A ROOT
Degree [sibling [x]] > degree[x]
if x is a root
CS 473
Lecture X
20
Operations on Binomial Heaps
CREATING A NEW BINOMIAL HEAP
MAKE-BINOMIAL-HEAP ( )
allocate H
head [ H ] NIL
return H
RUNNING-TIME= (1)
end
CS 473
Lecture X
21
Operations on Binomial Heaps
BINOMIAL-HEAP-MINIMUM (H)
x Head [H]
min key [x]
x sibling [x]
while
x NIL do
if
key [x] < min then
min key [x]
yx
endif
x sibling [x]
endwhile
return y
end
CS 473
Lecture X
22
Operations on Binomial Heaps
Since binomial heap is HEAP-ORDERED
The minimum key must reside in a ROOT NODE
Above procedure checks all roots
NUMBER OF ROOTS lgn + 1
RUNNINGTIME = O (lgn)
CS 473
Lecture X
23
Uniting Two Binomial Heaps
BINOMIAL-HEAP-UNION
Procedure repeatedly link binomial trees whose roots
have the same degree
BINOMIAL-LINK
Procedure links the Bk-1 tree rooted at node y to
the Bk-1 tree rooted at node z it makes z the parent of y
i.e. Node z becomes the root of a Bk tree
CS 473
Lecture X
24
Uniting Two Binomial Heaps
BINOMIAL-LINK (y,z)
p [y] z
sibling [y] child [z]
child [z] y
degree [z] degree [z] + 1
end
CS 473
Lecture X
25
Uniting Two Binomial Heaps
NIL
child[z]
NIL
+1
p[y]
sibling [y]
CS 473
Lecture X
26
Uniting Two Binomial Heaps: Cases
We maintain 3 pointers into the root list
x = points to the root currently being
examined
prev-x = points to the root PRECEDING x on
the root list sibling [prev-x] = x
next-x = points to the root FOLLOWING x on
the root list sibling [x] = next-x
CS 473
Lecture X
27
Uniting Two Binomial Heaps
Initially, there are at most two roots of the same
degree
Binomial-heap-merge guarantees that if two roots in h
have the same degree they are adjacent in the root list
During the execution of union, there may be three
roots of the same degree appearing on the root list at
some time
CS 473
Lecture X
28
Uniting Two Binomial Heaps
CASE 1: Occurs when degree [x] degree [next-x]
prev-x
next-x
Bk
prev-x
Bk
CS 473
Bl
l >k
sibling { next-x}
next-x
Bl
Lecture X
29
Uniting Two Binomial Heaps: Cases
CASE 2: Occurs when x is the first of 3 roots of equal degree
degree [x] = degree [next-x] = degree [sibling[next-x]]
prev-x
next-x
BK
a
BK
BK
prev-x
next-x
BK
CS 473
sibling [next-x]
BK
Lecture X
BK
30
Uniting Two Binomial Heaps: Cases
CASE 3 & 4: Occur when x is the first of 2 roots of equal degree
degree [x] = degree [next-x] degree [sibling [next-x]]
Occur on the next iteration after any case
Always occur immediately following CASE 2
Two cases are distinguished by whether x or next-x has the smaller key
The root with the smaller key becomes the root of the linked tree
CS 473
Lecture X
31
Uniting Two Binomial Heaps: Cases
CASE 3 & 4 CONTINUED
prev-x
prev-x
next-x
Bk
sibling [next-x]
Bk
x
Bl
next-x
CASE 3
key [b] key [c]
c
prev-x
next-x
CASE 4
key [c] key [b]
b
CS 473
l>k
Lecture X
32
Uniting Two Binomial Heaps: Cases
The running time of binomial-heap-union operation is
O (lgn)
Let H1 & H2 contain n1 & n2 nodes respectively
where n= n1+n2
Then, H1 contains at most lgn1 +1 roots
H2 contains at most lgn2 +1 roots
CS 473
Lecture X
33
Uniting Two Binomial Heaps: Cases
So H contains at most
lgn1 + lgn2 +2 2 lgn +2= O (lgn) roots
immediately after BINOMIAL-HEAP-MERGE
Therefore, BINOMIAL-HEAP-MERGE runs in O(lgn)
time and
BINOMIAL-HEAP-UNION runs in O (lgn) time
CS 473
Lecture X
34
Binomial-Heap-Union Procedure
BINOMIAL-HEAP-MERGE PROCEDURE
- Merges the root lists of H1 & H2 into a single linkedlist
- Sorted by degree into monotonically increasing order
CS 473
Lecture X
35
Binomial-Heap-Union Procedure
BINOMIAL-HEAP-UNION (H1,H2)
H MAKE-BINOMIAL-HEAP ( )
head [ H ] BINOMIAL-HEAP-MERGE (H1,H2)
free the objects H1 & H2 but not the lists they point to
prev-x NIL
x HEAD [H]
next-x sibling [x]
while next-x NIL do
if ( degree [x] degree [next-x] OR
(sibling [next-x] NIL and degree[sibling [next-x]] = degree [x]) then
prev-x x
CASE 1 and 2
x next-x
CASE 1 and 2
elseif key [x] key [next-x] then
sibling [x] sibling [next -x]
CASE 3
CS 473
Lecture X
36
Binomial-Heap-Union Procedure (Cont.)
BINOMIAL- LINK (next-x, x)
CASE 3
else
if prev-x = NIL then
head [H] next-x
else
sibling [prev-x] next-x
endif
BINOMIAL-LINK(x, next-x)
x next-x
CASE 4
CASE 4
CASE 4
CASE 4
CASE 4
endif
next-x sibling [x]
endwhile
return H
end
CS 473
Lecture X
37
Uniting Two Binomial Heaps vs
Adding Two Binary Numbers
H1 with n1 NODES : H1 =
H2 with n2
NODES : H2 =
5 4 3 2 1 0
ex:
n1= 39 : H1 = < 1 0 0 1 1 1> = { B0, B1, B2, B5 }
n2 = 54 : H2= < 1 1 0 1 1 0> = { B1, B2, B4, B5 }
CS 473
Lecture X
38
MERGE
CASE1 MARCH
Cin=0
1+0=1
next-x
B0
B1
x
B0
B1
B1
B2
B2
B4
B5
B5
next-x
B1
B2
B2
B4
B2
B4
B5
B5
B5
CASE3 or 4
LINK Cin=0
1+1=10
x
B0
CASE2 MARCH
then CASE3 and
CASE4 LINK
Cin=1
1+1=11
CS 473
B1
next-x
B2
B5
B1
B2
x
B0
B2
B2
Lecture X
next-x
B2
B4
B5
B5
39
B0
B2
CASE1
MARCH
Cin=1
0+0=1
next-x
B2
B4
B5
B3
B2
x
B0
CASE1
MARCH
Cin=0
0+1=1
CASE3 OR 4
LINK Cin=0
1+0=10
CS 473
B0
B2
B2
B5
B3
B3
next-x
B4
B5
B4
B5
next-x
B5
B5
x
B0
B2
B3
Lecture X
B4
B5
B5
B6
40
Inserting a Node
BINOMIAL-HEAP-INSERT (H,x)
H'
MAKE-BINOMIAL-HEAP (H, x)
P [x] NIL
child [x] NIL
RUNNING-TIME= O(lg n)
sibling [x] NIL
degree [x] O
head [H] x
H BINOMIAL-HEAP-UNION (H, H)
end
CS 473
Lecture X
41
Relationship Between Insertion &
Incrementing a Binary Number
H : n1=51
H = < 110011>
H
MERGE
( H,H)
B0
B1
= { B0, B1 ,B4, B5 }
B4
B5
next-x
B0
B0
B1
B4
B5
5 4 3 2 1 0
LINK
next-x
B0
B1
B2
B0
B1
LINK
B4
B4
B4
B5
1 1 0 0 1 1
1
B5
B1
CS 473
B5
Lecture X
1 1 0 1 0 0
42
A Direct Implementation that does not Call
Binomial-Heap-Union
- More effcient
- Case 2 never occurs
- While loop should terminate whenever
case 1 is encountered
CS 473
Lecture X
43
Extracting the Node with the Minimum Key
BINOMIAL-HEAP-EXTRACT-MIN (H)
(1) find the root x with the minimum key in the
root list of H and remove x from the root list of H
(2) H MAKE-BINOMIAL-HEAP ( )
(3) reverse the order of the linked list of x children
and set head [H] head of the resulting list
(4) H BINOMIAL-HEAP-UNION (H, H)
return x
end
CS 473
Lecture X
44
Extracting the Node with the Minimum Key
Consider H with n = 27, H = <1 1 0 1 1> = {B0, B1, B3, B4 }
assume that x = root of B3 is the root with minimum key
x
head [H]
B0
B1
B4
B1
B2
CS 473
Lecture X
B0
45
Extracting the Node with the Minimum Key
x
head [H]
B0
B1
B4
B1
B2
B0
head [H]
CS 473
Lecture X
46
Extracting the Node with the Minimum Key
Unite binomial heaps H= {B0 ,B1,B4} and
H = {B0 ,B1,B2}
Running time if H has n nodes
Each of lines 1-4 takes O(lgn) time
it is O(lgn).
CS 473
Lecture X
47
Decreasing a Key
BINOMIAL-HEAP-DECREASE-KEY (H, x, k)
key [x] k
y x
z p[y]
while z NIL and key [y] < key [z] do
exchange key [y] key [z]
exchange satellite fields of y and z
yz
z p [y]
endwhile
end
CS 473
Lecture X
48
Decreasing a Key
Similar to DECREASE-KEY in BINARY HEAP
BUBBLE-UP the key in the binomial tree it
resides in
RUNNING TIME: O(lgn)
CS 473
Lecture X
49
Deleting a Key
BINOMIAL- HEAP- DELETE (H,x)
yx
z p [y]
RUNNING-TIME=
while z NIL do
key [y] key [z]
satellite field of y satellite field of z
y z ; z p [y]
endwhile
H MAKE-BINOMIAL-HEAP
remove root z from the root list of H
reverse the order of the linked list of zs children
and set head [H] head of the resulting list
H BINOMIAL-HEAP-UNION (H, H)
CS 473
Lecture X
O(lg n)
50
Deleting a Key (Cont.)
H MAKE-BINOMIAL-HEAP
remove root z from the root list of H
reverse the order of the linked list of zs children
set head [H] head of the resulting list
H BINOMIAL-HEAP-UNION (H, H)
end
CS 473
Lecture X
51
