CMSC 341 Lecture 14: Priority Queues, Heaps

Transcription

1 CMSC 341 Lecture 14: Priority Queues, Heaps Prof. John Park Based on slides from previous iterations of this course

2 Today s Topics Priority Queues Abstract Data Type Implementations of Priority Queues: Lists BSTs Heaps Heaps Properties Insertion Deletion UMBC CMSC 341 Priority Queues (Heaps) 2

3 Priority Queues and Heaps 3

4 Priority Queue ADT A priority queue stores a collection of entries Typically, an entry is a pair (key, value) where the key indicates the priority Smaller value, higher priority Keys in a priority queue can be arbitrary objects on which an order is defined UMBC CMSC 341 Priority Queues (Heaps) 4

5 Priority Queue vs Queue Priority queue is a specific type of queue Queues are FIFO The element in the queue for the longest time is the first one we take out Priority queues: most important, first out The element in the priority queue with the highest priority is the first one we take out Examples: emergency rooms, airline boarding UMBC CMSC 341 Priority Queues (Heaps) 5

6 Implementing Priority Queues Priority queues are an Abstract Data Type They are a concept, and hence there are many different ways to implement them Possible implementations include A sorted list An ordinary BST A balanced BST Run time will vary based on implementation UMBC CMSC 341 Priority Queues (Heaps) 6

7 Implementing a Priority Queue 7

8 Priority Queue: Unsorted List We can implement a priority queue with a simple unsorted list (array, vector, etc.) Insertion just adds element to end of list Enqueuing new element takes O(1) time However, to find the highest priority, must find MIN(entire list), which takes O(n) time UMBC CMSC 341 Priority Queues (Heaps) 8

9 Priority Queue: Sorted List We can implement a priority queue with a sorted list (array, vector, etc.) Sorted by priority upon insertion To find the highest priority, simply take the first element, in O(1) time findmin() --> list.front() Insertion can take O(n) time, however UMBC CMSC 341 Priority Queues (Heaps) 9

10 Priority Queue: BST A BST makes a bit more sense than a list Sorted like a regular BST upon insertion To find the minimum, just go to the left call findmin() And removal will be easy, because it will always be a leaf node! Insertion should take no more than O(log n) time call Insert() UMBC CMSC 341 Priority Queues (Heaps) 10

11 Priority Queue: BST Downsides Unfortunately, a BST Priority Queue can become unbalanced very easily, and the actual run time will suffer If we have a low priority (high value) instance as our root, nearly everything will be to its left findmin() is now O(n) time UMBC CMSC 341 Priority Queues (Heaps) 11

12 Priority Queue: Heap The most common way to implement a priority queue is using a heap A heap is a binary tree (not a BST!!!) that satisfies the heap condition : Nodes in the tree are sorted based in relation to their parent s value, such that if A is a parent node of B, then the key of node A is ordered with respect to the key of node B with the same ordering applying across the heap Additionally, the tree must be complete UMBC CMSC 341 Priority Queues (Heaps) 12

13 Heaps 13

14 Min Binary Heap A min binary heap is a Complete binary tree Neither child is smaller than the value in the parent No order between left and right In other words, smaller items go above larger ones UMBC CMSC 341 Priority Queues (Heaps) 14

15 Min Binary Heap This property is called a partial ordering There is no set relation between siblings, cousins, etc. only that the values grow as we increase our distance from the root As a result of this partial ordering, every path from the root to a leaf visits nodes in a non-decreasing order UMBC CMSC 341 Priority Queues (Heaps) 15

16 Min Binary Heap Performance Performance (n is the number of elements in the heap) construction O( n ) findmin() O( 1 ) insert() O( lg n ) deletemin() O( lg n ) UMBC CMSC 341 Priority Queues (Heaps) 16

17 Convert a Heap to an Array Level-order traversal UMBC CMSC 341 Priority Queues (Heaps) 17

18 Min Binary Heap Performance Heap efficiency results, in part, from the implementation Conceptually a complete binary tree But implemented by using an array/vector (in level order) with the root at index 1 UMBC CMSC 341 Priority Queues (Heaps) 18

19 Min Binary Heap Performance For a node at index i Its left child is at index 2i Its right child is at index 2i+1 Its parent is at index i/2 No pointer storage Fast computation of 2i and i/2 by bit shifting i << 1 = 2i i >> 1 = i/2 UMBC CMSC 341 Priority Queues (Heaps) 19

20 Min Binary Heap: Exercises How to find the parent of E? The left child of D? The right child of A? UMBC CMSC 341 Priority Queues (Heaps) 20

21 Building a Heap 21

22 Insert Operation Must maintain Heap shape: Easy, just insert new element at the end of the array Min heap order: 1. Could be wrong after insertion if new element is smaller than its ancestors 2. Continuously swap the new element with its parent until parent is not greater than it ( percolate up ) Performance of insert is O(log n) in the worst case because the height of a complete binary tree (CBT) is at most log n UMBC CMSC 341 Priority Queues (Heaps) 22

23 Insert Code void insert(const Comparable &x) { /* First, check we are not overflowing array (code not included here) */ } // percolate up Comparable tmp; int hole = ++currentsize; array[hole] = x; for( ; hole > 1 && x < array[hole/2]; hole /= 2) { // swap, from child to parent tmp = array[hole]; array[hole] = array[hole / 2]; array[hole / 2] = tmp; } UMBC CMSC 341 Priority Queues (Heaps) 23

24 Insert Code (v2) /* More efficient version, where instead of swapping pairs, we just shift values down until right spot */ void insert(const Comparable &x) { /* First check we are not overflowing array (code not included here) */ } // percolate up int hole = ++currentsize; for( ; hole > 1 && x < array[hole/2]; hole /= 2) { // swap, from child to parent array[hole] = array[hole / 2]; } array[hole] = x; UMBC CMSC 341 Priority Queues (Heaps) 24

25 Insert Example: 14 UMBC CMSC 341 Priority Queues (Heaps) 25

26 Delete Operation Steps Remove min element (the root) Maintain heap shape Maintain min heap order To maintain heap shape, actual node removed is last one in the array Replace root value with value from last node and delete last node Sift-down the new root value Continually exchange value with the smaller child until no child is smaller. UMBC CMSC 341 Priority Queues (Heaps) 26

27 Delete Code void deletemin() { /* First, check for empty queue (code not included here) */ int hole, child; Comparable tmp = array[currentsize--]; } for (hole = 1, child = 2; child <= currentsize; hole = child, child *= 2) { /* find smaller of siblings (if there is one) */ if (child < currentsize && array[child+1] < array[child]) child++; if (array[child] < tmp) array[hole] = array[child]; else break; } array[hole] = tmp; UMBC CMSC 341 Priority Queues (Heaps) 27

28 Example: Delete Min UMBC CMSC 341 Priority Queues (Heaps) 28

29 Example: Delete Min UMBC CMSC 341 Priority Queues (Heaps) 29

30 Visualization This visualization of a minimum heap may be helpful in your understanding of the different properties of a heap, as well as the exact steps taken for the operations of insertion, deletion, etc. ual/heap.html UMBC CMSC 341 Priority Queues (Heaps) 30