cs 315 nov 14, 12 goals complete heap operations review insert, deletemin decreasekey, increasekey...
TRANSCRIPT
![Page 1: CS 315 Nov 14, 12 Goals Complete heap operations review insert, deletemin decreaseKey, increaseKey heap building Heap sorting Some applications of heap](https://reader036.vdocuments.site/reader036/viewer/2022062409/5697bfc81a28abf838ca8583/html5/thumbnails/1.jpg)
CS 315 Nov 14, 12
Goals• Complete heap operations
review insert, deletemin
decreaseKey, increaseKey
heap building
Heap sorting
Some applications of heap
![Page 2: CS 315 Nov 14, 12 Goals Complete heap operations review insert, deletemin decreaseKey, increaseKey heap building Heap sorting Some applications of heap](https://reader036.vdocuments.site/reader036/viewer/2022062409/5697bfc81a28abf838ca8583/html5/thumbnails/2.jpg)
Code for percolateDown
void percolateDown( int hole )
{
int child;
Comparable tmp = array[ hole ];
for( ; hole * 2 <= currentSize; hole = child )
{child = hole * 2;
if( child != currentSize && array[child +1] < array[ child ] )
child++;
if( array[ child ] < tmp )
array[ hole ] = array[ child ];
else
break;
}
array[ hole ] = tmp;
}
![Page 3: CS 315 Nov 14, 12 Goals Complete heap operations review insert, deletemin decreaseKey, increaseKey heap building Heap sorting Some applications of heap](https://reader036.vdocuments.site/reader036/viewer/2022062409/5697bfc81a28abf838ca8583/html5/thumbnails/3.jpg)
Code for percolateDown
void percolateDown( int hole )
{
int child;
Comparable tmp = array[ hole ];
for( ; hole * 2 <= currentSize; hole = child )
{
child = hole * 2;
if( child != currentSize && array[ child + 1 ] < array[ child ] )
child++;
if( array[ child ] < tmp )
array[ hole ] = array[ child ];
else
break;
}
array[ hole ] = tmp;
}
Summary: percolateDown(j) can be called when the heap property is violated at node j in that array[j] could be > array[2j] or array[2j+1]. (All the nodes in the subtree rooted at j satisfy the heap property.) After the call, the heap property is satisfied at all the nodes in the subtree rooted at j.
![Page 4: CS 315 Nov 14, 12 Goals Complete heap operations review insert, deletemin decreaseKey, increaseKey heap building Heap sorting Some applications of heap](https://reader036.vdocuments.site/reader036/viewer/2022062409/5697bfc81a28abf838ca8583/html5/thumbnails/4.jpg)
increaseKey operation
Suppose the priority of a key stored in position p changes. Specifically, we want to increase the key in A[p] by quantity d.
Example:
21
24
65 26 32
31 19
16
68
13p = 3, d = 6New key is 22
After changing the key to 22, call percolateDown(3)
Change this to 22
![Page 5: CS 315 Nov 14, 12 Goals Complete heap operations review insert, deletemin decreaseKey, increaseKey heap building Heap sorting Some applications of heap](https://reader036.vdocuments.site/reader036/viewer/2022062409/5697bfc81a28abf838ca8583/html5/thumbnails/5.jpg)
increaseKey operation
Example:
21
24
65 26 32
31 19
22
68
13percolateDown(3)
21
24
65 26 32
31 22
19
68
13
![Page 6: CS 315 Nov 14, 12 Goals Complete heap operations review insert, deletemin decreaseKey, increaseKey heap building Heap sorting Some applications of heap](https://reader036.vdocuments.site/reader036/viewer/2022062409/5697bfc81a28abf838ca8583/html5/thumbnails/6.jpg)
increaseKey operation
void increaseKey(int j, int d) {// change array[j] to array[j]+d and restore heap// d >= 0 is a pre-condition
array[j] += d; percolateDown(j);}
![Page 7: CS 315 Nov 14, 12 Goals Complete heap operations review insert, deletemin decreaseKey, increaseKey heap building Heap sorting Some applications of heap](https://reader036.vdocuments.site/reader036/viewer/2022062409/5697bfc81a28abf838ca8583/html5/thumbnails/7.jpg)
decreaseKey operation
In this case, we need to percolate the changed key up the heap.
Example: j = 4 and d = 12. Now, it is possible that array[j] is < array[j / 2] so we need to move the key up until the correct place is found.
21
24
65 26 32
31 19
16
68
13
Change to 12 13
21
65 26 32
31 19
16
68
12
![Page 8: CS 315 Nov 14, 12 Goals Complete heap operations review insert, deletemin decreaseKey, increaseKey heap building Heap sorting Some applications of heap](https://reader036.vdocuments.site/reader036/viewer/2022062409/5697bfc81a28abf838ca8583/html5/thumbnails/8.jpg)
decreaseKey operationvoid decreaseKey(int j, int d) {// change array[j] to array[j] – d and restore heap// d >= 0 is a pre-condition int temp = array[j]- d; while (j > 1 && array[j/2] > temp){ array[j] = array[j/2]; j/= 2; }; array[j] = temp; }
Note that this procedure is very similar to insert (shown below): void insert(const Comparble & x) { if (currentSize == array.size() – 1) array.reSize(array.size() * 2); //percolate up int hole = ++currentSize; for (; hole > 1 && x < array[ hole / 2]; hole/= 2) array[ hole ] = array[ hole / 2 ];
array[ hole ] = x;}
![Page 9: CS 315 Nov 14, 12 Goals Complete heap operations review insert, deletemin decreaseKey, increaseKey heap building Heap sorting Some applications of heap](https://reader036.vdocuments.site/reader036/viewer/2022062409/5697bfc81a28abf838ca8583/html5/thumbnails/9.jpg)
Removing a key at index p in a heap
Example: Remove key at index 5
21
24
65 26 32
31 19
22
68
13
Remove key
One way to do this:
• apply decreaseKey to make the key the smallest. (Ex: d = 32)
• perform deleteMin
What is the resulting heap?
![Page 10: CS 315 Nov 14, 12 Goals Complete heap operations review insert, deletemin decreaseKey, increaseKey heap building Heap sorting Some applications of heap](https://reader036.vdocuments.site/reader036/viewer/2022062409/5697bfc81a28abf838ca8583/html5/thumbnails/10.jpg)
Converting an array into a heap
We pass a vector items containing n (arbitrary) keys to the heap class constructor whose task it is to store these keys as a heap.
• Read these n keys into the heap array.
• call a procedure buildHeap to convert array into a heap.
binaryHeap(const vector<int> & items) { int n = items.size(); for (int i = 0; i < n; ++i) array[i+1] = items[i]; buildHeap(n);}
![Page 11: CS 315 Nov 14, 12 Goals Complete heap operations review insert, deletemin decreaseKey, increaseKey heap building Heap sorting Some applications of heap](https://reader036.vdocuments.site/reader036/viewer/2022062409/5697bfc81a28abf838ca8583/html5/thumbnails/11.jpg)
Converting an array into a heap
Starting with an arbitrary array, how to convert it to a heap?
Solution 1:We can view the array as a heap of size 1. Successively insert keys array[2], array[3], etc. into the heap until all the keys are inserted.
void buildHeap(int n) { currentSize = 1; for (int j= 2; j <= n; ++j) { insert(array[j]); } };
This takes O(n log n) time. (n operations each taking O(log n) time.)
![Page 12: CS 315 Nov 14, 12 Goals Complete heap operations review insert, deletemin decreaseKey, increaseKey heap building Heap sorting Some applications of heap](https://reader036.vdocuments.site/reader036/viewer/2022062409/5697bfc81a28abf838ca8583/html5/thumbnails/12.jpg)
Alternate (faster) way to buildHeap
Idea: perform percolateDown(j) starting from j = currentSize/2 to j = 1.
Why does it work? •Before percolateDown(j) is called, we have already performed percolateDown at 2j and 2j+1, and so in the subtree rooted at j, the only node where the heap property may not hold is j. • Thus, after percolateDown(j) is called, the subtree rooted at j is a heap.• The last call is percolateDown(1) so the tree rooted at 1 is a heap at the end.
Code for solution 2: void buildHeap2() { n = array.size(); currentSize = n; for (int j = n/2; j > 0; --j) percolateDown(j); }
![Page 13: CS 315 Nov 14, 12 Goals Complete heap operations review insert, deletemin decreaseKey, increaseKey heap building Heap sorting Some applications of heap](https://reader036.vdocuments.site/reader036/viewer/2022062409/5697bfc81a28abf838ca8583/html5/thumbnails/13.jpg)
BuildHeap using percolateDown is faster
Solution 2 builds a heap in O(n) time.
Analysis of this faster algorithm is presented in the text.
We will skip it since it is complicated.
(Involves summation of a series called the arithmetic-geometric series.)
![Page 14: CS 315 Nov 14, 12 Goals Complete heap operations review insert, deletemin decreaseKey, increaseKey heap building Heap sorting Some applications of heap](https://reader036.vdocuments.site/reader036/viewer/2022062409/5697bfc81a28abf838ca8583/html5/thumbnails/14.jpg)
Heap-sorting
To sort n numbers:
• read the numbers into an array A.
• call heap constructor to build a heap from A.
• perform n deleteMin operations. Store the successive outputs of deleteMin in the array A.
• A is now sorted.
Total number of operations = O(n) (for builing heap) + O(n log n) (for n deleteMin operations)
= O(n log n)
![Page 15: CS 315 Nov 14, 12 Goals Complete heap operations review insert, deletemin decreaseKey, increaseKey heap building Heap sorting Some applications of heap](https://reader036.vdocuments.site/reader036/viewer/2022062409/5697bfc81a28abf838ca8583/html5/thumbnails/15.jpg)
Heap-sorting
void sort(vector<Comparable>& out) { // the sorted array is output in array out out.resize(currentSize); int j=0; while (!isEmpty()) out[j++] = deleteMin();}
It is possible to collect the output in the heap array itself. As the heap size is shrinking, we can use the unused slots of the array to collect the delete min keys. The resulting heap will be sorted in descending order.
![Page 16: CS 315 Nov 14, 12 Goals Complete heap operations review insert, deletemin decreaseKey, increaseKey heap building Heap sorting Some applications of heap](https://reader036.vdocuments.site/reader036/viewer/2022062409/5697bfc81a28abf838ca8583/html5/thumbnails/16.jpg)
Heap-sorting animation
![Page 17: CS 315 Nov 14, 12 Goals Complete heap operations review insert, deletemin decreaseKey, increaseKey heap building Heap sorting Some applications of heap](https://reader036.vdocuments.site/reader036/viewer/2022062409/5697bfc81a28abf838ca8583/html5/thumbnails/17.jpg)
17
Application of Heaps: Interval Partitioning
Interval partitioning.
Lecture j starts at sj and finishes at fj. Goal: find minimum number of classrooms to
schedule all lectures so that no two occur at the same time in the same room.
Ex: This schedule uses 4 classrooms to schedule 10 lectures.
Time9 9:30 10 10:30 11 11:30 12 12:30 1 1:30 2 2:30
h
c
b
a
e
d g
f i
j
3 3:30 4 4:30
![Page 18: CS 315 Nov 14, 12 Goals Complete heap operations review insert, deletemin decreaseKey, increaseKey heap building Heap sorting Some applications of heap](https://reader036.vdocuments.site/reader036/viewer/2022062409/5697bfc81a28abf838ca8583/html5/thumbnails/18.jpg)
18
Interval Partitioning
Interval partitioning. Lecture j starts at sj and finishes at fj. Goal: find minimum number of classrooms to
schedule all lectures so that no two occur at the same time in the same room.
Ex: This schedule uses only 3.
Time9 9:30 10 10:30 11 11:30 12 12:30 1 1:30 2 2:30
h
c
a e
f
g i
j
3 3:30 4 4:30
d
b
![Page 19: CS 315 Nov 14, 12 Goals Complete heap operations review insert, deletemin decreaseKey, increaseKey heap building Heap sorting Some applications of heap](https://reader036.vdocuments.site/reader036/viewer/2022062409/5697bfc81a28abf838ca8583/html5/thumbnails/19.jpg)
19
Interval Partitioning: Lower Bound on Optimal
SolutionDef. The depth of a set of open intervals is the maximum number that contain any given time.
Key observation. Number of classrooms needed depth.
Ex: Depth of schedule below = 3 schedule below is optimal.
Q. Does there always exist a schedule equal to depth of intervals?
Time9 9:30 10 10:30 11 11:30 12 12:30 1 1:30 2 2:30
h
c
a e
f
g i
j
3 3:30 4 4:30
d
b
a, b, c all contain 9:30
![Page 20: CS 315 Nov 14, 12 Goals Complete heap operations review insert, deletemin decreaseKey, increaseKey heap building Heap sorting Some applications of heap](https://reader036.vdocuments.site/reader036/viewer/2022062409/5697bfc81a28abf838ca8583/html5/thumbnails/20.jpg)
20
Interval Partitioning: Greedy Algorithm
Greedy algorithm. Consider lectures in increasing order of start time: assign lecture to any compatible classroom.
Implementation. O(n log n). For each classroom k, maintain the finish time of the last job
added. Keep the classrooms in a priority queue.
Sort intervals by starting time so that s1 s2 ... sn.d 0
for j = 1 to n { if (lecture j is compatible with some classroom k) schedule lecture j in classroom k else allocate a new classroom d + 1 schedule lecture j in classroom d + 1 d d + 1 }
number of allocated classrooms
![Page 21: CS 315 Nov 14, 12 Goals Complete heap operations review insert, deletemin decreaseKey, increaseKey heap building Heap sorting Some applications of heap](https://reader036.vdocuments.site/reader036/viewer/2022062409/5697bfc81a28abf838ca8583/html5/thumbnails/21.jpg)
Machine Scheduling
m identical machines (drill press, cutter, sander, etc.)
n jobs/tasks to be performed assign jobs to machines so that the time at
which the last job completes is minimum
![Page 22: CS 315 Nov 14, 12 Goals Complete heap operations review insert, deletemin decreaseKey, increaseKey heap building Heap sorting Some applications of heap](https://reader036.vdocuments.site/reader036/viewer/2022062409/5697bfc81a28abf838ca8583/html5/thumbnails/22.jpg)
Another formulation of the same problem
A set of n items should be distributed to m people (or parties) so that each one gets nearly the same share as the others.
Each item has a weight (value).
![Page 23: CS 315 Nov 14, 12 Goals Complete heap operations review insert, deletemin decreaseKey, increaseKey heap building Heap sorting Some applications of heap](https://reader036.vdocuments.site/reader036/viewer/2022062409/5697bfc81a28abf838ca8583/html5/thumbnails/23.jpg)
Machine Scheduling Example
3 machines and 7 jobsjob times are [6, 2, 3, 5, 10, 7, 14]possible schedule
A
B
C
time ----------->
6
2
3
7
13
13
21
![Page 24: CS 315 Nov 14, 12 Goals Complete heap operations review insert, deletemin decreaseKey, increaseKey heap building Heap sorting Some applications of heap](https://reader036.vdocuments.site/reader036/viewer/2022062409/5697bfc81a28abf838ca8583/html5/thumbnails/24.jpg)
Machine Scheduling Example
Finish time = 21
Objective: Find schedules with minimum finish time.
A
B
Ctime ----------->
6
2
3
7
13
13
21
![Page 25: CS 315 Nov 14, 12 Goals Complete heap operations review insert, deletemin decreaseKey, increaseKey heap building Heap sorting Some applications of heap](https://reader036.vdocuments.site/reader036/viewer/2022062409/5697bfc81a28abf838ca8583/html5/thumbnails/25.jpg)
LPT Schedules
Longest Processing Time first. Jobs are scheduled in the order
14, 10, 7, 6, 5, 3, 2 Each job is scheduled on the machine on
which it finishes earliest. For each machine, maintain information
about when it is ready. Choice of data structure: priority queue
![Page 26: CS 315 Nov 14, 12 Goals Complete heap operations review insert, deletemin decreaseKey, increaseKey heap building Heap sorting Some applications of heap](https://reader036.vdocuments.site/reader036/viewer/2022062409/5697bfc81a28abf838ca8583/html5/thumbnails/26.jpg)
LPT Schedule
[14, 10, 7, 6, 5, 3, 2]
A
B
C
14
10
7 13
15
16
16
Finish time is 16!
![Page 27: CS 315 Nov 14, 12 Goals Complete heap operations review insert, deletemin decreaseKey, increaseKey heap building Heap sorting Some applications of heap](https://reader036.vdocuments.site/reader036/viewer/2022062409/5697bfc81a28abf838ca8583/html5/thumbnails/27.jpg)
LPT Schedule
LPT rule does not guarantee minimum finish time schedules.
Usually LPT finish time is very close to minimum finish time.
![Page 28: CS 315 Nov 14, 12 Goals Complete heap operations review insert, deletemin decreaseKey, increaseKey heap building Heap sorting Some applications of heap](https://reader036.vdocuments.site/reader036/viewer/2022062409/5697bfc81a28abf838ca8583/html5/thumbnails/28.jpg)
LPT implementation using a minheap
Minheap has the finish times of the m machines.
Initial finish times are all 0. To schedule a job remove the machine with
minimum finish time from the priority queue.
Update the finish time of the selected machine and put the machine back into the priority queue.
![Page 29: CS 315 Nov 14, 12 Goals Complete heap operations review insert, deletemin decreaseKey, increaseKey heap building Heap sorting Some applications of heap](https://reader036.vdocuments.site/reader036/viewer/2022062409/5697bfc81a28abf838ca8583/html5/thumbnails/29.jpg)
LPT implementation using a minheap
ListPtrs LPTschedule(vector<int> jobs, int m) {
// jobs is a sorted array of job durations, m is the
// number of machines
ListPtrs L(m); // array of m null pointers
BinaryHeap<pair> H;
for (int j=0; j < m ; ++j) {
pair p = new pair(j,0);
H.insert(p);
}
for (int j=0; j < jobs.size(); ++j) {
pair p = H.deleteMin();
int id = p.getId(); int ft = p.getFinishTime();
L[id].insert(j); ft+=jobs[j];
p = new pair(id, ft); H.insert(p);
}
}
![Page 30: CS 315 Nov 14, 12 Goals Complete heap operations review insert, deletemin decreaseKey, increaseKey heap building Heap sorting Some applications of heap](https://reader036.vdocuments.site/reader036/viewer/2022062409/5697bfc81a28abf838ca8583/html5/thumbnails/30.jpg)
LPT implementation using a min-heap
Sorting n jobs takes O(n log n) steps. Initialization of priority queue with m 0’s
• O(m) time One delete-min and one insert to schedule
each job• each put and remove min operation takes O(log
m) time time to schedule is O(m + n log m) overall time is
O(n log n + n log m + m)
![Page 31: CS 315 Nov 14, 12 Goals Complete heap operations review insert, deletemin decreaseKey, increaseKey heap building Heap sorting Some applications of heap](https://reader036.vdocuments.site/reader036/viewer/2022062409/5697bfc81a28abf838ca8583/html5/thumbnails/31.jpg)
Summary of heap
• binary heap is implemented as an array. (Tree representation is conceptual – for understanding, not explicit.)
• heap data members are: array (a vector) and currentSize.
• efficient heap operations: insert, findmin, deletemin, decreaseKey, increaseKey – all of which can be performed in O(log n), findmin can be done in O(1) in the worst-case.
• an important helper function is percolateDown. It also takes O(log n) time.
![Page 32: CS 315 Nov 14, 12 Goals Complete heap operations review insert, deletemin decreaseKey, increaseKey heap building Heap sorting Some applications of heap](https://reader036.vdocuments.site/reader036/viewer/2022062409/5697bfc81a28abf838ca8583/html5/thumbnails/32.jpg)
Summary of heap
• build-heap is the process of converting a set of keys into a heap-ordered array.
• build-heap can be performed in O(n log n) time by a series of n – 1 insertions.
• faster build-heap can be performed in O(n) time using n/2 percolate-down operations.
• heap-sorting takes O(n log n) in the worst-case• Step 1: build a heap• Step 2: perform n – 1 deleteMin operations and put the key at the end of the heap-array.
![Page 33: CS 315 Nov 14, 12 Goals Complete heap operations review insert, deletemin decreaseKey, increaseKey heap building Heap sorting Some applications of heap](https://reader036.vdocuments.site/reader036/viewer/2022062409/5697bfc81a28abf838ca8583/html5/thumbnails/33.jpg)
Summary of heap
• Some heap operations are expensive (i.e., can take n steps in the worst-case):
• search(x) – search for a key x.
• delete(x) – delete the key x (if present) in a heap
• Priority queue has many applications
• Example: scheduling problem, shortest-path problem (Dijkstra’s algorithm) etc.