Download presentation

Presentation is loading. Please wait.

Published byVirgil Jones Modified about 1 year ago

1
Priority Queues and Heaps Fundamental Data Structures and Algorithms Margaret Reid-Miller 29 January 2004

2
Plan Today Priority Queues Heaps Implementation questions Reading: For today: Chapters , 6.9 Reminder: Start HW3

3
We want to simulate a chain of events E i. Each event E i is associated with a time t i. No problem: sort the times, and run through them in order. t 1 < t 2 < t 3 <... < t n But what if an event can cause the creation of some new events in the future? A Simulation

4
We can still sort the original events by time, but not the additional ones: we don't yet know what/when they are. We need to be able to dynamically - insert an event into a data structure, and - extract the next event. And, of course, the operations should be cheap. A Simulation

5
Suppose a robot wants to cross a street. No jaywalking, it can only move straight forward or backward. Maximum speed of the robot is c. Cars are coming from either side, but the robot has complete information about when and where they cross your line. Problem: Find a way for the robot to get across without getting hit. An Example: Street Crossing

6
How do we model the given information? In space-time a car is just a rectangular box. Movement of the robot is constrained to a light- cone. More Street Crossing time space

7
Hugging an obstacle (not that unrealistic, just inflate the obstacles to account for safety buffer). More Street Crossing

8
Note how obstacles may be “fused” together. A Death Trap

9
The times when obstacles appear/disappear are clearly events. But there are more: The times when the robot touches an obstacle. Or when the light cones from both ends of a disappearing obstacle meet. Note that these events have to be computed as we go along, there is no way to compute them all at the outset. Street Crossing

10
Note how the first event happens before the first obstacle arrives! We need to go backwards in time, starting at the end of the last obstacle. Time Travel

11
How does this translate into a data structure? What are the crucial operations? What would be a simple (not necessarily efficient) implementation? Where is room for improvement? Towards An Algorithm

12
The priority queue interface A Priority Queue maintains a dynamic set of comparable objects where only have access to the smallest object: Insert findMin deleteMin As usual, we consider storing only simple items. But in practice store pairs (key, object).

13
Priority Queues: Applications Event simulations (key is time) Shortest paths in a graph Huffman codes Sorting (sort of) Not a universal data structure (like hash tables) but irreplaceable in some cases.

14
Linked list deleteMinO(1)O(N) insert O(N)O(1) Search trees All operationsO(log N) Heaps avg (assume random)worst deleteMinO(log N) O(log N) insert2.6O(log N) special case : buildheapO(N)O(N) i.e., insert*N or Possible priority queue implementations

15
Linked list deleteMinO(1)O(N) insert O(N)O(1) Search trees All operationsO(log N) Heaps avg (assume random)worst deleteMinO(log N) O(log N) insert2.6O(log N) special case : buildheapO(N)O(N) i.e., insert*N or Possible priority queue implementations

16
Linked list deleteMinO(1)O(N) insert O(N)O(1) Search trees All operationsO(log N) Heaps avg (assume random)worst deleteMinO(log N) O(log N) insert2.6O(log N) buildheapO(N)O(N) N inserts or Possible priority queue implementations

17
A Digression: Perfect and Complete Binary Trees

18
Perfect binary trees

19
Perfect binary trees

20
Perfect binary trees

21
Perfect binary trees How many nodes? h=3 N=15

22
Perfect binary trees How many nodes? In general: N = = 2 h Most of the nodes are leaves h=3h=3 N=15

23
A Serious Proof Define PBT by structural induction: - nil is a PBT and H(nil) = 0 - (a,L,R) is a PBT whenever L and R are PBTs and H(L) = H(R). Moreover, H( (a,L,R) ) = H(L) + 1. size(nil) = 0 size( (a,L,R) ) = size(L) + size(R) + 1. Then size(T) = 2 H(T) -1.

24
Quiz Break

25
Red-green quiz In a perfect binary tree, what is the sum of the heights of the nodes? Give a mathematical characterization, the prettier the better. Give a tight upper bound (in big-O terms)

26
Perfect binary trees What is the sum of the heights? S = < N = O(N) h=3 N=15

27
Complete binary trees

28
Complete binary trees

29
Representing complete binary trees Linked structures?

30
Representing complete binary trees Linked structures? No! Instead, use arrays!

31
Representing complete binary trees Arrays Parent at position i in the array Children at positions 2i and 2i

32
Representing complete binary trees Arrays ( 1-based ) Parent at position i Children at 2i and 2i

33
Representing complete binary trees Arrays ( 1-based ) Parent at position i Children at 2i and 2i

34
Representing complete binary trees Arrays ( 1-based ) Parent at position i Children at 2i (and 2i+1)

35
Representing complete binary trees Arrays ( 1-based ) Parent at position i Children at 2i and 2i+1. public class BinaryHeap { private Comparable[] heap; private int size; public BinaryHeap(int capacity) { size=0; heap = new Comparable[capacity+1]; }...

36
Representing complete binary trees Arrays Parent at position i Children at 2i and 2i+1. Example: find the leftmost child int left=1; for(; left

37
Quiz Break What index is the parent of node i? What would the array representation be for a complete tertiary tree? I.e., In a 3-way complete tree which indices are the children of node i? What is its parent index?

38
Implementing Priority Queues with Binary Heaps

39
Binary heaps: the invariant Representation invariants 1. Structure property Complete binary tree (i.e. the elements of the heap are stored in positions 1…size of the array) 2. Heap order property Parent keys less than children keys

40
Heaps Representation invariant 1. Structure property Complete binary tree Hence: efficient compact representation 2. Heap order property Parent keys less than children keys Hence: rapid insert, findMin, and deleteMin O(log(N)) for insert and deleteMin O(1) for findMin

41
The heap order property Each parent is less than each of its children. Hence: Root is less than every other node. (obvious proof by induction)

42
Operating with heaps Representation invariant: All methods must: 1. Produce complete binary trees 2. Guarantee the heap order property All methods may assume 1. The tree is initially complete binary 2. The heap order property holds

43
Constructor method All methods must: 1. Produce complete binary trees Trivially true 2. Guarantee the heap order property Also trivially true This is the base case

44
findMin () The code public boolean isEmpty() { return size == 0; } public Comparable findMin() { if(isEmpty()) return null; return heap[1]; } Does not change the tree Trivially preserves the invariant

45
insert (Comparable x) Process 1. Create a “hole” for x at the next tree leaf heap[size+1] This preserves the completeness of the tree. 2. Percolate the hole up the tree until the heap order property is satisfied. This assures the heap order property is satisfied.

46
insert (Comparable x) Process 1. Create a “hole” at the next tree cell for x. heap[size+1] This preserves the completeness of the tree assuming it was complete to begin with. 2. Percolate the hole up the tree until the heap order property is satisfied. This assures the heap order property is satisfied assuming it held at the outset.

47
Complete the binary tree Not really there... 21

48
Percolation up Bubble the hole up the tree until the heap order property is satisfied. hole = 11hole = 5 HOP falseHOP false

49
Percolation up Bubble the hole up the tree until the heap order property is satisfied. hole = 5hole = 2 HOP falseHOP true done

50
Percolation up public void insert(Comparable x) throws Overflow { if(isFull()) throw new Overflow(); int hole = ++size; for(; hole>1 && x.compareTo(heap[hole/2])<0; hole/=2) heap[hole] = heap[hole/2]; heap[hole] = x; }

51
Percolation up public void insert(Comparable x) throws Overflow { if(isFull()) throw new Overflow(); int hole = ++size; for(; hole>1 && x.compareTo(heap[hole/2])<0; hole/=2) heap[hole] = heap[hole/2]; heap[hole] = x; } Integer division

52
deleteMin() /** * Remove the smallest item from the priority queue. the smallest item, or null, if empty. */ public Comparable deleteMin( ) { if(isEmpty()) return null; Comparable min = heap[1]; heap[1] = heap[size--]; percolateDown(1); return min; } Temporarily place last element at top Grab min element !!!

53
Complete binary tree Establish the compete binary tree property by moving leaf to root

54
Percolation down Bubble the transplanted leaf value down the tree until the heap order property is satisfied

55
Percolation down Bubble the transplanted leaf value down the tree until the heap order property is satisfied done

56
percolateDown(int hole) private void percolateDown( int hole ) { int child = hole; Comparable tmp = heap[hole]; for( ; hole*2 <= size; hole=child ) { child = hole * 2; if(child!=size && heap[child+1].compareTo(heap[child]) < 0) child++; if(array[child].compareTo(tmp) < 0) heap[hole] = heap[child]; else break; } heap[hole] = tmp; } Is there a right child? Bubble up if smaller than tmp Initially 1 Select smaller child Finally, place the orphan Start at left child Exit loop if not bubbling

57
deleteMin () Observe that both components of the representation invariant are preserved by deleteMin. 1. Completeness The last cell ( heap[size] ) is vacated, providing the value to percolate down. This assures that the tree remains complete. 2. Heap order property

58
deleteMin () Observe that both components of the representation invariant are preserved by deleteMin. 1. Completeness The last cell ( heap[size] ) is vacated, providing the value to percolate down. This assures that the tree remains complete. 2. Heap order property

59
deleteMin () Observe that both components of the representation invariant are preserved by deleteMin. 1. Completeness The last cell ( heap[size] ) is vacated, providing the value to percolate down. This assures that the tree remains complete. 2. Heap order property The percolation algorithm assures that the orphaned value is relocated to a suitable position.

60
buildHeap() Start with complete (unordered) tree Starting from bottom, repeatedly call percolateDown() Void buildHeap () { for (int i = size/2; i>0; i--) percolateDown(i); }

61
buildHeap() performance At each iteration, have to do work proportional to the height of the current node Therefore, total running time is bounded by the sum of the heights of all of the nodes

62
Another Digression: Invariants

63
Representation Invariants Necessary for a clear understand an algorithm or piece of code. The most useful kind of comment you can make in a piece of code!

64
(Invariants) Plus ça change, plus c’est la même chose. The role of an induction hypothesis

65
(Invariants and induction) Induction hypothesis What you are allowed to assume At the start About the result values of a recursive call About the object state when a method is called What you must deliver At the end Of the result values when the recursive call returns About the object state when the method returns

66
(Invariants and induction) Induction hypothesis What you are allowed to assume At the start of a loop iteration About the result values of a recursive call About the object state when a method is called What you must deliver At the end of the loop iteration Of the result values when the recursive call returns About the object state when the method returns

67
(Invariants and induction) Induction hypothesis What you are allowed to assume About the result values of a recursive call About the object state when a method is called What you must deliver Of the result values when the recursive call returns About the object state when the method returns

68
(Invariants and induction) Induction hypothesis What you are allowed to assume At the start of a loop iteration About the result values of a recursive call About the object state when a method is called What you must deliver At the end of the loop iteration Of the result values when the recursive call returns About the object state when the method returns

69
(Invariants and induction) Induction hypothesis What you are allowed to assume At the start of a loop iteration About the result values of a recursive call About the object state when a method is called What you must deliver At the end of the loop iteration Of the result values when the recursive call returns About the object state when the method returns

70
(Invariants) Plus ça change, plus c’est la même chose The role of an induction hypothesis Invariants in programs Loop invariants Recursion invariants Representation invariants

71
(Representation invariant) What must always be true of the data structure when an operation completes. Theorem : Suppose each constructor assures the representation invariant is initially correct. Suppose each method preserves the representation invariant, assuming it is true initially. Then the representation invariant will always be true at the completion of each method.

72
(Representation invariant) What must always be true of the data structure when an operation completes. Theorem : Suppose each constructor assures the representation invariant is initially correct. Suppose each method preserves the representation invariant, assuming it is true initially. Then the representation invariant will always be true at the completion of each method.

73
(Representation invariants) What must always be true of the data structure when an operation completes. Theorem: Suppose each constructor assures the representation invariant is initially correct. Suppose each method preserves the representation invariant, assuming it is true initially. Then the representation invariant will always be true at the completion of each method. Assuming the code is not concurrent!

74
Heapsort Obviously we can use a priority queue to sort... just insert all the keys then do repeated deleteMins However we can take advantage of the fact that the heap always uses the first part of the array to do this with no extra space. This is called heapsort.

75
Heapsort Reverse the sense of the heap order (largest at the root) Start from position 0 in the array (children are 2i+1 and 2i+2) Call percDown(a, i, len) Public static void heapsort(Comparable[] a) { for(int i = a.length/2; i>=0; i--) percDown(a, i, a.length); for (int j = a.length-1; j>0; j--) { swapReferences(a, 0, j); percDown(a, 0, j); }

76
Heapsort invariant At the start of the loop over j: a[j+1]…a[a.length-1] are sorted a[0]…a[j] are a heap

77
Homework 3 On Blackboard. You’re all working on it already. Right?

Similar presentations

© 2017 SlidePlayer.com Inc.

All rights reserved.

Ads by Google