Unformatted text preview: Chapter 8: Priority Queues
Objectives: Priority Queue ADT
Comparator design pattern
Heaps
Priority Queue Implementation with List and Heap Adaptable Priority Queues Sorting: –
–
–
– Priority Queuesort
Selectionsort Insertsort Heaport CSC311: Data Structures
CSC311: Data Structures 1 Priority Queue ADT
Priority
A priority queue stores a collection of entries
Each entry is a pair
(key, value)
Main methods of the Priority Queue ADT – insert(k, x)
inserts an entry with key k and value x
– removeMin()
removes and returns the entry with smallest key Additional methods – min()
returns, but does not remove, an entry with smallest key
– size(), isEmpty() Applications:
–
–
– Standby flyers
Auctions
Stock market Total Order Relations
Total
Keys in a priority queue can be arbitrary objects on which an order is defined
Two distinct entries in a priority queue can have the same key Mathematical concept of total order relation ≤
– Reflexive property:
x≤ x
– Antisymmetric property:
x ≤ y ∧y ≤ x ⇒ x = y – Transitive property: x ≤ y ∧y ≤ z ⇒ x ≤ z Entry ADT
Entry
An entry in a priority queue is simply a key
value pair
Priority queues store entries to allow for efficient insertion and removal based on keys
Methods: – key(): returns the key for this entry
– value(): returns the value associated with this entry As a Java interface: /** * Interface for a keyvalue * pair entry **/
public interface Entry { public Object key(); public Object value();
} Comparator ADT
Comparator
A comparator encapsulates the action of comparing two objects according to a given total order relation
A generic priority queue uses an auxiliary comparator
The comparator is external to the keys being compared
When the priority queue needs to compare two keys, it uses its comparator The primary method of the Comparator ADT: – compare(x, y): Returns an integer i such that i < 0 if a < b, i = 0 if a = b, and i > 0 if a > b; an error occurs if a and b cannot be compared. Example Comparator
Example
Lexicographic comparison of 2D points:
/** Comparator for 2D points under the standard 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); }
} Point objects:
/** Class representing 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; }
} Priority Queue Sorting
Priority
We can use a priority queue to sort a set of comparable elements 1. Insert the elements one by one with a series of insert operations
2. Remove the elements in sorted order with a series of removeMin operations The running time of this sorting method depends on the priority queue implementation Algorithm PQSort(S, C)
Input sequence S, comparator C
for the elements of S
Output sequence S sorted in
increasing order according to C
P ← priority queue with
comparator C
while ¬S.isEmpty ()
e ← S.removeFirst ()
P.insert (e, 0)
while ¬P.isEmpty()
e ← P.removeMin().key()
S.insertLast(e) Sequencebased Priority Queue
Sequencebased
Implementation with an unsorted list
4 5 2 Performance: 3 1 – insert takes O(1) time since we can insert the item at the beginning or end of the sequence
– removeMin and min take O(n) time since we have to traverse the entire sequence to find the smallest key Implementation with a sorted list
1 2 3 Performance: 4 5 – insert takes O(n) time since we have to find the place where to insert the item
– removeMin and min take O(1) time, since the smallest key is at the beginning SelectionSort
SelectionSort
Selectionsort is the variation of PQsort where the priority queue is implemented with an unsorted sequence
Running time of Selectionsort: 1. Inserting the elements into the priority queue with n insert operations takes O(n) time
time
2. Removing the elements in sorted order from the priority queue with n removeMin operations takes time proportional to 1 + 2 + …+ n Selectionsort runs in O(n2) time time SelectionSort Example
SelectionSort Input: Sequence S
(7,4,8,2,5,3,9) Priority Queue P
() Phase 1
(a)
(b)
..
.
(g) (4,8,2,5,3,9)
(8,2,5,3,9)
..
..
.
.
() (7)
(7,4) Phase 2
(a)
(b)
(c)
(d)
(e)
(f)
(g) (2)
(2,3)
(2,3,4)
(2,3,4,5)
(2,3,4,5,7)
(2,3,4,5,7,8)
(2,3,4,5,7,8,9) (7,4,8,5,3,9)
(7,4,8,5,9)
(7,8,5,9)
(7,8,9)
(8,9)
(9)
() (7,4,8,2,5,3,9) InsertionSort
InsertionSort
Insertionsort is the variation of PQsort where the priority queue is implemented with a sorted sequence
Running time of Insertionsort: 1. 2. Inserting the elements into the priority queue with n insert operations takes time proportional to 1 + 2 + …+ n
Removing the elements in sorted order from the priority queue with a series of n removeMin operations takes O(n) time
time Insertionsort runs in O(n2) time time InsertionSort Example
InsertionSort
Input: Sequence S
(7,4,8,2,5,3,9) Priority queue P
() Phase 1 (a)
(b)
(c)
(d)
(e)
(f)
(g) (4,8,2,5,3,9)
(8,2,5,3,9)
(2,5,3,9)
(5,3,9)
(3,9)
(9)
() (7)
(4,7)
(4,7,8)
(2,4,7,8)
(2,4,5,7,8)
(2,3,4,5,7,8)
(2,3,4,5,7,8,9) Phase 2
(a)
(b)
..
.
(g) (2)
(2,3)
..
.
(2,3,4,5,7,8,9) (3,4,5,7,8,9)
(4,5,7,8,9)
..
.
() Inplace Insertionsort
Inplace
Instead of using an external data structure, we can implement selectionsort and insertionsort inplace
A portion of the input sequence itself serves as the priority queue
For inplace insertionsort
– We keep sorted the initial portion of the sequence
– We can use swaps instead of modifying the sequence 5 4 2 3 1 5 4 2 3 1 4 5 2 3 1 2 4 5 3 1 2 3 4 5 1 1 2 3 4 5 1 2 3 4 5 Heaps
Heaps A heap is a binary tree storing keys at its nodes and satisfying the following properties:
– HeapOrder: for every internal node v other than the root,
key(v) ≥ key(parent(v))
– Complete Binary Tree: let h be the height of the heap
for i = 0, … , h − 1, there are 1,
i
2 nodes of depth i
at depth h − 1, the internal nodes are to the left of the external nodes The last node of a heap is the rightmost node of depth h
2
5
9 6
7 last node Height of a Heap
Height
Theorem: A heap storing n keys has height O(log n)
keys has height (log
Proof: (we apply the complete binary tree property) – Let h be the height of a heap storing n keys
keys
0,
– Since there are 2i keys at depth i = 0, … , h − 1 and at least one key and at least one key h−1
at depth h, we have n ≥ 1 + 2 + 4 + … + 2 + 1
log
– Thus, n ≥ 2h , i.e., h ≤ log n
, i.e., depth keys
0 1 1 2 h−1 2h−1 h 1 Heaps and Priority Queues
Heaps
We can use a heap to implement a priority queue
We store a (key, element) item at each internal node
We keep track of the position of the last node
For simplicity, we show only the keys in the pictures
(2, Sue)
(5, Pat)
(9, Jeff) (6, Mark)
(7, Anna) Insertion into a Heap
Insertion
Method insertItem of the priority queue ADT corresponds to the insertion of a key k to the heap
The insertion algorithm consists of three steps – Find the insertion node z (the new last node)
– Store k at z
– Restore the heaporder property (discussed next) 2
5
9 6 z
7 insertion node
2
5
9 6
7 z 1 Upheap
Upheap
After the insertion of a new key k, the heaporder property may be violated
Algorithm upheap restores the heaporder property by swapping k along an upward path from the insertion node
Upheap terminates when the key k reaches the root or a node whose parent has a key smaller than or equal to k Since a heap has height O(log n), upheap runs in O(log n) time
(log
(log
2 1 5
9 1
7 z 6 5
9 2
7 z 6 Removal from a Heap
Removal Method removeMin of the priority queue ADT corresponds to the removal of the root key from the heap
The removal algorithm consists of three steps
– Replace the root key with the key of the last node w
– Remove w – Restore the heaporder property (discussed next) 2
5
9 6
7 w
last node
7 5 w 9 new last node 6 Downheap
Downheap
After replacing the root key with the key k of the last node, the heaporder property may be violated
Algorithm downheap restores the heaporder property by swapping key k along a downward path from the root
Upheap terminates when key k reaches a leaf or a node whose children have keys greater than or equal to k Since a heap has height O(log n), downheap runs in O(log n) time
(log
(log
7
5
9 w 5
6 7
9 w 6 Updating the Last Node
Updating
The insertion node can be found by traversing a path of O(log n)
(log
nodes
nodes
– Go up until a left child or the root is reached
– If a left child is reached, go to the right child
– Go down left until a leaf is reached Similar algorithm for updating the last node after a removal HeapSort
Consider a priority Consider a priority queue with n items implemented by means of a heap
– the space used is O(n)
– methods insert and removeMin take O(log n)
(log
time
time
– methods size, isEmpty, and min take time O(1)
(1)
time
time Using a heapbased priority queue, we can sort a sequence of n elements in O(n log n)
time
time
The resulting algorithm is called heapsort
Heapsort is much faster than quadratic sorting algorithms, such as insertionsort and selectionsort Vectorbased Heap
Implementation
Implementation
We can represent a heap with n keys by means of a vector of length n + 1
For the node at rank i
– the left child is at rank 2i
– the right child is at rank 2i + 1 Links between nodes are not explicitly stored
The cell of at rank 0 is not used
Operation insert corresponds to inserting at rank n + 1
Operation removeMin corresponds to removing at rank 1
Yields inplace heapsort 2
5 6 9 7 2
0 5 6 9 7 1 2 3 4 5 Merging Two Heaps
Merging
We are given two heaps and a key k
We create a new heap with the root node storing k and with the two heaps as subtrees
We perform downheap to restore the heap
order property 3
8 2
5 4 6 7
3
8 2
5 4 6 2
3
8 4
5 7 6 Bottomup Heap Construction
We can construct a heap We can construct a heap storing n given keys in using a bottomup construction with log n log
phases
In phase i, pairs of heaps with 2i −1 keys are merged into heaps with 2i+ 1−1 keys 2i −1 2i −1 2i+ 1−1 Example
Example 16 15 4 25
16 12 6 5
15 4 7 23 11
12 6 20 27
7 23 20 Example (contd.)
Example
25
16 5
15 4 15
16 11
12 6 4
25 5 27
9 23 6
12 11 20 23
9 27 20 Example (contd.)
Example
7 8 15
16 4
25 5 6
12 11 23
9 4
5
25 20 6 15
16 27 7 8
12 11 23
9 27 20 Example (end)
Example
10
4 6 15
16 5
25 7 8
12 11 23
9 27 20 4
5 6 15
16 7
25 10 8
12 11 23
9 27 20 Analysis
Analysis
We visualize the worstcase time of a downheap with a proxy path that goes first right and then repeatedly goes left until the bottom of the heap (this path may differ from the actual downheap path)
Since each node is traversed by at most two proxy paths, the total number of nodes of the proxy paths is O(n) Thus, bottomup heap construction runs in O(n) time time Bottomup heap construction is faster than n successive insertions and speeds up the first phase of heapsort Adaptable
Adaptable
Priority Queues
Priority 3a 5g CSC311: Data Structures
CSC311: Data Structures 4e 31 Motivating Example
Motivating Suppose we have an online trading system where orders to purchase and sell a given stock are stored in two priority queues (one for sell orders and one for buy orders) as (p,s) entries:
The key, p, of an order is the price
The value, s, for an entry is the number of shares
A buy order (p, s) is executed when a sell order (p’, s’) with price p’<p is added (the execution is complete if s’>s)
– A sell order (p, s) is executed when a buy order (p’, s’) with price p’>p is added (the execution is complete if s’>s)
–
–
– What if someone wishes to cancel their order before it executes?
What if someone wishes to update the price or number of shares for their order? Methods of the Adaptable
Priority Queue ADT
Priority
remove(e): Remove from P and return remove
entry e.
replaceKey(e,k): Replace with k and return the key of entry e of P; an error condition occurs if k is invalid (that is, k cannot be compared with other keys).
replaceValue(e,x): Replace with x and return the value of entry e of P. Example
Example
Operation
insert(5,A)
insert(3,B)
insert(7,C)
min()
(5,A),(7,C)
key(e2)
remove(e1)
(7,C)
replaceKey(e2,9)
(9,B)
replaceValue(e3,D) Output
e1
e2
e3
e2
3
e1
3
C P (5,A)
(3,B),(5,A)
(3,B),(5,A),(7,C)
(3,B),
(3,B),(5,A),(7,C)
(3,B),
(7,C),
(7,D),(9,B) Locating Entries
Locating
In order to implement the operations remove(k), replaceKey(e), and replaceValue(k), we need fast ways of locating an entry e in a priority queue.
We can always just search the entire data structure to find an entry e, but there are better ways for locating entries. LocationAware Entries
LocationAware
A locatoraware entry identifies and tracks the location of its (key, value) object within a data structure
Intuitive notion:
– Coat claim check
– Valet claim ticket
– Reservation number Main idea: – Since entries are created and returned from the data structure itself, it can return locationaware entries, thereby making future updates easier List Implementation
List
A locationaware list entry is an object storing
–
–
– key
value
position (or rank) of the item in the list In turn, the position (or array cell) stores the entry
Back pointers (or ranks) are updated during swaps nodes/positions header 2c 4c 5c 8c
entries trailer Heap Implementation
Heap A locationaware heap entry is an object storing
–
–
– key
value
position of the entry in the underlying heap In turn, each heap position stores an entry
Back pointers are updated during entry swaps 2d
4a 8g 6b 5e 9c Performance
Performance
Using locationaware entries we can achieve the following running times (times better than those achievable without locationaware entries are highlighted in red): Method
Unsorted List
size, isEmpty
O(1)
insert
O(1)
min
O(n)
removeMin
O(n)
remove
O(1)
replaceKey
O(1)
replaceValue
O(1) Sorted List
O(1)
O(n)
O(1)
O(1)
O(1)
O(n)
O(1) Heap
O(1)
O(log n)
(log
O(1)
O(log n)
(log
O(log n)
(log
O(log n)
(log
O(1) ...
View
Full Document
 Spring '11
 dr.kahan
 Sort, Binary heap, Priority queue

Click to edit the document details