Data Structures and Algorithms

Transcription

1 Data Structures and Algorithms Spring

2 Outline 1 Priority Queues

3 Outline Priority Queues 1 Priority Queues

4 Jumping the Queue Priority Queues In normal queue, the mode of selection is first in, first out In many situations (e.g. an OS) turnaround can often be improved by selecting the smallest job as the one to do next A priority queue enables finding efficiently the smallest job in a set Two operations supported by a PQ: insert: put an item in the queue delete_min: find the smallest item in the queue, remove it from the queue and return it to the calling function

5 Implementing a PQ Priority Queues Implementation alternatives: Linked list with insertions at front; insert: O(1)-time cost; delete_min: O(n)-time cost Sorted linked list where insertions maintains sortedness; insert: O(n); delete_min: O(1) Binary Search Tree (BST): height-balanced (HB) BST will guarantee O(log n)-time for both ops; but this is more than is needed Data structure we construct that supports the PQ ADT is a heap Running times will be O(log n)-time (worst case) for delete_min and O(1)-time (average case) for insert

6 Outline Priority Queues 1 Priority Queues

7 : Introduction A heap is a special type of binary tree that is completely filled except for the bottom level, on which level the nodes are filled from left to right u v w x y z A heap is not ordered in the same way as a BST (binary search tree) is

8 Heap Height and Representations A heap of height h has a maximum of h i=0 2i = 2 h+1 1 nodes (a full bottom level) and a minimum of 2 h (= 1 + h 1 i=0 2i = h 1) nodes Thus, a heap of n nodes has height log n = O(log n) Heaps can be represented in an array 0 u v w x y z For any element in position i of the array its relatives locations are: left child in position 2i right child in position 2i + 1 parent in position i/2

9 Heap Order Property Priority Queues A heap is said to have the heap order property if the smallest element of every subtree is at the root of the subtree A BST does not have this property Has HOP Has not HOP Minimum element of heap is at root To check for heap property just need to trace from every leaf node back to root; no need to compare siblings A heap is looser, less-organised than a BST

10 Outline Priority Queues 1 Priority Queues

11 Heap Operations: insert() If there are n elements in the heap, insert the new element at the first empty location in the array If the heap property is not violated, we re finished Otherwise, by swapping the new (and offending) element with its parent percolate it up the tree until the heap order property is satisfied Inserting the value 4 into the heap below:

12 Heap Operations: insert() (contd.) Insert at end of array (leftmost free slot on bottom level of tree): Percolate up: For void BinaryHeap<Comparable>::insert(const Comparable & x ) see Resource Matrix (Week08)

13 Heap Operations: insert() (contd.) Insert at end of array (leftmost free slot on bottom level of tree): Percolate up: For void BinaryHeap<Comparable>::insert(const Comparable & x ) see Resource Matrix (Week08)

14 Heap Operations: insert() (contd.) Insert at end of array (leftmost free slot on bottom level of tree): Percolate up: For void BinaryHeap<Comparable>::insert(const Comparable & x ) see Resource Matrix (Week08)

15 Heap Operations: delete_min() It is easy to extract the min element from a heap will be at i = 1 in array Hard part in deletions is reconstructing the heap If there were n elements in the heap prior to deletion, take the nth element and place it at i = 1 Trickle down the offending element until heap order is no longer violated First, remove root element (Before) 7

16 Heap Operations: delete_min() (contd.) Then, remove last element of array and place at root position (i) (ii) Trickle down this element; need to look at both offspring: For void BinaryHeap<Comparable>::deleteMin(const Comparable & x ) see Resource Matrix (Week08)

17 Heap Operations: delete_min() (contd.) Then, remove last element of array and place at root position Trickle down this element; need to look at both offspring: 7 6 For void BinaryHeap<Comparable>::deleteMin(const Comparable & x ) see Resource Matrix (Week08) 21

18 Heap Operations: delete_min() (contd.) Then, remove last element of array and place at root position Trickle down this element; need to look at both offspring: For void BinaryHeap<Comparable>::deleteMin(const Comparable & x ) see Resource Matrix (Week08)

19 But we know that we will have to do at most O(log n) trickles, in the worst case Priority Queues Heap Operations: delete_min() (contd.) When trickling down, we must make sure that we swap with the smaller of the two children How many levels we will have to trickle down depends on which side we trickle down and we cannot always predict this Sometimes difficult to know how to break a tie: 31 16

20 Heap Operations: delete_min() (contd.) When trickling down, we must make sure that we swap with the smaller of the two children How many levels we will have to trickle down depends on which side we trickle down and we cannot always predict this Sometimes difficult to know how to break a tie: But we know that we will have to do at most O(log n) trickles, in the worst case

21 Heap Operations: delete_min() (contd.) When trickling down, we must make sure that we swap with the smaller of the two children How many levels we will have to trickle down depends on which side we trickle down and we cannot always predict this Sometimes difficult to know how to break a tie: 7 1 swap 2 swaps 6 But we know that we will have to do at most O(log n) trickles, in the worst case 21 21

22 Heap Operations: delete_min() (contd.) When trickling down, we must make sure that we swap with the smaller of the two children How many levels we will have to trickle down depends on which side we trickle down and we cannot always predict this Sometimes difficult to know how to break a tie: But we know that we will have to do at most O(log n) trickles, in the worst case