Priority Queues. INFO0902 Data Structures and Algorithms. Priority Queues (files à priorités) Keys. Priority Queues

Transcription

1 Priority Queues INFO0902 Data Structures and Algorithms Priority Queues Justus H. Piater Priority Queues (files à priorités) Keys Extract the top-priority element at any time. No notion of order, positions, ranks etc. are exposed to the user. Examples? The priorities of the queued object are defined as a function of their keys. The key may be an attribute of the object, or a label attached to it, depending on the application context. Examples? Priority Queues 3 / 53 Priority Queues 4 / 53

2 Total order Associating Keys to Values Definition: A binairy relation properties for any : Totality: or (implies reflexivity ). with the following Antisymmetry: If and, then. Transitivity: If and, then (implies the existence of ). Design pattern: composition /** Interface for a key value pair entry */ public interface Entry { public Object key(); public Object value(); Priority Queues 5 / 53 Comparing Two Keys Priority Queues 6 / 53 Separating Keys from Comparisons Implement a priority queue specifically for each type of key? Ask keys to compare themselves to each other? Design pattern: comparator Integer compare(object a, Object b); Returns an integer if, if, and if ; error if and are not comparable. See also java.util.comparator. Priority Queues 7 / 53 Priority Queues 8 / 53

3 Comparing Two Points Comparing Two Points (Continued) /** Class represeting a point in the plane with integer coordinates */ public class Point2D { protected int xc, yc; // coordinates public Point2D(int x, int y) { xc = x; yc = y; public int getx() { return xc; public int gety() { return yc; /** Comparator for 2D points under lexicographic order. */ public class Lexicographic implements Comparator { int xa, ya, xb, yb; public int compare(object a, Object b) throws ClassCastException { xa = ((Point2D) a).getx(); ya = ((Point2D) a).gety(); xb = ((Point2D) b).getx(); yb = ((Point2D) b).gety(); if (xa!= xb) return (xb xa); else return (yb ya); Priority Queues 9 / 53 Priority Queues 10 / 53 The Priority-Queue ADT Java Interface Entry insert(object key, Object value); Entry removemin(void); Entry min(void); Note The keys of the elements within a priority queue are not necessarily distinct. A comparator must be explicitly supplied to the priority queue. The priority order can be inversed simply by changing the comparator. This ADT is much simpler than e.g. the sequence. /** Interface for the priority queue ADT */ public interface PriorityQueue { /** Returns the number of items in the priority queue. */ public int size(); /** Returns whether the priority queue is empty. */ public boolean isempty(); /** Returns but does not remove an entry with minimum key. */ public Entry min() throws EmptyPriorityQueueException; /** Inserts a key value pair and return the entry created. */ public Entry insert(object key, Object value) throws InvalidKeyException; /** Removes and returns an entry with minimum key. */ public Entry removemin() throws EmptyPriorityQueueException; Priority Queues 11 / 53 Priority Queues 12 / 53

4 Sorting with a Priority Queue List-Based Priority Queues Algorithm PriorityQueueSort(, ): Input: A sequence storing elements with a total order, and a priority queue that uses the same total order relation. Output: The sequence sorted by the total order relation. while!.isempty() do.removefirst().insert(, 0) // just key (= value), no extra data while!.isempty() do.removemin().key().insertlast( ) Priority Queues 13 / 53 Implementing a Priority Queue Based on the List ADT Sorted or unsorted list: Complexity of the methods? Java Implementation /** Implementation of a priority queue by means of a sorted list */ public class SortedListPriorityQueue implements PriorityQueue { protected List L; protected Comparator c; protected Position actionpos; // variable used by subclasses /** Inner class for entries */ protected static class MyEntry implements Entry { protected Object k; // key protected Object v; // value public MyEntry(Object key, Object value) { k = key; v = value; // methods of the Entry interface public Object key() { return k; public Object value() { return v; /** Inner class for a default comparator using the natural ordering */ protected static class DefaultComparator implements Comparator { List-Based Priority Queues 15 / 53 List-Based Priority Queues 16 / 53

5 Java Implementation (Continued) Java Implementation (Continued) public DefaultComparator() { /* default constructor */ public int compare(object a, Object b) throws ClassCastException { return ((Comparable) a).compareto(b); /** Creates the priority queue with the default comparator. */ public SortedListPriorityQueue () { L = new NodeList(); c = new DefaultComparator(); /** Creates the priority queue with the given comparator. */ public SortedListPriorityQueue (Comparator comp) { L = new NodeList(); c = comp; /** Returns but does not remove an entry with minimum key. */ public Entry min () throws EmptyPriorityQueueException { if (L.isEmpty()) throw new EmptyPriorityQueueException("priority queue is empty"); else return (Entry) L.first().element(); /** Inserts a key value pair and return the entry created. */ public Entry insert (Object k, Object v) throws InvalidKeyException { // auxiliary key checking method (could throw exception): checkkey(k); Entry entry = new MyEntry(k, v); insertentry(entry); // auxiliary insertion method return entry; /** Auxiliary method used for insertion. */ protected void insertentry(entry e) { Object k = e.key(); if (L.isEmpty()) { List-Based Priority Queues 17 / 53 Java Implementation (Continued) List-Based Priority Queues 18 / 53 Java Implementation (Continued) actionpos = L.insertFirst(e); // insert into empty list else if (c.compare(k, key(l.last())) > 0) { actionpos = L.insertLast(e); // insert at the end of the list else { Position curr = L.first(); while (c.compare(k, key(curr))> 0) { curr = L.next(curr); // advance toward insertion position actionpos = L.insertBefore(curr, e); // useful for subclasses /** Removes and returns an entry with minimum key. */ public Entry removemin() throws EmptyPriorityQueueException { if (L.isEmpty()) throw new EmptyPriorityQueueException("priority queue is empty"); else return (Entry) (L.remove(L.first())); protected Object key(position pos) { return ((Entry) pos.element()).key(); List-Based Priority Queues 19 / 53 List-Based Priority Queues 20 / 53

6 Selection Sort Insertion Sort Implementation of the sort with an unsorted list Best- and worst-case running times? Implementation of the sort with a sorted list Best- and worst-case running times? List-Based Priority Queues 21 / 53 List-Based Priority Queues 22 / 53 Heap Balancing the Operations With a list, the operations are or. Can we trade them off to obtain in total? Yes by replacing the list by a particular tree! Heap 24 / 53

7 The Heap (tas) The Heap (tas) (Continued) Definition: A (binary) heap is a binary tree the following two properties: with Heap Order: The key of each node (other than the root) is greater than or equal to that of the parent. Note The keys along a path are non-decreasing. The root contains a minimal key. Completeness: A binary tree of height is complete if it exhibits the following properties: The levels vertices ( vertices at level ). contain a maximal number of At level, all internal vertices are on the left of the external nodes (that is, an inorder traversal visits the former before the latter). At level, there is at most one vertex with one child. If it exists, it is the rightmost internal node, and its child is a left child. Definition: The last vertex of a heap is the rightmost vertex at level. Heap 25 / 53 The Height of a Heap Heap 26 / 53 ADT: Complete Binary Tree Proposition: A heap containing entries is of height. Proof: This ADT contains the methods of a binary tree, plus the following methods that are only concerned with the last vertex; the lowest level is created or deleted as needed: Position add(object o); Note If we manage to update the heap in time proportional to its height, such operations will be limited to a time logarithmic in. Object remove(void); Let s see some examples public interface CompleteBinaryTree extends BinaryTree { public Position add(object elem); public Object remove(); Heap 27 / 53 Heap 28 / 53

8 Representing a Complete Binary Tree An array list (level numbering) is particularly interesting: all operations constant (amortized) time, space efficient. Implementing a Priority Queue by a Heap We assume an array-list representation. We assume a constant-time comparator. min() est. Heap 29 / 53 Heap 30 / 53 Insertion Deletion insert(): 1. add() 2. Propagate the new vertex upwards to restore the heap order. Running time? removemin(): 1. Return the entry stored at the root. 2. Move the entry of the last vertex to the root, and delete the last vertex. 3. Propagate the root downwards to restore the heap order: a. If does not have a right child, let be the left child of. Otherwise, let be the child of containing the lesser key. b. If, exchange and and continue to propagate. Running time? Heap 31 / 53 Heap 32 / 53

9 Advanced Concepts Heap Sort Implementation of the sort with a heap Best- and worst-case running times? Advanced Concepts 34 / 53 In-Place Heap Sort ADT: Adaptable Priority Queue Use an inverse comparator (that places the maximum key at the root) The unique, linear data structure contains on its left a heap containing part of the elements, and on its right a sequence containing the remaining elements. During the first phase, the heap grows from left to right. During the second phase, the sorted sequence grows from right to left. Let s see an example: Priority Queue, plus: Entry remove(entry e); Object replacekey(entry e, Object k); Object replacevalue(entry e, Object x); To find an element in constant time, we augment the entry by a Position. The rest is trivial. Advanced Concepts 35 / 53 Advanced Concepts 36 / 53

10 Bottom-Up Heap Construction Recursive Formulation For simplicity of presentation, suppose, that is, the tree is full with height. 1. Create heaps containing one vertex each. 2. For : a. Merge heaps pairwise (each heap contains vertices) by adding a new root node. b. Propagate the new entry to restore the heap order, resulting in new heaps containing vertices each. Algorithm BottomUpHeap( ): Input: A list storing entries. Output: A heap storing the entries in. if.isempty() then return an empty heap.remove(.first()) Split into and of size BottomUpHeap( ) BottomUpHeap( ) Join and by root storing Perform down heap bubbling from return Advanced Concepts 37 / 53 Advanced Concepts 38 / 53 Proof of Linear Running Time Due to propagation, merging two heaps is. What is total time of all propagations? To bound the number of times a vertex takes part in a propagation, consider a path of a vertex towards is inorder successor. Observe that each vertex (other than the root) occurs in exactly two such paths. Thus, the sum of the lengths of all such paths is. Fibonacci Heap Advanced Concepts 39 / 53

11 Improved Priority Queue? Fibonacci Heap Reduce the insertion time below? When useful? Efficiently merge two priority queues: void merge(heap heap); (Algorithm and complexity for the binary heap?) With a Fibonacci heap, these two operations take time, while leaving removemin() at amortized time! Definition: The degree of a vertex is the number of its children. Definition: A Fibonacci heap is a collection of trees (containing vertices in total), each of which exhibits the following properties: 1. The heap order. 2. Each vertex is of degree at most. 3. Each vertex of degree is the root of a subtree of size at least Fibonacci Heap 41 / 53 The Simple Methods Fibonacci Heap 42 / 53 Algorithm removemin() min(): with a pointer to the root containing the minimal key merge(): Concatenate the lists of roots: insert(): Create a new Fibonacci heap of a single vertex and merge(): 1. Delete the root containing the minimum key; its children become the roots of new trees. Why isn t this all? 2. Repeat until all trees are of different degrees: Let and be two roots of identical degree, where the key of is inferior to that of. Attach as a new child to. 3. Update the pointer to the root containing the minimum key. Let s see an example. Fibonacci Heap 43 / 53 Fibonacci Heap 44 / 53

12 Analysis of Step 1 Analysis of Step 2 Running time? Conformance to the 3 properties? What do we have to show? Fibonacci Heap 45 / 53 Fibonacci Heap 46 / 53 Fibonacci is exponential. Reduction to trees Proposition: for some constant. Proof: Proposition: Step 2 reduces the number of trees to. Proof: Tree, if it exists, contains vertices. Corollary: Property 2 Corollary: Step 3 is. and thus for. The recursion bottoms out at, thus. We already proved earlier that. Fibonacci Heap 47 / 53 Fibonacci Heap 48 / 53

13 Correctness of Step 2 Running time of Step 2 Each merger obeys: Property 1? Property 2? Property 3? Proofs? Proposition: Step 2 takes amortized time. Proof: If there are initially trees, one execution of Step 2 takes time, and results in trees. Can we pay for a maximum overtime of by overcharging other operations? Fibonacci Heap 49 / 53 Fibonacci Heap 50 / 53 More on Fibonacci Heaps Our discussion of Fibonacci heaps is simplified: It also supports the reduction of a key in amortized time, and the deletion of an element in amortized time (see also the ADT: Adaptable Priority Queue). The analysis of these operations is more involved. Such an analysis motivates property 3 (and thus the name of this data structure), and justifies property 2. Summary Fibonacci Heap 51 / 53

14 Summary Priority Queues: Implementations based on lists and on binary heaps Implementation of a heap by an array list Sorting Adaptable Priority Queues Bottom-up heap construction in time Fibonacci heaps (simplified) Summary 53 / 53