1. Source: Muangsin / Weiss
Priority Queue (Heap)
A kind of queue
Dequeue gets element with the highest priority
Priority is based on a comparable value (key) of each object (smaller value higher priority, or higher value higher priority)
Example Applications:
printer -> print (dequeue) the shortest document first
operating system -> run (dequeue) the shortest job first
normal queue -> dequeue the first enqueued element first
Source: Muangsin / Weiss

2. Priority Queue (Heap) Operations
deleteMin
insert
insert (enqueue)
deleteMin (dequeue)
smaller value higher priority
Find / save the minimum element, delete it from structure and return it
Source: Muangsin / Weiss

3. Implementation using Linked List
Unsorted linked list
insert takes O(1) time
deleteMin takes O(N) time
Sorted linked list
insert takes O(N) time
deleteMin takes O(1) time
Source: Muangsin / Weiss

4. Implementation using Binary Search Tree
insert takes O(log N) time
deleteMin takes O(log N) time
support other operations that are not required by priority queue (for example, findMax)
deleteMin operations make the tree unbalanced
Source: Muangsin / Weiss

5. Terminology: full tree
completely filled (bottom level is filled from left to right
size between 2h (bottom level has only one node) and 2h+1-1 A C G F B E J D H I
Source: Muangsin / Weiss

6. Heap: Order Property (for Minimum Heap)
Any node is smaller than (or equal to) all of its children (any subtree is a heap)
Smallest element is at the root (findMin take O(1) time) 13 16 68 19 21 31 32 24 65 26
Source: Muangsin / Weiss

7. Source: Muangsin / Weiss
Insert
Create a hole in the next available location
Move the hole up (swap with its parent) until data can be placed in the hole without violating the heap order property (called percolate up) 13 16 68 19 21 31 32 24 65 26 13 16 68 19 21 32 24 65 26 31
Source: Muangsin / Weiss

8. Source: Muangsin / Weiss
Insert
insert 14 13 16 68 19 21 31 32 24 65 26 13 16 68 19 21 32 24 65 26 31
Percolate Up -> move the place to put 14 up
(move its parent down) until its parent <= 14
Source: Muangsin / Weiss

9. Source: Muangsin / Weiss
Insert 13 16 68 19 21 31 32 24 65 26 13 16 68 19 21 31 32 24 65 26 14
Source: Muangsin / Weiss

10. Source: Muangsin / Weiss
deleteMin
Create a hole at the root
Move the hole down (swap with the smaller one of its children) until the last element of the heap can be placed in the hole without violating the heap order property (called percolate down) 13 16 68 19 21 31 32 65 26 14 16 68 19 21 32 65 26 14 31
Source: Muangsin / Weiss

11. Source: Muangsin / Weiss
deleteMin 13 16 68 19 21 31 32 65 26 14 16 68 19 21 32 65 26 14 31
Percolate Down -> move the place to put 31 down (move its smaller child up) until its children >= 31
Source: Muangsin / Weiss

12. Source: Muangsin / Weiss
deleteMin 16 68 19 21 32 65 26 14 31 16 68 19 21 32 65 26 14 31
Source: Muangsin / Weiss

13. Source: Muangsin / Weiss
deleteMin 16 68 19 21 32 65 14 31 26 16 68 19 21 32 65 26 14 31
Source: Muangsin / Weiss

14. Source: Muangsin / Weiss
Running Time
insert
worst case: takes O(log N) time, moves an element from the bottom to the top
on average: takes a constant time (2.607 comparisons), moves an element up levels
deleteMin
worst case: takes O(log N) time
on average: takes O(log N) time (element that is placed at the root is large, so it is percolated almost to the bottom)
Source: Muangsin / Weiss

15. Array Implementation of Binary HeapC G F B E J D H I
left child is in position 2i
right child is in position (2i+1)
parent is in position i/2 A B C D E F G H I J 1 2 3 4 5 6 7 8 9 10 11 12 13
Source: Muangsin / Weiss