Administration CSE 326: Data Structures

Transcription

1 Administration CSE : Data Structures Binomial Queues Neva Cherniavsky Summer Released today: Project, phase B Due today: Homework Released today: Homework I have office hours tomorrow // Binomial Queues BuildHeap: Floyd s Method Buildheap pseudocode Add elements arbitrarily to form a complete tree. Pretend it s a heap and fix the heap-order property! private void buildheap() { for ( int i = currentsize/; i > ; i-- ) percolatedown( i ); } // Binomial Queues // Binomial Queues BuildHeap: Floyd s Method Finally // Binomial Queues // Binomial Queues

2 Facts about Heaps Observations: finding a child/parent index is a multiply/divide by two operations jump widely through the heap each percolate step looks at only two new nodes inserts are at least as common as deletemins Realities: division/multiplication by powers of two are equally fast looking at only two new pieces of data: bad for cache! with huge data sets, disk accesses dominate Cycles to access: CPU Cache Memory Disk // Binomial Queues // Binomial Queues Representing Complete Binary Trees in an Array B C D E F H I J K L A A implicit (array) implementation: B C D E F G G H From node i: left child: right child: parent: I J K L A Solution: d-heaps Each node has d children Still representable by array Good choices for d: (choose a power of two for efficiency) fit one set of children in a cache line fit one set of children on a memory page/disk block // Binomial Queues // Binomial Queues Operations on d-heap Insert : runtime = One More Operation Merge two heaps. Ideas? deletemin: runtime = Does this help insert or deletemin more? // Binomial Queues // Binomial Queues

3 New Operation: Merge Given two heaps, merge them into one heap first attempt: insert each element of the smaller heap into the larger. second attempt: concatenate binary heaps arrays and run buildheap. Merging heaps Binary Heap is a special purpose hot rod FindMin, DeleteMin and Insert only does not support fast merges of two heaps For some applications, the items arrive in prioritized clumps, rather than individually Is there somewhere in the heap design that we can give up a little performance so that we can gain faster merge capability? // Binomial Queues // Binomial Queues Binomial Queues Worst Case Run Times Binomial Queues are designed to be merged quickly with one another Using pointer-based design we can merge large numbers of nodes at once by simply pruning and grafting tree structures More overhead than Binary Heap, but the flexibility is needed for improved merging speed Insert FindMin DeleteMin Merge Binary Heap Θ() Θ(N) Binomial Queue O(log N) O(log N) // Binomial Queues // Binomial Queues Binomial Queues Binomial Queue with Trees Binomial queues give up simplicity in order to provide O(log N) merge performance A binomial queue is a collection (or forest) of heap-ordered trees Not just one tree, but a collection of trees each tree has a defined structure and capacity each tree has the familiar heap-order property B B B B B depth number of elements = = = = = // Binomial Queues // Binomial Queues

4 Structure Property Powers of Each tree contains two copies of the previous tree the second copy is attached at the root of the first copy The number of nodes in a tree of depth d is exactly d depth B B B Any number N can be represented in base A base value identifies the powers of that are to be included = = = = Hex Decimal number of elements = = = // Binomial Queues // Binomial Queues Numbers of nodes Structure Examples Any number of entries in the binomial queue can be stored in a forest of binomial trees Each tree holds the number of nodes appropriate to its depth, ie d nodes So the structure of a forest of binomial trees can be characterized with a single binary number + + = nodes // Binomial Queues N= = = = = N= = = = = N= = = = = N= = = = = What is a merge? There is a direct correlation between the number of nodes in the tree the representation of that number in base and the actual structure of the tree When we merge two queues, the number of nodes in the new queue is the sum of N +N We can use that fact to help see how fast merges can be accomplished Example. Merge BQ. and BQ. Easy Case. There are no comparisons and there is no restructuring. BQ. N= = = = = + BQ. N= = = = = BQ. = // Binomial Queues N= = = = =

5 Example. BQ. BQ. Merge BQ. and BQ. This is an add with a carry out. It is accomplished with one comparison and one pointer change: O() N= = = = = + BQ. N= = = = = BQ. = Example. Merge BQ. and BQ. Part - Form the carry. N= = = = = + BQ. N= = = = = carry = N= = = = = N= = = = = carry + BQ. Merge Algorithm N= = = Example. = = Part - Add the existing values and the carry. N= = = = = + BQ. N= = = = = BQ. N= = = = = = Just like binary addition algorithm Assume trees X,,X n and Y,,Y n are binomial queues X i and Y i are of type B i or null C := null; //initial carry is null// for i = to n do combine X i,y i, and C i to form Z i and new C i+ Z n+ := C n+ // Binomial Queues Exercise O(log N) time to Merge N= = = = = N= = = = = For N keys there are at most log N trees in a binomial forest. Each merge operation only looks at the root of each tree. Total time to merge is O(log N). // Binomial Queues // Binomial Queues

6 Insert Create a single node queue B with the new item and merge with existing queue O(log N) time DeleteMin. Assume we have a binomial forest X,,X m. Find tree X k with the smallest root. Remove X k from the queue. Remove root of X k (return this value) This yields a binomial forest Y, Y,,Y k-.. Merge this new queue with remainder of the original (from step ) Total time = O(log N) // Binomial Queues // Binomial Queues Implementation Binomial forest as an array of multiway trees FirstChild, Sibling pointers Subtrees in decreasing sizes DeleteMin Example Return this // Binomial Queues // Binomial Queues Old forest Merge New forest // Binomial Queues // Binomial Queues

7 Why Binomial? Other Priority Queues d d! = k ( d k)! k! tree depth d nodes at depth k,,,, B,,, B B,, B, B Leftist Heaps O(log N) time for insert, deletemin, merge Skew Heaps O(log N) amortized time for insert, deletemin, merge Calendar Queues O() average time for insert and deletemin Assuming insertions are random // Binomial Queues // Binomial Queues Exercise Solution + // Binomial Queues