PRIORITY QUEUE

 A priority queue (PQ) is an abstract data type

for storing a set of elements according to a
specified order or priority. It supports arbitrary
insertion of elements in any order whatsoever but
allows removal only in terms defined by the
priority. A priority queue, therefore, is
essentially a list of items in which each item has
associated with it a priority, which is used to
determine the order in which values are available
to the user.
Types of Priority Queues
 An ascending
priority queue is a
collection of items into
which items can be
inserted arbitrarily and
from which only the
smallest item can be
removed. On the other
hand a descending
priority queue allows
only the largest item to
be removed.
Basic Priority Queue Operations
 There are two basic operations that can be
performed on a priority queue:
 Enqueue: This operation inserts or adds data in
the queue. The data will be added to the rear of
the queue.
 Dequeue: This operation removes the data,
which has the highest priority in the queue.
Implementation of the Priority
Queues
There are many possible ways to implement the
queues, using:
 An unordered array

 An ordered array

 A linked list

 Heap
 Implementing Priority Queue
using Unordered Array
 Data Items stored in an unordered array
 Enqueue operation same as enqueue operation in
ordinary FIFO queues
 To implement dequeue, we first scan the whole of the
priority queue to look for element with highest priority
and then swap it with the element at the front and then
perform dequeue operation as in queues.
enqueue(23)
front

23

rear
enqueue(11)
front

23 11

rear
enqueue(17)
front

23 11

rear
enqueue(17)
front

23 11 17

rear
dequeue()
front

23 11 17

rear
dequeue()
front

11 17

rear
enqueue(12)
front

11 17 12

rear
enqueue(22)
front

11 17 12

rear
enqueue(22)
front

11 17 12 22

rear
dequeue()
front

11 17 12 22

rear
dequeue()
front

11 17 12 22

rear
dequeue()
front

11 17 12

rear
enqueue(20)
front

11 17 12

rear
enqueue(20)
front

11 17 12 20

rear
enqueue(16)
front

11 17 12 20

rear
enqueue(16)
front

11 17 12 20 16

rear
dequeue()
front

11 17 12 20 16

rear
dequeue()
front

11 17 12 16

rear
dequeue()
front

11 17 12 16

rear
dequeue()
front

11 12 16

rear
enqueue(5)
front

11 12 16 5

rear
dequeue()
front

11 12 16 5

rear
dequeue()
front

11 12 16 5

rear
dequeue()
front

11 12 5

rear
Final Queue
front

11 12 5

rear
 Implementing Priority Queue
using ordered Array
 Data Items stored in an ordered array
 Dequeue operation same as dequeue operation in
ordinary FIFO queues
 To implement enqueue, we first search where the new
element has to be inserted and then we need to shift
elements to make room for the insertion.
enqueue(23)
front

23

rear
enqueue(11)
front

23 11

rear
enqueue(17)
front

23 11

rear
enqueue(17)
front

23 11

rear
enqueue(17)
front

23 17 11

rear
dequeue()
front

23 17 11

rear
dequeue()
front

17 11

rear
enqueue(12)
front

17 11

rear
enqueue(12)
front

17 11

rear
enqueue(12)
front

17 12 11

rear
enqueue(22)
front

17 12 11

rear
enqueue(22)
front

17 12 11

rear
enqueue(22)
front

22 17 12 11

rear
dequeue()
front

22 17 12 11

rear
dequeue()
front

17 12 11

rear
enqueue(20)
front

17 12 11

rear
enqueue(20)
front

20 17 12 11

rear
enqueue(16)
front

20 17 12 11

rear
enqueue(16)
front

20 17 12 11

rear
enqueue(16)
front

20 17 16 12 11

rear
dequeue()
front

20 17 16 12 11

rear
dequeue()
front

17 16 12 11

rear
dequeue()
front

17 16 12 11

rear
dequeue()
front

16 12 11

rear
enqueue(5)
front

16 12 11 5

rear
dequeue()
front

16 12 11 5

rear
dequeue()
front

16 12 11 5

rear
dequeue()
front

12 11 5

rear
Applications of Priority
Queues
 Network Routing
 Sorting
 Compression
 CPU Scheduling
 Interrupt Handling
 Simulation
 Greedy Algorithms
 Incremental /Partial sorting
 Find the k largest elements
Applications of Priority
Queues
Network Routing
Applications of Priority Queue

Sorting
 We can use a priority queue to sort a set of
comparable elements
1. Insert the elements one by one with a series of
push(e) operations
2. Remove the elements in sorted order with a series of
pop() operations
 The running time of this sorting method depends
on the priority queue implementation
Applications of Priority Queue
Compression
 One of the earliest data
algorithm, Huffman algorithm compression
uses priority queue. Huffman extensively
used to compress a block of data into a
smaller space. The Codes algorithm starts
collecting the frequencies by
characters are block all then
of in the data the
and
processes each one in order of descending
frequency by using a priority queue.
Applications of Priority Queue
CPU Scheduling
 A CPU can only run one process at a time, but
there may be many jobs waiting to be run. A
priority can be associated with each process, and
the CPU is allocated to the process with the
highest priority. A Priority Queue can be used to
store the processes and quickly select the next
process to run based upon its priority.
Applications of Priority Queue
Event Simulation
 Priority queues are most commonly used as "event
queues" in simulations. Each value on the queue is
an event that is expected to take place, and each key is the
time it is expected to take place.

 A simulation operates by removing successive events

from the queue and simulating them. This
is why most priority queues return the minimum, rather
than maximum, key: we want to simulate the events
that occur first.
Applications of Priority Queue
Partial/Incremental Sorting
 Priority queues provide extra flexibility over
sorting, where instead of sorting complete data only
partial or incremental sorting may be needed. This is
important because jobs often enter a system at
arbitrary intervals. It is more cost-effective to insert
a new job into a priority queue than to re-sort
everything on each new arrival. One such
application can be to maintain largest M values in a
stream of N elements. It can be used for fraud
detection, to isolate large transactions. Could also be
used by for ranking by Web search engines.
Applications of Priority Queue
Find the m largest elements
 Store the first m elements in an ascending priority
queue
 Process the rest of n-m elements one by one.
 If the element is larger than the element in front of
queue, then perform a dequeue operation and insert the
new element in queue.
 At the end, the m largest elements are in the priority
queue.
 2 3 1 2
3 1 9 8 6 7
1 2 3 2
2 1 8 7 1 1
11 4 5 2
8 2 1 2 7 9
 2 3 1 2
3 1 9 8 6 7
1 2 3 2
2 1 8 7 1 1
11 4 5 2
8 2 1 2 7 9

3
 2 3 1 2
3 1 9 8 6 7
1 2 3 2
2 1 8 7 1 1
11 4 5 2
8 2 1 2 7 9

1 3
 2 3 1 2
3 1 9 8 6 7
1 2 3 2
2 1 8 7 1 1
11 4 5 2
8 2 1 2 7 9

1 3 9
 2 3 1 2
3 1 9 8 6 7
1 2 3 2
2 1 8 7 1 1
11 4 5 2
8 2 1 2 7 9

1 3 8 9
 2 3 1 2
3 1 9 8 6 7
1 2 3 2
2 1 8 7 1 1
11 4 5 2
8 2 1 2 7 9

1 3 6 8 9
 2 3 1 2
3 1 9 8 6 7
1 2 3 2
2 1 8 7 1 1
11 4 5 2
8 2 1 2 7 9

21>1

1 3 6 8 9
 2 3 1 2
3 1 9 8 6 7
1 2 3 2
2 1 8 7 1 1
11 4 5 2
8 2 1 2 7 9

3 6 8 9 21
 2 3 1 2
3 1 9 8 6 7
1 2 3 2
2 1 8 7 1 1
11 4 5 2
8 2 1 2 7 9

32>3

3 6 8 9 21
 2 3 1 2
3 1 9 8 6 7
1 2 3 2
2 1 8 7 1 1
11 4 5 2
8 2 1 2 7 9

6 8 9 21 32
 2 3 1 2
3 1 9 8 6 7
1 2 3 2
2 1 8 7 1 1
11 4 5 2
8 2 1 2 7 9

13>6

6 8 9 31 32
 2 3 1 2
3 1 9 8 6 7
1 2 3 2
2 1 8 7 1 1
11 4 5 2
8 2 1 2 7 9

8 9 13 31 32
 2 3 1 2
3 1 9 8 6 7
1 2 3 2
2 1 8 7 1 1
11 4 5 2
8 2 1 2 7 9

22>8

8 9 13 31 32
 2 3 1 2
3 1 9 8 6 7
1 2 3 2
2 1 8 7 1 1
11 4 5 2
8 2 1 2 7 9

9 13 22 31 32
 2 3 1 2
3 1 9 8 6 7
1 2 3 2
2 1 8 7 1 1
11 4 5 2
8 2 1 2 7 9

7<9

9 13 22 31 32
 2 3 1 2
3 1 9 8 6 7
1 2 3 2
2 1 8 7 1 1
11 4 5 2
8 2 1 2 7 9

11>9

9 13 22 31 32
 2 3 1 2
3 1 9 8 6 7
1 2 3 2
2 1 8 7 1 1
11 4 5 2
8 2 1 2 7 9

11 13 22 31 32
 2 3 1 2
3 1 9 8 6 7
1 2 3 2
2 1 8 7 1 1
11 4 5 2
8 2 1 2 7 9

28>11

11 13 22 31 32
 2 3 1 2
3 1 9 8 6 7
1 2 3 2
2 1 8 7 1 1
11 4 5 2
8 2 1 2 7 9

13 22 28 31 32
 2 3 1 2
3 1 9 8 6 7
1 2 3 2
2 1 8 7 1 1
11 4 5 2
8 2 1 2 7 9

12<13

13 22 28 31 32
 2 3 1 2
3 1 9 8 6 7
1 2 3 2
2 1 8 7 1 1
11 4 5 2
8 2 1 2 7 9

4<13

13 22 28 31 32
 9 2 3 1 2
3 1 8 6 7
1 2 3 2
2 1 8 7 1 1
11 4 5 2
8 2 1 2 7 9

81>13

13 22 28 31 32
 2 3 1 2
3 1 9 8 6 7
1 2 3 2
2 1 8 7 1 1
11 4 5 2
8 2 1 2 7 9

22 28 31 32 81
 2 3 1 2
3 1 9 8 6 7
1 2 3 2
2 1 8 7 1 1
11 4 5 2
8 2 1 2 7 9

72>22

22 28 31 32 81
 2 3 1 2
3 1 9 8 6 7
1 2 3 2
2 1 8 7 1 1
11 4 5 2
8 2 1 2 7 9

28 31 32 72 81
 2 3 1 2
3 1 9 8 6 7
1 2 3 2
2 1 8 7 1 1
11 4 5 2
8 2 1 2 7 9

5<28

28 31 32 72 81
 2 3 1 2
3 1 9 8 6 7
1 2 3 2
2 1 8 7 1 1
11 4 5 2
8 2 1 2 7 9

17<2
8
28 31 32 72 81
 2 3 1 2
3 1 9 8 6 7
1 2 3 2
2 1 8 7 1 1
11 4 5 2
8 2 1 2 7 9

19<28

28 31 32 72 81
 2 3 1 2
3 1 9 8 6 7
1 2 3 2
2 1 8 7 1 1
11 4 5 2
8 2 1 2 7 9

2<28

28 31 32 72 81
 2 3 1 2
3 1 9 8 6 7
1 2 3 2
2 1 8 7 1 1
11 4 5 2
8 2 1 2 7 9

28 31 32 72 81
Evaluating implementations
 When we choose a data structure, it is important to look at
usage patterns
 If we load an array once and do thousands of searches on
it, we want to make searching fast—so we would
probably sort the array
 If we load a huge array and expect to do only a few
searches, we probably don’t want to spend time sorting
the array
 For almost all uses of a queue (including a priority
queue), we eventually remove everything that we add
 Hence, when we analyze a priority queue, neither “add”
nor “remove” is more important—we need to look at the
timing for “add + remove”
Array implementations
 A priority queue could be implemented as an unsorted
array (with a count of elements)
 Adding an element would take O(1) time (why?)
 Removing an element would take O(n) time (why?)
 Hence, adding and removing an element takes O(n)
time
 This is an inefficient representation
 A priority queue could be implemented as a sorted array
(again, with a count of elements)
 Adding an element would take O(n) time (why?)
 Removing an element would take O(1) time (why?)
 Hence, adding and removing an element takes O(n)
time
100
 Again, this is inefficient
Linked list implementations
 A priority queue could be implemented as an unsorted
linked list
 Adding an element would take O(1) time (why?)
 Removing an element would take O(n) time (why?)
 A priority queue could be implemented as a sorted linked list
 Adding an element would take O(n) time (why?)
 Removing an element would take O(1) time (why?)
 As with array representations, adding and removing an
element takes O(n) time
 Again, these are inefficient implementations

101
Binary tree implementations
 A priority queue could be represented as a (not
necessarily balanced) binary search tree
 Insertion times would range from O(log n) to
O(n)
(why?)
 Removal times would range from O(log n) to
O(n)
(why?)
 A priority queue could be represented as a
balanced
binary search tree
 Insertion and removal could destroy the balance
102
 We need an algorithm to rebalance the binary
Heap implementation
Better than BST because it does not support
links

- Insert O(logN)
- Find minimum O(logN)
Deleting the minimal element takes a constant
time, however after that the heap structure has to be
adjusted, and this requires O(logN) time.
Programming Assignment
 Dynamic-median finding. Design a data
type that supports insert in logarithmic time,
find the median in constant time,
and remove the median in logarithmic
time.
Dynamic-median finding
 You need two heaps: one min-heap and one max-heap. Each heap contains about
one half of the data. Every element in the min-heap is greater or equal to the
median, and every element in the max-heap is less or equal to the median.
 When the min-heap contains one more element than the max-heap, the median is
in the top of the min-heap. And when the max-heap contains one more element
than the min-heap, the median is in the top of the max-heap.
 When both heaps contain the same number of elements, the total number of
elements is even. In this case median is the mean of the two middle elements.
 Every time you insert, compare the new element with those at the top of the heaps
in order to decide where to insert it. If the new element is greater than the current
median, it goes to the min-heap. If it is less than the current median, it goes to the
max heap. Then you might need to rebalance. If the sizes of the heaps differ by
more than one element, extract the min/max from the heap with more elements and
insert it into the other heap.