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 2

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 5

Binomial Trees

B k-1

B k-1
Bk
CS 473 Lecture X 6

Binomial Trees B
B1
B1

B0 B1

B0

B1

B2

B3

B3

B2 B1

B0

CS 473

B4

Lecture X

Binomial Trees

B1 B2

Bo

Bk-1

Bk-2

Bk
CS 473 Lecture X 8

Properties of Binomial Trees

LEMMA: For the binomial tree Bk ; 1. There are 2k nodes, 2. The height of tree is k, 3. There are exactly k 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 9

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 -1) d=i D(k-1, i)

d=i

Bk-1
Bk-1
D(k,i)=D(k-1,i -1) + D(k-1,i) = true by induction
k-1 i -1
CS 473 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.)

B1 B0 Bk-3 Bk-2
B1 B0

B2

Bk-3
Bk-2

B2

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 terms k are the binomial coefficients.
i
CS 473 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
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.

CS 473

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 b 2 i=0 i

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 1 6 8 14 29

B0 B2
CS 473

12

25

18

11

17

38

27 Lecture X

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 10 10

ROOT LIST (LINKED LIST)

10 10

parent key degree

10 10

10 10

10 10

10 10

10 10

child

10 10

sibling

10 10

10 10

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 end RUNNING-TIME= (1)

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

+1

NIL

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 x next-x sibling { next-x}

Bk
l >k
prev-x

Bl

next-x

Bk
CS 473

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 x next-x sibling [next-x]

BK
prev-x

BK
x

BK
next-x

b BK

d BK
30

BK
Lecture X

CS 473

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 x next-x sibling [next-x]

b
Bk

c
Bk x

d
Bl next-x l>k
CASE 3

prev-x

a c
prev-x

key [b] key [c]

next-x

a b
CS 473

CASE 4

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 endif next-x sibling [x] endwhile return H end
CS 473 Lecture X 37

CASE 4 CASE 4 CASE 4 CASE 4 CASE 4

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

x
MERGE H CASE1 MARCH Cin=0 1+0=1
B0

next-x
B1 B1 B2 B2 B4 B5 B5

B0

x
B1

next-x
B1 B2 B2 B4 B5 B5

CASE3 or 4 LINK Cin=0 1+1=10

B0

x
B1 B1

next-x
B2 B2 B4 B5 B5

CASE2 MARCH then CASE3 and CASE4 LINK Cin=1 1+1=11

CS 473

B2
B0 B2

x
B2

next-x
B2 B4 B5 B5

Lecture X

39

x
B0 B2 B2

next-x
B4 B5 B5

CASE1 MARCH Cin=1 0+0=1

B0

B2

B3

x
B2 B3 B4

next-x
B5 B5

CASE1 MARCH Cin=0 0+1=1

B0 B2 B3 B4

x
B5

next-x
B5

CASE3 OR 4 LINK Cin=0 1+0=10

CS 473

x
B0 B2 B3 B4 B5

Lecture X

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 MERGE ( H,H)

H = < 110011> =
B0 B1 B4

{ B0, B1 ,B4, B5 }
B5

x
B0

next-x
B0 B1 B4 B5

x
LINK
B0

next-x
B1 B4 B5

B0

B2
B1 B1

B4
B4

B5
B5

5 4 3 2 1 0 1 1 1 0 0 1 1 1 + 1 1 0 1 0 0

LINK

CS 473

Lecture X

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 B2 B1 B0

CS 473

Lecture X

45

Extracting the Node with the Minimum Key

x head [H] B0 B1 B4 B2 B1 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= O(lg n) 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

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