CSE 326: Data Structures Lecture #13 Priority Queues and Binary Heaps Nick Deibel Winter Quarter...
-
Upload
gerald-woods -
Category
Documents
-
view
218 -
download
1
Transcript of CSE 326: Data Structures Lecture #13 Priority Queues and Binary Heaps Nick Deibel Winter Quarter...
![Page 1: CSE 326: Data Structures Lecture #13 Priority Queues and Binary Heaps Nick Deibel Winter Quarter 2002.](https://reader036.fdocuments.net/reader036/viewer/2022062516/56649e5c5503460f94b54300/html5/thumbnails/1.jpg)
CSE 326: Data StructuresLecture #13
Priority Queues and Binary Heaps
Nick Deibel
Winter Quarter 2002
![Page 2: CSE 326: Data Structures Lecture #13 Priority Queues and Binary Heaps Nick Deibel Winter Quarter 2002.](https://reader036.fdocuments.net/reader036/viewer/2022062516/56649e5c5503460f94b54300/html5/thumbnails/2.jpg)
Not Quite Queues
• Consider applications– ordering CPU jobs
– searching for the exit in a maze
– emergency room admission processing
• Problems?– short jobs should go first
– most promising nodes should be searched first
– most urgent cases should go first
![Page 3: CSE 326: Data Structures Lecture #13 Priority Queues and Binary Heaps Nick Deibel Winter Quarter 2002.](https://reader036.fdocuments.net/reader036/viewer/2022062516/56649e5c5503460f94b54300/html5/thumbnails/3.jpg)
Priority Queue ADT
• Priority Queue operations– create
– destroy
– insert
– deleteMin
– is_empty
• Priority Queue property: for two elements in the queue, x and y, if x has a lower priority value than y, x will be deleted before y
F(7) E(5) D(100) A(4)
B(6)
insert deleteMinG(9) C(3)
![Page 4: CSE 326: Data Structures Lecture #13 Priority Queues and Binary Heaps Nick Deibel Winter Quarter 2002.](https://reader036.fdocuments.net/reader036/viewer/2022062516/56649e5c5503460f94b54300/html5/thumbnails/4.jpg)
Applications of the Priority Q
• Hold jobs for a printer in order of length• Store packets on network routers in order of
urgency• Sort numbers • Simulate events• Anything greedy
![Page 5: CSE 326: Data Structures Lecture #13 Priority Queues and Binary Heaps Nick Deibel Winter Quarter 2002.](https://reader036.fdocuments.net/reader036/viewer/2022062516/56649e5c5503460f94b54300/html5/thumbnails/5.jpg)
Discrete Event Simulation
• An event is a pair (x,t) where x describes the event and t is time it should occur
• A discrete event simulator (DES) maintains a set S of events which it intends to simulate in time order
repeat {
Find and remove (x0,t0) from S such that t0 minimal;
Do whatever x0 says to do, in the process new events (x2,t2)…(xk,tk) may be generated;
Insert the new events into S; }
![Page 6: CSE 326: Data Structures Lecture #13 Priority Queues and Binary Heaps Nick Deibel Winter Quarter 2002.](https://reader036.fdocuments.net/reader036/viewer/2022062516/56649e5c5503460f94b54300/html5/thumbnails/6.jpg)
Emergency Room Simulation • Two priority queues: time and criticality• K doctors work in an emergency room• events:
– patients arrive with injury of criticality C at time t (according to some probability distribution)
• Processing: if no patients waiting and a free doctor, assign them to doctor and create a future departure event; else put patient in the Criticality priority queue
– patient departs• If someone in Criticality queue, pull out most critical and assign to
doctor
• How long will a patient have to wait? Will people die?
![Page 7: CSE 326: Data Structures Lecture #13 Priority Queues and Binary Heaps Nick Deibel Winter Quarter 2002.](https://reader036.fdocuments.net/reader036/viewer/2022062516/56649e5c5503460f94b54300/html5/thumbnails/7.jpg)
Naïve Priority Queue Data Structures
• Unsorted list:– insert:
– deleteMin:
• Sorted list:– insert:
– deleteMin:
![Page 8: CSE 326: Data Structures Lecture #13 Priority Queues and Binary Heaps Nick Deibel Winter Quarter 2002.](https://reader036.fdocuments.net/reader036/viewer/2022062516/56649e5c5503460f94b54300/html5/thumbnails/8.jpg)
BST Tree Priority Queue Data Structure
4
121062
115
8
14137 9
•Regular BST:–insert:
–deleteMin:
•AVL Tree:–insert:
–deleteMin:Can we do better?
![Page 9: CSE 326: Data Structures Lecture #13 Priority Queues and Binary Heaps Nick Deibel Winter Quarter 2002.](https://reader036.fdocuments.net/reader036/viewer/2022062516/56649e5c5503460f94b54300/html5/thumbnails/9.jpg)
Binary Heap Priority Q Data Structure
201412911
81067
54
2
• Heap-order property– parent’s key is less than
children’s keys
– result: minimum is always at the top
• Structure property– complete tree with fringe
nodes packed to the left
– result: depth is always O(log n); next open location always known
How do we find the minimum?
![Page 10: CSE 326: Data Structures Lecture #13 Priority Queues and Binary Heaps Nick Deibel Winter Quarter 2002.](https://reader036.fdocuments.net/reader036/viewer/2022062516/56649e5c5503460f94b54300/html5/thumbnails/10.jpg)
201412911
81067
54
2
2 4 5 7 6 10 8 11 9 12 14 2012
1 2 3 4 5 6 7 8 9 10 11 12
1
2 3
4 5 6 7
8 9
10 11 12
Nifty Storage Trick• Calculations:
– child:
– parent:
– root:
– next free:
0
![Page 11: CSE 326: Data Structures Lecture #13 Priority Queues and Binary Heaps Nick Deibel Winter Quarter 2002.](https://reader036.fdocuments.net/reader036/viewer/2022062516/56649e5c5503460f94b54300/html5/thumbnails/11.jpg)
DeleteMin
201412911
81067
54
?2
201412911
81067
54
2
pqueue.deleteMin()
![Page 12: CSE 326: Data Structures Lecture #13 Priority Queues and Binary Heaps Nick Deibel Winter Quarter 2002.](https://reader036.fdocuments.net/reader036/viewer/2022062516/56649e5c5503460f94b54300/html5/thumbnails/12.jpg)
Percolate Down
201412911
81067
54
?
201412911
81067
5?
4
201412911
810?7
56
4
201420911
810127
56
4
![Page 13: CSE 326: Data Structures Lecture #13 Priority Queues and Binary Heaps Nick Deibel Winter Quarter 2002.](https://reader036.fdocuments.net/reader036/viewer/2022062516/56649e5c5503460f94b54300/html5/thumbnails/13.jpg)
Finally…
1420911
810127
56
4
![Page 14: CSE 326: Data Structures Lecture #13 Priority Queues and Binary Heaps Nick Deibel Winter Quarter 2002.](https://reader036.fdocuments.net/reader036/viewer/2022062516/56649e5c5503460f94b54300/html5/thumbnails/14.jpg)
DeleteMin CodeObject deleteMin() {
assert(!isEmpty());
returnVal = Heap[1];
size--;
newPos =
percolateDown(1,
Heap[size+1]);
Heap[newPos] =
Heap[size + 1];
return returnVal;
}
int percolateDown(int hole, Object val) {while (2*hole <= size) { left = 2*hole; right = left + 1; if (right <= size && Heap[right] < Heap[left]) target = right; else target = left;
if (Heap[target] < val) { Heap[hole] = Heap[target]; hole = target; } else break; } return hole;}
runtime:
![Page 15: CSE 326: Data Structures Lecture #13 Priority Queues and Binary Heaps Nick Deibel Winter Quarter 2002.](https://reader036.fdocuments.net/reader036/viewer/2022062516/56649e5c5503460f94b54300/html5/thumbnails/15.jpg)
Insert
201412911
81067
54
2
201412911
81067
54
2
pqueue.insert(3)
?
![Page 16: CSE 326: Data Structures Lecture #13 Priority Queues and Binary Heaps Nick Deibel Winter Quarter 2002.](https://reader036.fdocuments.net/reader036/viewer/2022062516/56649e5c5503460f94b54300/html5/thumbnails/16.jpg)
Percolate Up
201412911
81067
54
2
? 201412911
8?67
54
2
10
201412911
8567
?4
2
10 201412911
8567
34
2
10
3
3
3
![Page 17: CSE 326: Data Structures Lecture #13 Priority Queues and Binary Heaps Nick Deibel Winter Quarter 2002.](https://reader036.fdocuments.net/reader036/viewer/2022062516/56649e5c5503460f94b54300/html5/thumbnails/17.jpg)
Insert Codevoid insert(Object o) {
assert(!isFull());
size++;
newPos =
percolateUp(size,o);
Heap[newPos] = o;
}
int percolateUp(int hole, Object val) { while (hole > 1 && val < Heap[hole/2]) Heap[hole] = Heap[hole/2]; hole /= 2; } return hole;}
runtime:
![Page 18: CSE 326: Data Structures Lecture #13 Priority Queues and Binary Heaps Nick Deibel Winter Quarter 2002.](https://reader036.fdocuments.net/reader036/viewer/2022062516/56649e5c5503460f94b54300/html5/thumbnails/18.jpg)
Performance of Binary Heap
• In practice: binary heaps much simpler to code, lower constant factor overhead
Binary heap
worst case
Binary heap avg case
AVL tree worst case
AVL tree avg case
Insert O(log n) O(1)
percolates 1.6 levels
O(log n) O(log n)
Delete Min
O(log n) O(log n) O(log n) O(log n)
![Page 19: CSE 326: Data Structures Lecture #13 Priority Queues and Binary Heaps Nick Deibel Winter Quarter 2002.](https://reader036.fdocuments.net/reader036/viewer/2022062516/56649e5c5503460f94b54300/html5/thumbnails/19.jpg)
Changing Priorities
• In many applications the priority of an object in a priority queue may change over time– if a job has been sitting in the printer queue for a long
time increase its priority
– unix “renice”
• Must have some (separate) way of find the position in the queue of the object to change (e.g. a hash table)
![Page 20: CSE 326: Data Structures Lecture #13 Priority Queues and Binary Heaps Nick Deibel Winter Quarter 2002.](https://reader036.fdocuments.net/reader036/viewer/2022062516/56649e5c5503460f94b54300/html5/thumbnails/20.jpg)
Other Priority Queue Operations
• decreaseKey – given the position of an object in the queue, reduce its priority
value
• increaseKey– given the position of an an object in the queue, increase its priority
value
• remove– given the position of an an object in the queue, remove it
• buildHeap– given a set of items, build a heap
![Page 21: CSE 326: Data Structures Lecture #13 Priority Queues and Binary Heaps Nick Deibel Winter Quarter 2002.](https://reader036.fdocuments.net/reader036/viewer/2022062516/56649e5c5503460f94b54300/html5/thumbnails/21.jpg)
DecreaseKey, IncreaseKey, and Remove
void decreaseKey(int pos, int delta){
temp = Heap[pos] - delta;
newPos = percolateUp(pos, temp);
Heap[newPos] = temp;
}
void increaseKey(int pos, int delta) {
temp = Heap[pos] + delta;
newPos = percolateDown(pos, temp);
Heap[newPos] = temp;
}
void remove(int pos) { percolateUp(pos, NEG_INF_VAL); deleteMin();}
![Page 22: CSE 326: Data Structures Lecture #13 Priority Queues and Binary Heaps Nick Deibel Winter Quarter 2002.](https://reader036.fdocuments.net/reader036/viewer/2022062516/56649e5c5503460f94b54300/html5/thumbnails/22.jpg)
BuildHeapFloyd’s Method. Thank you, Floyd.
5 11 3 10 6 9 4 8 1 7 212
pretend it’s a heap and fix the heap-order property!
27184
96103
115
12Easy worst case bound:
Easy average case bound:
![Page 23: CSE 326: Data Structures Lecture #13 Priority Queues and Binary Heaps Nick Deibel Winter Quarter 2002.](https://reader036.fdocuments.net/reader036/viewer/2022062516/56649e5c5503460f94b54300/html5/thumbnails/23.jpg)
Build(this)Heap
67184
92103
115
12
671084
9213
115
12
1171084
9613
25
12
1171084
9653
21
12
![Page 24: CSE 326: Data Structures Lecture #13 Priority Queues and Binary Heaps Nick Deibel Winter Quarter 2002.](https://reader036.fdocuments.net/reader036/viewer/2022062516/56649e5c5503460f94b54300/html5/thumbnails/24.jpg)
Finally…
11710812
9654
23
1
runtime?
![Page 25: CSE 326: Data Structures Lecture #13 Priority Queues and Binary Heaps Nick Deibel Winter Quarter 2002.](https://reader036.fdocuments.net/reader036/viewer/2022062516/56649e5c5503460f94b54300/html5/thumbnails/25.jpg)
Complexity of Build Heap• Note: size of a perfect binary tree doubles (+1)
with each additional layer• At most n/4 percolate down 1 level
at most n/8 percolate down 2 levelsat most n/16 percolate down 3 levels…
O(n)nnin
ni
nnn
n
ii
n
ii
)2(222
2163
82
41
log
1
log
11
![Page 26: CSE 326: Data Structures Lecture #13 Priority Queues and Binary Heaps Nick Deibel Winter Quarter 2002.](https://reader036.fdocuments.net/reader036/viewer/2022062516/56649e5c5503460f94b54300/html5/thumbnails/26.jpg)
Proof of Summation
2112
11
24
2
4
3
2
1
2
212
24
3
2
212
22
1
8
3
4
2
2
1
2
1
1
1
11
x
ii
x
x
xx
x
ii
S
xSSS
xS
xxiS
![Page 27: CSE 326: Data Structures Lecture #13 Priority Queues and Binary Heaps Nick Deibel Winter Quarter 2002.](https://reader036.fdocuments.net/reader036/viewer/2022062516/56649e5c5503460f94b54300/html5/thumbnails/27.jpg)
Heap Sort• Input: unordered array A[1..N]
1. Build a max heap (largest element is A[1])
2. For i = 1 to N-1:A[N-i+1] = Delete_Max()
7 50 22 15 4 40 20 10 35 25
50 40 20 25 35 15 10 22 4 7
40 35 20 25 7 15 10 22 4 50
35 25 20 22 7 15 10 4 40 50
![Page 28: CSE 326: Data Structures Lecture #13 Priority Queues and Binary Heaps Nick Deibel Winter Quarter 2002.](https://reader036.fdocuments.net/reader036/viewer/2022062516/56649e5c5503460f94b54300/html5/thumbnails/28.jpg)
Properties of Heap Sort
• Worst case time complexity O(n log n)– Build_heap O(n)
– n Delete_Max’s for O(n log n)
• In-place sort – only constant storage beyond the array is needed
![Page 29: CSE 326: Data Structures Lecture #13 Priority Queues and Binary Heaps Nick Deibel Winter Quarter 2002.](https://reader036.fdocuments.net/reader036/viewer/2022062516/56649e5c5503460f94b54300/html5/thumbnails/29.jpg)
Thinking about Heaps
• Observations– 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 terrible in a cache line
– with huge data sets, disk accesses dominate
![Page 30: CSE 326: Data Structures Lecture #13 Priority Queues and Binary Heaps Nick Deibel Winter Quarter 2002.](https://reader036.fdocuments.net/reader036/viewer/2022062516/56649e5c5503460f94b54300/html5/thumbnails/30.jpg)
4
9654
23
1
8 1012
7
11
Solution: d-Heaps
• 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 8 5 12 11 10 6 9112
What do d-heaps remind us of???
![Page 31: CSE 326: Data Structures Lecture #13 Priority Queues and Binary Heaps Nick Deibel Winter Quarter 2002.](https://reader036.fdocuments.net/reader036/viewer/2022062516/56649e5c5503460f94b54300/html5/thumbnails/31.jpg)
Coming Up
• Thursday: Quiz Section is Midterm Review– Come with questions!
• Friday: Midterm Exam– Bring pencils
• Monday:– Mergeable Heaps
– 3rd Programming project