CSE 326: Data Structures Binomial Queues Ben Lerner Summer 2007

2 Adminstrivia Due today: Homework #1 Released today: Homework #2

3 BuildHeap: Floyd’s Method Add elements arbitrarily to form a complete tree. Pretend it’s a heap and fix the heap-order property!

4 Buildheap pseudocode private void buildHeap() { for ( int i = currentSize/2; i > 0; i-- ) percolateDown( i ); } runtime:

5 BuildHeap: Floyd’s Method

6 Finally… runtime:

7 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

8 CPU – 1 cycle Cache – ~10 cycles Memory – ~200 cycles Disk – ~200,000 cycles Cycles to access:

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

10 Operations on d-Heap Insert : runtime = deleteMin: runtime = Does this help insert or deleteMin more?

11 One More Operation Merge two heaps. Ideas?

12 New Operation: Merge Given two heaps, merge them into one –First attempt: aren’t two heaps “just like” one heap after deleteMin? NO. Violates the completeness property –Second attempt: Foreach element in smaller heap, insert into larger one Runtime? –Third attempt: Concatenate the arrays of the two heaps, then run buildHeap Runtime?

13 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?

14 Binomial Queues 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

15 Worst Case Run Times Insert FindMin DeleteMin Merge  (log N)  (1)  (N)  (log N) Binary Heap  (log N) O(log N)  (log N) Binomial Queue

16 Binomial Queues Binomial queues give up  (1) FindMin performance 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

17 Binomial Queue with 5 Trees B0B0 B1B1 B2B2 B3B3 B4B4 depth number of elements = = = = = 1

18 Structure Property 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 2 d B0B0 B1B1 B2B2 depth number of elements = = = 1

19 Powers of 2 Any number N can be represented in base 2 –A base 2 value identifies the powers of 2 that are to be included 2 0 = = = = 8 10 Hex 16 Decimal

20 Numbers of nodes 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 2 d nodes So the structure of a forest of binomial trees can be characterized with a single binary number –100 2  1· · ·2 0 = 4 nodes

Structure Examples 4 8 N=2 10 = = = = 42 1 = 22 0 = = 4 N=3 10 =11 2 N=4 10 =100 2 N=5 10 = = = = 2

22 What is a merge? There is a direct correlation between –the number of nodes in the tree –the representation of that number in base 2 –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 1 +N 2 We can use that fact to help see how fast merges can be accomplished

4 8 N=2 10 = = = 1 N=3 10 = = = 1 N=1 10 = = 22 2 = 42 0 = 1 9 Example 1. Merge BQ.1 and BQ.2 Easy Case. There are no comparisons and there is no restructuring. BQ.1 + BQ.2 = BQ.3

4 6 N=2 10 = = = 1 N=4 10 = = = 1 N=2 10 = = 22 2 = 42 0 = 1 Example 2. Merge BQ.1 and BQ.2 This is an add with a carry out. It is accomplished with one comparison and one pointer change: O(1) BQ.1 + BQ.2 = BQ

4 6 N=3 10 = = = 1 N=2 10 = = = 1 N=3 10 = = 22 2 = 42 0 = 1 Example 3. Merge BQ.1 and BQ.2 Part 1 - Form the carry. BQ.1 + BQ.2 = carry

4 6 N=3 10 = = = 1 N=6 10 = = = 1 N=3 10 = = 22 2 = 42 0 = 1 Example 3. Part 2 - Add the existing values and the carry. + BQ.1 + BQ.2 = BQ = 22 0 = 1 N=2 10 = = 4 carry

27 Merge Algorithm Just like binary addition algorithm Assume trees X 0,…,X n and Y 0,…,Y n are binomial queues –X i and Y i are of type B i or null C 0 := null; //initial carry is null// for i = 0 to n do combine X i,Y i, and C i to form Z i and new C i+1 Z n+1 := C n+1

28 Exercise = 22 0 = = 42 1 = 22 0 = 1 N=3 10 =11 2 N=5 10 = =

29 O(log N) time to Merge For N keys there are at most  log 2 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).

30 Insert Create a single node queue B 0 with the new item and merge with existing queue O(log N) time

31 DeleteMin 1.Assume we have a binomial forest X 0,…,X m 2.Find tree X k with the smallest root 3.Remove X k from the queue 4.Remove root of X k (return this value) –This yields a binomial forest Y 0, Y 1, …,Y k-1. 5.Merge this new queue with remainder of the original (from step 3) Total time = O(log N)

32 Implementation Binomial forest as an array of multiway trees –FirstChild, Sibling pointers –Sibling pointers act like a linked list

33 DeleteMin Example 1 And return this

34 DeleteMin step 1: remove min 1 Return this Keep these

New forest Old forest DeleteMin step 2: new forest

Merge DeleteMin step 3: merge forests

37 Merge in detail

38 Merge step 1: 1-trees Carry out

39 97 Merge step 2: 2-trees Carry out Carry in Merging two trees is just a stack push! 7 12

40 Merge step 3: 4-trees Carry in 2 Carry out

41 Merge step 4: 8-trees Carry in

42 Why Binomial? B0B0 B1B1 B2B2 B3B3 B4B4 tree depth d nodes at depth k 4 1, 4, 6, 4, 1 3 1, 3, 3, 1 2 1, 2, 1 1 1, 1 0 1

43 Other Priority Queues Leftist Heaps –O(log N) time for insert, deletemin, merge Skew Heaps –O(log N) amortized time for insert, deletemin, merge Calendar Queues –O(1) average time for insert and deletemin –Assuming insertions are “random”

44 Exercise Solution