CS 473Lecture X1 CS473-Algorithms Lecture BINOMIAL HEAPS.

CS 473 Lecture X 1

CS473-Algorithms

Lecture

BINOMIAL HEAPS

CS 473 Lecture X 2

Binomial HeapsDATA 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 3

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 4

• 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

Mergeable Heaps

CS 473 Lecture X 5

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 6

Binomial Trees

B k-1

B k-1

B k

CS 473 Lecture X 7

Binomial Trees

B0 B1 B2 B3

B1

B1

B2

B1

B4

B0

B3 B2

B1

B0

CS 473 Lecture X 8

Binomial Trees

Bk-2

Bk-1

B2

B1Bo

Bk

CS 473 Lecture X 9

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 nodes at depth i for

i = 0,1,..,k and4. 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.

ki

CS 473 Lecture X 10


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

MKE

therefore dymbolu koyyy!!!!

CS 473 Lecture X 11


3. Let D(k,i) denote the number of nodes at depth i of a Bk ;

true by inductionBk-1

Bk-1

d=1

d=id=i-1 d=i

D(k-1,i -1) D(k-1, i)

D(k,i)=D(k-1,i -1) + D(k-1,i) = k-1

i -1+

k-1

i =

k

i

CS 473 Lecture X 12

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 13

Properties of Binomial Trees (Cont.)

Bk-1

Bk-3

Bk-2

B2

B1B0

Bk-3

Bk-2

B2

B1B0

CS 473 Lecture X 14

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.

i.e. There are nodes at depth i of a Bk

terms are the binomial coefficients.

ki

ki

CS 473 Lecture X 15

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 16

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 17

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

25

1

12

18

6

298

38

14

27

1711

B0

B2

B3

CS 473 Lecture X 18

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 19

Representation of Binomial HeapsHEAD [H]

10

10

10

10

10

10

10

10

10

10

10

10

10

10

10

10

10

10

10

10

10

10

10

10

10

parent

degreekey

childsibling

ROOT LIST (LINKED LIST)

CS 473 Lecture X 20

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 21

Operations on Binomial Heaps

CREATING A NEW BINOMIAL HEAP

MAKE-BINOMIAL-HEAP ( )

allocate H

head [ H ] NIL

return H

end

RUNNING-TIME= Θ(1)RUNNING-TIME= Θ(1)

CS 473 Lecture X 22

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] y x endif x sibling [x] endwhile return yend


CS 473 Lecture X 23

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

RUNNING–TIME = O (lgn)


CS 473 Lecture X 24

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 25

BINOMIAL-LINK (y,z)

p [y] z

sibling [y] child [z]

child [z] y

degree [z] degree [z] + 1

end


CS 473 Lecture X 26

NIL

sibling [y]

child[z]

p[y]


z+1

NIL

CS 473 Lecture X 27

Uniting Two Binomial Heaps: CasesWe 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 28

• 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 29

CASE 1: Occurs when degree [x] ≠ degree [next-x]

prev-x x next-x sibling { next-x}

prev-x x next-x

a b c d

a b c d

Bk Bl

l >k

Bk Bl


CS 473 Lecture X 30

prev-x x next-x sibling [next-x]

prev-x x next-x

a b c d

a b c d

BK BK BK

BK BK BK

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

CS 473 Lecture X 31

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 32

prev-x x next-x sibling [next-x]

prev-x x next-xBk Bk Bl l > k

CASE 3

key [b] ≤ key [c]

CASE 4

key [c] ≤ key [b]

prev-x x next-x

a b c d

a

c

b d

a

b

c d

Uniting Two Binomial Heaps: CasesCASE 3 & 4 CONTINUED

CS 473 Lecture X 33

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 34

• 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 35

Binomial-Heap-Union Procedure

BINOMIAL-HEAP-MERGE PROCEDURE

- Merges the root lists of H1 & H2 into a single linked-list

- Sorted by degree into monotonically increasing order

CS 473 Lecture X 36

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

Binomial-Heap-Union Procedure

CS 473 Lecture X 37

BINOMIAL- LINK (next-x, x) CASE 3else

if prev-x = NIL then head [H] next-x CASE 4 else CASE 4 sibling [prev-x] next-x CASE 4

endifBINOMIAL-LINK(x, next-x)

CASE 4 x next-x CASE 4 endif next-x sibling [x]

endwhilereturn H

end

Binomial-Heap-Union Procedure (Cont.)

CS 473 Lecture X 38

Uniting Two Binomial Heaps vs Adding Two Binary Numbers

H1 with n1 NODES : H1 =

H2 with n2 NODES : H2 =

ex: n1= 39 : H1 = < > = { B0, B1, B2, B5 }

n2 = 54 : H2= < > = { B1, B2, B4, B5 }

5 4 3 2 1 0

1 0 0 1 1 1

1 1 0 1 1 0

CS 473 Lecture X 39

B5B5B4B2B2B1B1B0

MERGE H

B5B5B4B2B2B1B1B0

B5B5B4B2B2B1B0

B1

B5B5B4B2B2B2B0

next-x x

next-x x

next-x x

next-x xB2

CASE1 MARCH Cin=0 1+0=1

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

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

CS 473 Lecture X 40

B5B5B4B2B2B0

B5B5B4B3B2B0

B5B5B4B3B2B0

B5

B5

B2 B3


x

B4B3B2B0

next-x

next-x x

next-x x

B6

x


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

CS 473 Lecture X 41

Inserting a Node

BINOMIAL-HEAP-INSERT (H,x)

H' MAKE-BINOMIAL-HEAP (H, x) P [x] NIL child [x] NIL sibling [x] NIL degree [x] O head [H’] x H BINOMIAL-HEAP-UNION (H, H’)end

RUNNING-TIME= O(lg n)RUNNING-TIME= O(lg n)

CS 473 Lecture X 42

B5B4B1B0

B5B4B1B0

B5B4B1B0

B5B4B1

Relationship Between Insertion & Incrementing a Binary Number

B0

B0

B1

H : n1=51 H = < 110011> = { B0, B1 ,B4, B5 }

H

MERGE

( H,H’)

LINK

LINK

5 4 3 2 1 0

1

1 1 0 0 1 1

1

+

1 1 0 1 0 0

B2 B4 B5

x next-x

x next-x

CS 473 Lecture X 43

- More effıcient

- Case 2 never occurs

- While loop should terminate whenever case 1 is encountered

A Direct Implementation that does not Call Binomial-Heap-Union

CS 473 Lecture X 44

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 45

head [H]

B0B1

x


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

B2B1

B0

B4

CS 473 Lecture X 46

head [H’]


head [H]

B0B1

x

B2B1 B0

B4

CS 473 Lecture X 47

• 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 48

BINOMIAL-HEAP-DECREASE-KEY (H, x, k)key [x] ky xz p[y] while z ≠ NIL and key [y] < key [z] do exchange key [y] key [z] exchange satellite fields of y and z y z z p [y] endwhileend

Decreasing a Key

CS 473 Lecture X 49

• Similar to DECREASE-KEY in BINARY HEAP

• BUBBLE-UP the key in the binomial tree it resides in

• RUNNING TIME: O(lgn)

Decreasing a Key

CS 473 Lecture X 50

Deleting a KeyBINOMIAL- HEAP- DELETE (H,x) y ← x z ← p [y] 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 z’s children

and set head [H’] ← head of the resulting list H ← BINOMIAL-HEAP-UNION (H, H’)

RUNNING-TIME= O(lg n)RUNNING-TIME= O(lg n)

CS 473 Lecture X 51

H’ ← MAKE-BINOMIAL-HEAP

remove root z from the root list of H

reverse the order of the linked list of z’s children

set head [H’] ← head of the resulting list

H ← BINOMIAL-HEAP-UNION (H, H’)

end

Deleting a Key (Cont.)

CS 473Lecture X1 CS473-Algorithms Lecture BINOMIAL HEAPS.

Documents

Transcript of CS 473Lecture X1 CS473-Algorithms Lecture BINOMIAL HEAPS.