1 / 51

CS473-Algorithms

CS473-Algorithms. Lecture BINOMIAL HEAPS. 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)

shira
Download Presentation

CS473-Algorithms

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. CS473-Algorithms Lecture BINOMIAL HEAPS Lecture X

  2. 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. 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. Lecture X

  4. 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 destroyedby this operation 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. Lecture X

  6. Binomial Trees B k-1 B k-1 B k Lecture X

  7. Binomial Trees B2 B1 B1 B0 B1 B0 B1 B2 B3 B3 B2 B0 B1 B4 Lecture X

  8. Binomial Trees Bk-2 Bo B1 B2 Bk-1 Bk Lecture X

  9. k i Properties of Binomial Trees LEMMA: For the binomial tree Bk ; • There are 2k nodes, • The height of tree is k, • There are exactly nodes at depth i for i = 0,1,..,kand • 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. Lecture X

  10. 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 • 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 Lecture X

  11. Properties of Binomial Trees 3. Let D(k,i) denote the number of nodes at depth i of a Bk ; true by induction d=1 d=i d=i-1 d=i D(k-1, i) D(k-1,i -1) Bk-1 Bk-1 k k-1 k-1 D(k,i)=D(k-1,i -1) + D(k-1,i) = + = i i i -1 Lecture X

  12. Properties of Binomial Trees(Cont.) 4.Only node with greater degree in Bkthan 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 Lecture X

  13. Bk-3 Bk-3 B0 B0 B1 B1 B2 B2 Bk-2 Bk-2 Properties of Binomial Trees (Cont.) Bk-1 Lecture X

  14. k k i i 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. Lecture X

  15. Binomial Heaps A BINOMIAL HEAP H is a set of BINOMIAL TREES that satisfies the following “Binomial Heap Properties” • Each binomial tree in H isHEAP-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. 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 haslg(n) + 1bits, n≤ blgn, blgn-1, ....b1, b0> = Σlgni=0bi 2i By property 1 of the lemma (Bi contains 2inodes) Bi appears in H iff bit bi=1 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 1 6 B0 12 25 8 14 29 18 B2 11 17 38 B3 27 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. Lecture X

  19. 10 10 ROOT LIST (LINKED LIST) 10 10 10 10 parent key 10 10 10 10 10 degree 10 10 10 10 10 child 10 10 10 10 sibling 10 10 10 10 10 Representation of Binomial Heaps HEAD [H] 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 Lecture X

  21. Operations on Binomial Heaps CREATING A NEW BINOMIAL HEAP MAKE-BINOMIAL-HEAP ( ) allocateH head [ H ]  NIL returnH end RUNNING-TIME= Θ(1) Lecture X

  22. Operations on Binomial Heaps BINOMIAL-HEAP-MINIMUM (H) x Head [H] min  key [x] x  sibling [x] whilex≠ NIL do if key [x] < min then min  key [x] yx endif x sibling [x] endwhile returny end Lecture X

  23. 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 RUNNING–TIME = O (lgn) 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 Lecture X

  25. Uniting Two Binomial Heaps BINOMIAL-LINK (y,z) p [y] z sibling [y]  child [z] child [z] y degree [z] degree [z] + 1 end Lecture X

  26. Uniting Two Binomial Heaps NIL z +1 child[z] p[y] NIL sibling [y] Lecture X

  27. 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 Lecture X

  28. 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 Lecture X

  29. Uniting Two Binomial Heaps CASE 1: Occurs whendegree [x] ≠ degree [next-x] prev-x x next-x sibling { next-x} a b c d Bk Bl l >k prev-x x next-x a b c d Bk Bl Lecture X

  30. Uniting Two Binomial Heaps: Cases CASE 2: Occurs when x is the first of 3 roots ofequal degree degree [x] = degree [next-x] = degree [sibling[next-x]] prev-x x next-x sibling [next-x] a b c d BK BK BK prev-x x next-x c a b d BK BK BK Lecture X

  31. 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 Lecture X

  32. Uniting Two Binomial Heaps: Cases CASE 3 & 4 CONTINUED prev-x x next-x sibling [next-x] a b c d Bk Bk Bl l > k prev-x x next-x CASE 3 a b d key [b] ≤ key [c] c prev-x x next-x CASE 4 a c d key [c] ≤ key [b] b Lecture X

  33. 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 mostlgn1+1 roots H2 contains at mostlgn2+1 roots Lecture X

  34. 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-MERGEruns inO(lgn)time and • BINOMIAL-HEAP-UNIONruns inO (lgn)time 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 Lecture X

  36. 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 anddegree[sibling [next-x]] = degree [x]) then prev-xxCASE 1 and 2 x next-xCASE 1 and 2 elseif key [x] ≤ key [next-x] then sibling [x]  sibling [next -x] CASE 3 Lecture X

  37. Binomial-Heap-Union Procedure (Cont.) BINOMIAL- LINK (next-x, x)CASE 3 else if prev-x = NIL then head [H]  next-xCASE 4 elseCASE 4 sibling [prev-x]  next-xCASE 4 endif BINOMIAL-LINK(x, next-x)CASE 4 x next-xCASE 4 endif next-x sibling [x] endwhile returnH end Lecture X

  38. Uniting Two Binomial Heaps vsAdding Two Binary Numbers H1withn1NODES : H1 = H2withn2 NODES : H2= ex: n1= 39 : H1= < > = { B0,B1,B2,B5} n2= 54 : H2= < > = { B1,B2,B4,B5} Lecture X

  39. x next-x MERGE H B0 B1 B1 B2 B2 B4 B5 B5 CASE1 MARCH Cin=0 1+0=1 x next-x B0 B1 B1 B2 B2 B4 B5 B5 CASE3 or 4 LINK Cin=0 1+1=10 x next-x B0 B1 B2 B2 B4 B5 B5 CASE2 MARCH then CASE3 and CASE4 LINK Cin=1 1+1=11 B1 B2 x next-x B0 B2 B2 B2 B4 B5 B5 Lecture X

  40. x next-x B0 B2 B2 B4 B5 B5 CASE1 MARCH Cin=1 0+0=1 B3 B2 x next-x B0 B2 B3 B4 B5 B5 CASE1 MARCH Cin=0 0+1=1 x next-x B0 B2 B3 B4 B5 B5 x CASE3 OR 4 LINK Cin=0 1+0=10 B0 B2 B3 B4 B5 B6 B5 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) Lecture X

  42. Relationship Between Insertion & Incrementing a Binary Number B0 B1 B4 B5 H : n1=51 H = < 110011> = { B0,B1 ,B4, B5 } x next-x B0 B0 B1 B4 B5 5 4 3 2 1 0 1 1 1 0 0 1 1 1 + 1 1 0 1 0 0 x next-x H MERGE ( H,H’) LINK LINK B5 B0 B1 B4 B0 B2B4 B5 B4 B5 B1 B1 Lecture X

  43. A Direct Implementation that does not Call Binomial-Heap-Union • More effıcient • Case 2 never occurs • While loop should terminate whenever case 1 is encountered 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 Lecture X

  45. B1 B2 B1 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 B4 B0 Lecture X

  46. Extracting the Node with the Minimum Key x head [H] B1 B0 B4 B1 B0 B2 head [H’] Lecture X

  47. 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 itis O(lgn). Lecture X

  48. Decreasing a Key BINOMIAL-HEAP-DECREASE-KEY (H,x,k) key [x]  k y  x z  p[y] whilez ≠ NIL and key [y] < key [z] do exchange key [y]  key [z] exchange satellite fields of y and z y  z z  p [y] endwhile end Lecture X

  49. 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) Lecture X

  50. Deleting a Key BINOMIAL- 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) Lecture X

More Related