1 / 42

Priority Queues

Priority Queues. CSE 373 Data Structures. Priority Queue ADT. Priority Queue has these key behaviors: FindMin (peek) DeleteMin (poll) Insert (add,offer) also size, clear, iterate [not in order!] and possibly remove, changePriority efficiently…

carmenrichardson
Download Presentation

Priority Queues

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Priority Queues CSE 373 Data Structures

  2. Priority Queue ADT • Priority Queue has these key behaviors: • FindMin (peek) • DeleteMin (poll) • Insert (add,offer) • also size, clear, iterate [not in order!] • and possibly remove, changePriority efficiently… • Can get faster performance when using just these ops than when using full sorting (e.g. BST) • Is adaptive to incoming data, whereas a sorted list is precomputed Priority Queues

  3. Revisiting FindMin • Application: Find the smallest ( or highest priority) item quickly • Operating system needs to schedule jobs according to priority instead of FIFO • Event simulation (bank customers arriving and departing, ordered according to when the event happened) • Find student with highest grade, employee with highest salary etc. • Algorithm implementation (Huffman coding, minimum spanning trees) • Machine learning (k-nearest neighbors) Priority Queues

  4. Huffman coding • CDBBAABBCABABABACCAA • 40% A 100% ABCD • 35% B 60% BCD • 20% C 25% CD • 5% D 0 10 110 111 Priority Queues

  5. Nonparametric modeling Estimate ? w/ nearest points. Great in multidimensional spaces ? Priority Queues

  6. Simple Implementation • Lists • If sorted: deleteMin is O(1) but insert is O(N) • If not sorted: insert is O(1) but deleteMin is O(N) • Nice to do a simple implementation to compare against fancier version, check your testing… and sometimes simple version is good enough! Priority Queues

  7. void insert(Comparable o) { // O(1) list.add(o); } Comparable findMin() { // O(n) Iterator I = list.iterator(); if (!i.hasNext()) throw NoSuchElemEx(); Object min=i.next(); while(i.hasNext()) { Comparable o = i.next(); if (o.compareTo(min)<0) min=o; } return o; } Priority Queues

  8. void insert(Comparable o) { // O(n) int idx=0; for(Comparable c:list) { if (c.compareTo(o)<0) break; idx++; } list.add(o,idx); } Comparable deleteMin() { // O(1) return remove(list.size()-1); } Priority Queues

  9. Better than a speeding BST • We can do better than Balanced Binary Search Trees? • Very limited requirements: Insert, FindMin, DeleteMin. The goals are: • FindMin is O(1) • Insert is O(log N) • DeleteMin is O(log N) • Binary heaps! Priority Queues

  10. Binary Heaps • A binary heap is a binary tree (NOT a BST) that is: • Complete: the tree is completely filled except possibly the bottom level, which is filled from left to right • Satisfies the heap order property • every node is less than or equal to its children • or every node is greater than or equal to its children • The root node is always the smallest node • or the largest, depending on the heap order Priority Queues

  11. Heap order property • A heap provides limited ordering information • Each path is sorted, but the subtrees are not sorted relative to each other • A binary heap is NOT a binary search tree -1 2 1 1 0 6 4 6 2 0 7 5 8 4 7 These are all valid binary heaps (minimum) Priority Queues

  12. Binary Heap vs Binary Search Tree Binary Heap Binary Search Tree min value 5 94 10 94 10 97 min value 97 24 5 24 Parent is less than both left and right children Parent is greater than left child, less than right child Priority Queues

  13. Structure property • A binary heap is a complete tree • All nodes are in use except for possibly the right end of the bottom row Priority Queues

  14. Examples 6 2 4 2 4 6 complete tree, heap order is "max" 5 not complete 2 2 4 6 5 6 7 5 8 7 complete tree, heap order is "min" 9 not complete Priority Queues

  15. Array Implementation of Heaps (Implicit Pointers) • Root node = A[1] • Children of A[i] = A[2i], A[2i + 1] • Parent of A[j] = A[j/2] • Keep track of current size N (number of nodes) 1 2 2 3 - 2 4 6 7 5 4 6 value index 0 1 2 3 4 5 6 7 7 5 4 5 N = 5 Priority Queues

  16. FindMin and DeleteMin • FindMin: Easy! • Return root value A[1] • Run time = ? • DeleteMin: • Delete (and return) value at root node 2 4 3 7 5 8 10 11 9 6 14 Priority Queues

  17. DeleteMin • Delete (and return) value at root node 4 3 7 5 8 10 11 9 6 14 Priority Queues

  18. Maintain the Structure Property • We now have a “Hole” at the root • Need to fill the hole with another value • When we get done, the tree will have one less node and must still be complete 4 3 7 5 8 10 11 9 6 14 4 3 7 5 8 10 11 9 6 14 Priority Queues

  19. Maintain the Heap Property • The last value has lost its node • we need to find a new place for it • We can do a simple insertion sort operation to find the correct place for it in the tree 14 4 3 7 5 8 10 11 9 6 Priority Queues

  20. DeleteMin: Percolate Down 14 ? 14 3 3 ? 4 8 4 3 4 7 5 14 10 7 5 8 10 7 5 8 10 11 9 6 11 9 6 11 9 6 • Keep comparing with children A[2i] and A[2i + 1] • Copy smaller child up and go down one level • Done if both children are  item or reached a leaf node • What is the run time? Priority Queues

  21. 1 2 3 4 5 6 6 | 10 | 8 | 13 | 14 | 25 Percolate Down PercDown(i:integer, x: integer): { // N is the number elements, i is the hole, x is the value to insert Case{ 2i > N : A[i] := x; //at bottom// 2i = N : if A[2i] < x then A[i] := A[2i]; A[2i] := x; else A[i] := x; 2i < N : if A[2i] < A[2i+1] then j := 2i; else j := 2i+1; if A[j] < x then A[i] := A[j]; PercDown(j,x); else A[i] := x; }} no children one child at the end 2 children Priority Queues

  22. DeleteMin: Run Time Analysis • Run time is O(depth of heap) • A heap is a complete binary tree • Depth of a complete binary tree of N nodes? • depth = log2(N) • Run time of DeleteMin is O(log N) Priority Queues

  23. Insert • Add a value to the tree • Structure and heap order properties must still be correct when we are done 2 3 4 8 7 5 14 10 11 9 6 Priority Queues

  24. Maintain the Structure Property • The only valid place for a new node in a complete tree is at the end of the array • We need to decide on the correct value for the new node, and adjust the heap accordingly 2 3 4 8 7 5 14 10 11 9 6 Priority Queues

  25. Maintain the Heap Property • The new value goes where? • We can do a simple insertion sort operation to find the correct place for it in the tree 3 4 8 7 5 14 10 11 9 6 2 Priority Queues

  26. Insert: Percolate Up 2 3 ? 3 3 4 8 4 8 8 7 5 14 10 7 14 10 7 4 14 10 ? ? 11 9 6 11 9 6 11 9 6 5 5 2 2 • Start at last node and keep comparing with parent A[i/2] • If parent larger, copy parent down and go up one level • Done if parent  item or reached top node A[1] • Run time? Priority Queues

  27. Insert: Done 2 3 8 7 4 14 10 11 9 6 5 • Run time? Priority Queues

  28. PercUp • Define PercUp which percolates new entry to correct spot. • Note: the parent of i is i/2 PercUp(i : integer, x : integer): { ???? } Priority Queues

  29. PercUp Solution PercUp(i : integer, x : integer): { if i = 1 then A[1] := x else if A[i/2] < x then A[i] := x; else A[i] := A[i/2]; PercUp(i/2,x); } Priority Queues

  30. Sentinel Values - • Every iteration of Insert needs to test: • if it has reached the top node A[1] • if parent  item • Can avoid first test if A[0] contains a very large negative value • sentinel - < item, for all items • Second test alone always stops at top 2 3 8 7 4 10 9 11 9 6 5 - 2 3 8 7 4 10 9 11 9 6 5 value index 8 9 10 11 12 13 0 1 2 3 4 5 6 7 Priority Queues

  31. Binary Heap Analysis • Space needed for heap of N nodes: O(MaxN) • An array of size MaxN, plus a variable to store the size N, plus an array slot to hold the sentinel • Time • FindMin: O(1) • DeleteMin and Insert: O(log N) • BuildHeap from N inputs : O(N) How is this possible? Priority Queues

  32. Other Heap Operations • Find(X, H): Find the element X in heap H of N elements • What is the running time? O(N) • FindMax(H): Find the maximum element in H • Where FindMin is O(1) • What is the running time? O(N) • We sacrificed performance of these operations in order to get O(1) performance for FindMin Priority Queues

  33. Other Heap Operations: • changePriority: increase or decrease • Where in the heap are we? • Soln: store heap index in the object that we’re storing (adaptive data structure) Priority Queues

  34. Other Heap Operations • DecreaseKey(P,,H): Decrease the key value of node at position P by a positive amount , e.g., to increase priority • First, subtract  from current value at P • Heap order property may be violated • so percolate up to fix • Running Time: O(log N) Priority Queues

  35. Other Heap Operations • IncreaseKey(P,,H): Increase the key value of node at position P by a positive amount , e.g., to decrease priority • First, add  to current value at P • Heap order property may be violated • so percolate down to fix • Running Time: O(log N) Priority Queues

  36. Other Heap Operations • Delete(P,H): E.g. Delete a job waiting in queue that has been preemptively terminated by user • Use DecreaseKey(P,,H) followed by DeleteMin • Running Time: O(log N) Priority Queues

  37. Build Heap BuildHeap { for i = N/2 to 1 by –1 PercDown(i, A[i]) } 1 N=11 11 11 2 3 5 10 5 10 4 5 6 7 9 4 8 12 9 3 8 12 2 7 6 3 2 7 6 4 8 11 9 10 Priority Queues

  38. Build Heap 11 11 5 10 5 8 2 3 8 9 2 3 10 12 9 7 6 4 9 7 6 4 Priority Queues

  39. Build Heap 11 2 2 8 3 8 5 3 10 12 5 4 10 12 9 7 6 4 9 7 6 11 Priority Queues

  40. Analysis of Build Heap • Assume N = 2K –1 • Level 1: k -1 steps for 1 item • Level 2: k - 2 steps for 2 items • Level 3: k - 3 steps for 4 items • Level i : k - i steps for 2i-1 items Priority Queues

  41. Heapsort • Build heap • deleteMin onto same space Priority Queues

  42. Other Heap Operations • Merge(H1,H2): Merge two heaps H1 and H2 of size O(N). H1 and H2 are stored in two arrays. • Can do O(N) Insert operations: O(N log N) time • Better: Copy H2 at the end of H1 and use BuildHeap. Running Time: O(N) Priority Queues

More Related