1. CSE 326: Data Structures Lecture #5 Heaps More
Steve Wolfman
Winter Quarter 2000
OK, today we’ll get to and get through much of heaps. So, we have a lot of material to cover!
But, there is one thing we need to touch on briefly before we continue.

2. We get slide printouts every class
4 pages of notes per day  50 students  3 lectures per week  10 weeks per quarter  engineer’s fudge factor  10,000 pages
one 60 foot pine tree  80,000 pages
Frankye Jones’s frantic effort = one paycheck for Steve
paycheck + = 1 tree / $1
How about two trees per person?
Some of you may remember that I was considering not printing out slides every class period.
I decided it was important to do so, but I did some math and some web searching and discovered that we can, as usual, buy our way out of guilt!
So, given that I’m now getting paid, how does about two trees per person in the class sound to everyone?

3. Today’s Outline Things Steve Didn’t Finish on Wednesday (Heaps)
Extra heap operations
d-Heaps
Return Quizzes
OK, back to comupter science.
Today we’ll cover everything I missed on Wed. That’s heaps of stuff, and then move on to some extra heap operations and d-heaps. I’ll hand the quizzes back right now, however.
You MUST hand in your score sheet along with your homework!

4. Other Priority Queue Operations
decreaseKey
given a pointer to an object in the queue, reduce its priority value
increaseKey
given a pointer to an object in the queue, increase its priority value
remove
given a pointer to an object in the queue, remove it
buildHeap
given a set of items, build a heap
Why do I insist on a pointer to each item in decreaseKey, increaseKey, and remove?
Because it’s hard to find an item in a heap; it’s easy to delete the minimum, but how would you find some arbitrary element?
This is where the Dictionary ADT and its various implementations which we will study soon come up.
What about build heap? Is that really a necessary operation?
It turns out that the necessity for this is based _purely_ on the fact that we can do it faster than the naïve implementation!

5. DecreaseKey, IncreaseKey, and Remove
void decreaseKey(int obj) {
assert(size >= obj);
temp = Heap[obj];
newPos = percolateUp(obj, temp);
Heap[newPos] = temp; }
void increaseKey(int obj) {
newPos = percolateDown(obj, temp);
void remove(int obj) {
assert(size >= obj);
percolateUp(obj,
NEG_INF_VAL);
deleteMin(); }
The code for these is pretty simple. Notice that these are called just after the key is changed, they do not include the new value (just assume it’s there).
This is different from the book’s version. And, it’s not necessarily better.

6. BuildHeap Floyd’s Method. Thank you, Floyd.12 5 11 3 10 6 9 4 8 1 7 2
pretend it’s a heap and fix the heap-order property! 12 5 11
Pull other slide back up and ask how long it takes.
O(n log n) worst case, but O(n) average case.
Can we get a worst case O(n) bound?
Let’s try pretending it’s a heap already and just fixing the heap-order property.
The red nodes are the ones that are out of order.
Question: which nodes MIGHT be out of order in any heap? 3 10 6 9 4 8 1 7 2

7. Build(this)Heap 12 12 5 11 5 11 3 10 2 9 3 1 2 9 4 8 1 7 6 4 8 10 7 6 12 12 5 2 1 2 3 1 6 9 3 5 6 9 4 8 10 7 11 4 8 10 7 11

8. Finally… 1 3 2 4 5 6 9
How long does this take? Well, everything above the fringe might move 1 step.
Everything height 2 or greater might move 2 steps. …
In other words n * Sum I=0 to n of I/2i
But, this is (as n->inf) just 2. See chapter I to see why.
So, the runtime is O(n). 12 8 10 7 11
runtime:

9. Thinking about Heaps Observations Realities
finding a child/parent index is a multiply/divide by two
operations jump widely through the heap
each operation looks at only two new nodes
inserts are at least as common as deleteMins
Realities
division and multiplication by powers of two are fast
looking at one new piece of data sucks in a cache line
with huge data sets, disk accesses dominate
Now, let’s look at some facts about heaps and see if we can’t come up with a new priority queue implementation.

10. Solution: d-Heaps Each node has d children1
Each node has d children
Still representable by array
Good choices for d:
optimize performance based on # of inserts/removes
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 3 7 2 4 8 5 12 11 10 6 9
D-heaps address all these problems. 12 1 3 7 2 4 8 5 12 11 10 6 9

11. One More Operation Merge two heaps. Ideas?
Anyone have a way to merge two heaps? We’ll find out tomorrow that we can actually do this in O(log n) time!

12. To Do Turn in Project I (due today)
Start on Homework II (due Jan 20th)
Read chapter 6 in the book

13. Coming Up Mergeable heaps Dictionary ADT and Self-Balancing Trees
First project due (January 14th)
A day off (January 17th)!
Second homework assignment due (January 20th)
Again, turn in that next homework assignment with your score sheet!