Priority queues. Priority queues. Priority queue operations

Transcription

1 Priority queues March 30, Priority queues The ADT priority queue stores arbitrary objects with priorities. An object with the highest priority gets served first. Objects with priorities are defined by keyvalue pairs called entries whose keys define priorities. March 30, 018 Priority queue operations The ADT priority queue is defined by: insert(k, v): Insert an entry with key k and value v. removemin(): Remove and return an entry with the smallest key March 30,

2 Auxiliary operations In addition, there are: min(): Return an entry with the smallest key without removing it. size(): Return the number of entries stored. isempty(): Indicate whether no entries are stored. March 30, Heaps March 30, Heaps A heap is a binary tree of entries (i.e., keyvalue pairs) with the following properties: Heap order: For every node v other than the root, key(v) key(parent(v)). Complete binary tree: There are maximum number of nodes at every level except for the deepest level at which all nodes are gathered on the left-hand side. March 30, 018 6

3 Heap-based priority queues An entry is in each node. An entry with the smallest key (i.e., highest priority) is in the root. Insertion and removal take O(log n)-time. (, Sue) (5, Pat) (6, Mark) (9, Jeff) (7, Anna) March 30, Insertion 1. Add a new node v with a new entry next to the last (i.e., deepest, rightmost) node of the heap.. Perform up-heap bubbling: (a) Unless v is the root, if key(parent(v)) > key(v), then swap v with parent(v). (b) If swap was made in (a), then repeat (a) else stop. March 30, Removal 1. Replace the root with the last node, removing the root s entry.. Perform down-heap bubbling: (a) Let v be the root. (b) Unless v has no children, let w be the child of v with the smaller key. If key(w) < key(v), then swap v with w. (c) If swap was made in (b), then repeat (b) else stop. March 30,

4 Array-list-based heaps We represent a heap of n entries by means of an array list of length n. We use the level-numbering function f defined recursively for the element at a position p as follows: (a) If p is the root, then f(p) = 0. (b) If p is the left child of a position q, then f(p) = f(q) + 1. (c) If p is the right child of a position q, then f(p) = f(q) +. March 30, Array-list-based heaps We represent a heap of n entries by means of an array list of length n. In other words, for an entry stored at index i, (a) its parent is at index (i 1)/, (b) its left child is at index i + 1, (c) its right child is at index i +. March 30, Array-list-based heaps We represent a heap of n entries by means of an array list of length n March 30,

5 Sorting March 30, Sorting Given a linear list of comparable objects of the same type, we wish to sort the objects in the increasing order. For simplicity, let s just assume that we are given an array of n integers. March 30, Selection sort Find the least value in the array. Swap it with the value at the index 0. Repeat the steps above for the remainder of the array, starting from the index 1 and advancing each time. March 30,

6 Selection sort Suppose we are given an array A of n integers. for (int i = 0; i < n - 1; i++) { int minindex = i; for (int j = i + 1; j < n; j++) if (A[j] < A[minIndex]) minindex = j; if (minindex!= i) swap A[i] with A[minIndex]; } March 30, Bubble sort By comparing and (swapping if necessary) adjacent pairs of numbers, bubble up the largest value in the array. Repeat the above step for the remainder of the array, ending at the second-to-the last index and advancing each time. March 30, Bubble sort Suppose we are given an array A of n integers. for (int i = 1; i < n; i++) for (int j = 0; j < n - i; j++) if (A[j] > A[j + 1]) swap A[j] with A[j + 1]; March 30,

7 Efficiency What is the number of comparisons made in the worst case? For both selection and bubble sorts, it is: (n 1)n (n 1)+ (n )+ +1= Thus, it is O(n ). Can we do better using a heap? March 30, Heap sort Suppose we are given an array A of n integers. Create an empty heap. Insert the integers from A into the heap one at a time. Remove the integers from the heap one at a time and put them back to A in the removed order. March 30, Efficiency What is the number of comparisons made in the worst case? For insertion, it is proportional to:!" log#$+!" log3#$+ +!" log(n 1) #$ For removal, it is proportional to: "# log(n 1) $%+ + "# log3$%+ "# log$% In sum, it is O(n log n). March 30,