Priority Queues. Outline and Required Reading: The Priority Queue ADT ( 7.1) Implementing a Priority Queue with a Sequence ( 7.2)

Transcription

1 1 Priority Queues Outline and Required Reading: The Priority Queue ADT (.1) Implementing a Priority Queue with a Sequence (.2) COSC 20, Fall 200, Section A Instructor: N. Vlajic

2 Keys 2 Key object / attribute assigned to an element used to identify, rank or weight that element typically assigned by a user or application not necessarily related to the content of corresponding element key element node in data-structure Example 1 [ keys in different applications ] (1) student records: key = student number (2) phone book: key = names () queue of callers on hold : key = assigned priority level [! ] [call ] [ ] [call 2 ] [ ] [call 2 ]

3 Total Order Relations on Keys Key Comparison in order to identify, rank, or weight elements based on their keys, a comparison rule is needed (R) if R(k 1,k 2 )=true k 1 comes before k 2, otherwise k 2 comes before k 2 R must define a total order relation, i.e. it must satisfy the following: (1) reflexive property: R(k,k)=true for every valid k (2) anti-symmetric property: if R(k 1,k 2 )=true & R(k 2,k 1 )=true k 1 =k 2 () transitive property: if R(k 1,k 2 )=true & R(k 2,k )=true R(k 1,k )=true Comparison rule that satisfies these properties will never lead to contradiction; the notion of the greatest (k max ) and smallest (k min ) key will be clearly defined: R(k,k max )=true, for any other key in the collection R(k min,k)=true, for any other key in the collection

4 Total Order Relations on Keys 4 Example 2 [ Total Order Relations ] Let us assume: keys N, R corresponds to. (1) k k is true for every valid k (2) if k 1 k 2 is true & k 2 k 1 is true k 1 =k 2 () if k 1 k 2 is true & k 2 k is true k 1 k is true Is strictly less a total order relation?? Let us assume: keys are words, R corresponds to alphabetically equal or before (@). (1) w is true for every valid w (2) if w 2 is true & w 1 is true w 1 =w 2 () if w w 2 is true & w w is true w w is true

5 Comparator Pattern 5 Comparator object external to the keys supplies a set of methods that implement key-comparison rules each method takes two keys and compares them, or reports an error if they are incomparable comparator approach enables that data container portion of the dictionary be reused k 1 e 1 k 2 e 2 k n e n C class islessthan(k a,k b ) isgreaterthan(k a,k b ) isequalto(k a,k b ) Example [ use of comparator ] C.isComparable(p.k) C.isLessThan(p.k, q.k) C.isGreaterThan(p.k,q.k) Dictionary class

6 Comparator Pattern (cont.) 6 Comparator Interface public boolean islessthan(a,b); /* return true if and only if a is less than b */ public boolean islessthanorequalto(a,b); /* return true if and only if a is less than or equal to b */ public boolean isequalto(a,b); /* return true if a and b are equal */ public boolean isgreaterthan(a,b); /* return true if and only if a is greater than b */ public boolean isgreaterthanorequalto(a,b); /* return true if and only if a is greater than or equal to b */ public boolean iscomparable(a); /* return true if and only if a can be compared */

7 Priority Queue Priority Queue dictionary organized according to the principle smallest key first out key value = priority level (e.g. smallest key = highest priority) if there are several items with smallest keys, one of the following policies can be used: (1) remove any item with smallest key (2) remove the item with smallest key that was first added k=1 e n k=0 e n-1 k=2 e n-2 k=0 e 1 remove first Could a PQ be efficiently implemented using a single (regular) queue???

8 Priority Queue (cont.) 8 Example 4 [ Priority Queues ] Priority levels of Internet traffic: high [0] streaming video normal [1] HTML files (textual Web pages) low [2] traffic computer 1 ( tool) [ 0 ] [ 2 ] [ 1 ] [ 0 ] computer 2 (Web-browser) computer (video-chat) HTML file router priority queue

9 Priority Queue: Interface Priority Queue Interface public int size(); /* return the number of elements in PQ */ public boolean isempty(); /* test whether PQ is empty */ public void insertitem(object k, Object e); /* insert a new element e with key k into PQ */ public Object minelement(); /* return, but do not remove, an element of PQ with smallest key; an error condition occurs if the PQ is empty */ public Object minkey(); /* return the smallest key in P; an error condition occurs if the PQ is empty */ public Object removemin(); /* remove from PQ and return an element with smallest key; an error condition occurs if the priority queue is empty */

10 Priority Queue: Implementation 10 How to choose the optimal implementation of a dictionary? In order to choose the optimal implementation it is important to look at usage pattern. (1) if dictionary is loaded once and then there are numerous searches executed on it we should be concerned with the cost of find method (2) if the number of elements loaded in the dictionary is large, and only a few searches are expected we should be concerned with the cost of insert method How to evaluate implementation of PQ? In PQs: (1) the number of elements can be considerable (2) all inserted elements are eventually removed (1) and (2) the cost of find/remove and insert are equally important!!!

11 Priority Queue: Implementation [1] Implementation of PQ with an Array of Ordinary Queues the number of ordinary queues corresponds to the number of priority levels each item of the PQ is placed in one of the ordinary queues when an item needs to be removed, move down through the ordinary queues, starting from the highest priority, until a nonempty queue is found remove the front item from this nonempty queue k=0 k=1 k=2

12 Priority Queue: Implementation [1] (cont.) 12 Running Times simple array-based implementation of queues is proven ineffective we will assume that ordinary queues are implemented using linked-lists Method insertitem(k,e) removemin() RT O(1) O(q) q = number of priority levels The running time of removemin() could be improved by adding an instance variable which keeps track of the highest priority element currently in the PQ. If the number of possible priorities is large, or unknown, this implementation becomes impractical!

13 Priority Queue: Implementation [2] 1 Implementation of PQ with Unsorted Sequence S is a general sequence; elements of S are pairs (k,e) new item p=(k,e) is always added at the end of S, by means of insertlast(p) to perform removemin(), element p with min key must be found, which requires that all elements in S be inspected removemin k=1 e n k=0 e n-1 k=2 e n-2 k=4 e 1 insertitem Which implementation of Sequence (array or DLL) is better, in this case?

14 Priority Queue: Implementation [2] (cont.) 14 Running Times the cost of insertlast() and findmin(), both in array and DLL based implementation, are O(1) and Θ(n) respectively we can assume either implementation Method insertitem(k,e) removemin() RT O(1) Θ(n) Implementation of PQ with unsorted sequence allows for fast insertion but slow deletion of items. removemin() in the array-based implementation is slightly more costly than in the DLL-implementation. Why?!

15 Priority Queue: Implementation [] 15 Implementation of PQ with Sorted Sequence to add new item p=(k,e) to S, first an appropriate location for p must be found (after the last item with key-value k, when looking from first() to last() ) item with smallest key is always placed at the front of S, therefore removemin() is performed simply as remove(first()) removemin k=4 e 1 k=2 e n-2 k=1 e n k=0 e n-1 insertitem In this implementation of PQ, items end up sorted according to their key-values.

16 Priority Queue: Implementation [] 16 Running Times the cost of findlessthanorequal(k) (i.e. insertitem(k,e)) and remove(first()), both in circular-array and DLL based implementation, are O(n) and O(1) respectively we can assume either implementation Method insertitem(k,e) removemin() RT O(n) O(1) Implementation of PQ with sorted sequence allows for fast deletion but slow insertion of items. insertitem(k,e) in the array-based implementation is slightly more costly than in the DLL-implementation. Why?!

17 Sorting with Priority Queue 1 PriorityQueueSort scheme for sorting S using an auxiliary PQ Phase (1) Put the items of S into an initially empty PQ by means of n insertitem() operations, one for each element. Phase (2) Extract the items from PQ in non-decreasing order by means of n removemin() operations, putting them back into S S [1,e n ] [0,e n-1 ] [2,e n-2 ] [4,e n-2 ] a=s.remove(first()) Q.insertItem(a.k,a.e) Q [1,e n ] [0,e n-1 ] [2,e n-2 ] [4,e n-2 ] b=q.minkey() c=q.removemin() p=(b,c) S.insertLast(p) S [4,e n-2 ] [2,e n-2 ] [1,e n ] [0,e n-1 ]

18 Sorting with Priority Queue (cont.) 18 Selection-Sort Algorithm = PriorityQueueSort with Unsorted Seq. Phase (1) Put the items of S into an initially empty PQ by means of n insertitem() operations. complexity: Θ(n) + Θ(n) = Θ(n) Phase (2) Repeatedly select (and remove) the item with smallest key in PQ and insert it at the end end of S. complexity: Θ(n+(n-1)+..+1) + Θ(n) = Θ(n 2 ) Selection from PQ is the bottleneck in the k th iteration all (n-k+1) keys of PQ need to be scanned in order to find the min key.

19 Sorting with Priority Queue (cont.) 1 Insertion-Sort Algorithm = PriorityQueueSort with Sorted Seq. Phase (1) Repeatedly remove the first item p=(k,e) from S and insert it at the appropriate location in PQ, i.e. after the last item in PQ with key-value k. Complexity: Θ(n) + O( (n-1)) = O(n 2 ). Phase (2) Remove the first item from PQ and place it at the back of S. Complexity: Θ(n) + Θ(n) = Θ(n) Insertion in PQ is the bottleneck in the k th iteration keys of at most (k-1) items in PQ need to be examined in order to find the right place for the new element. Which of the two sort algorithms provides a better performance, overall!?

20 1 st iteration 2 nd iteration In-Place Selection and Insertion Sort 20 In-Place Sort the 2 nd data-structure is not used all steps are performed directly on the original data-structure In-Place Selection Sort k th iteration: (1) find the smallest element (A) in the range [k,n] of S; (2) remove A; () shift-down all elements in the range [k,a.before()] (4) place A in the new (empty) location, i.e. k th location;

21 In-Place Selection and Insertion Sort (cont.) 21 In-Place Insertion Sort k th iteration: (1) remove the (k+1) th elements of S (B); (2) shift the above elements down, as long as they are larger than B () place B at the new (empty) location 1 st iteration 2 nd iteration

22 Priority Queues: Questions 22 Q.1 Implement insertitem(k,e) method of the priority queue, using the concepts of Implementation [1]. Assume that ordinary queues form an array of queues (Queue[ ] ordinaryqueues = new Queue[noOfPriorities]). Verify for yourself that the complexity of this method is O(1). Q.2 Suppose you know that the number of priorities that will be used in a PQ application is small, but you do not know what the actual priorities will be. For example, suppose you know that the priorities can be any integer value in the range 0 to , but you also know that there will at most 25 different numbers used. How might you implement the priority queue as an array of ordinary Queues in such a way that the array size is much smaller than ?