This document discusses the implementation of a max-priority queue using a max-heap data structure. It defines the key operations of a priority queue as insert, maximum, extract-max, and increase-key. It then provides pseudocode for implementing these operations efficiently using a heap in O(log n) time. Extract-max, increase-key, and insert are implemented by calling auxiliary heap functions that maintain the max-heap property. The document also provides an example application for job scheduling and concludes that a heap can efficiently support any priority queue operation in O(log n) time.

1. MAX PRIORITY QUEUE

2. What is a priority queue?
 A priority queue is a data structure for maintaining a set S of elements, each with
an associated value called a key.
 In a priority queue, an element with high priority is served before an element with
low priority.

3. Max-Priority Queue
 Here we will implement the priority queue using heap.
 As with heaps, priority queues come in two forms:
max-priority queues and
min-priority queues
 Here we will focus on how to implement max-priority
queues, which are in turn based on max-heaps.

4. Operations of Max-Priority Queue
 A max-priority queue supports the following operations:
INSERT(S, x):inserts the element x into the set S, which is
equivalent to the operation S = S ∪ 𝒙 .
MAXIMUM(S):returns the element of S with the largest
key.
EXTRACT-MAX(S):removes and returns the element of S
with the largest key.
INCREASE-KEY(S, x, k):increases the value of element
x’s key to the new value k, which is assumed to be atleast
as large as x’s current key value.

5. Implementation of the operations of max-priority queue
HEAP-MAXIMUM(A)
1 return A[1]
 The procedure HEAP-MAXIMUM implements the MAXIMUM operation in θ(1)
time.

6. The procedure HEAP-EXTRACT-MAX implements the EXTRACT-MAX operation.
HEAP-EXTRACT-MAX(A)
1 if A.heap-size < 1
2 error “heap underflow”
3 max = A[1]
4 A[1] = A[A.heap-size]
5 A.heap-size = A.heap-size - 1
6 MAX-HEAPIFY(A, 1)
7 return max
Thus the time complexity of HEAP-EXTRACT-MAX is O(lg n).
Implementation of the operations of max-priority queue
From lines 1 to 5 runs is constant
time
From heap we know that the running time of
MAX-HEAPIFY is O(lg n)
Line 7 runs in constant time

7. 67810
100
3050
1
2
3
4 5 6 7
7810
6
3050
1
2
3
4 5 6
MAX-HEAPIFY
7810
50
306
1
2
3
4 5 6
MAX-
HEAPIFY
(a) (b)
(c)
786
50
3010
1
2
3
4 5 6MAX-
HEAPIFY
(d)

8. The procedure HEAP-INCREASE-KEY implements the INCREASE-KEY operation.
(Parent (i) = )
HEAP-INCREASE-KEY(A, I, key)
1 if key < A[i]
2 error “new key is smaller than current key”
3 A[i] = key
4 while i > 1 and A[PARENT(i) ] < A[i]
5 exchange A[i] with A[PARENT(i)]
6 i = PARENT(i)
The WORST CASE occurs when we have to start INCREASE-KEY procedure from a leaf
node and stop at the root node of the heap.
Thus the time complexity of the HEAP-INCREASE-KEY depends on the number of times
the while loop (lines 4 to 6) executes .
Since the height of the tree is lg n, therefore the time complexity of HEAP-INCREASE-KEY
is O(lg n).
Implementation of the operations of max-priority queue
 2/i
From lines 1 to 3 runs is constant
time

9. Loop invariant of HEAP-INCREASE-KEY
 At the start of each iteration of the while loop of lines 4–6, the subarray
A[1….A.heap-size] satisfies the max-heap property, except that there
may be one violation: A[i] may be larger than A[PARENT(i)].
 Initialization. A is a heap except that A[i] might be larger
that it's parent, because it has been modified and A[i] is
larger than its children.
 Maintenance. When we exchange A[i] with its parent, the
max-heap property is satisfied except that
now A[PARENT(i)] might be larger than its parent.
 Termination. The loop terminates whenever we reach the
root of the heap or the max-heap property for A[i] and its
parent is satisfied. At the loop termination, A is a max-heap.

10. Image source (introduction to algorithms )
1
2
3
4 5 6 7
8 =9 10
1
2
3
4 5 6 7
8 =9 10
1
2
3
=4 5 6 7
8 9 10
1
=2 3
4 5 6 7
8 9 10

11. MAX-HEAP-INSERT(A,key)
1 A.heap-size =A.heap-size +1
2 A[A.heap-size] = -∞
3 HEAP-INCREASE-KEY(A,A.heap-size,key)
 The procedure MAX-HEAP-INSERT implements the INSERT operation. It takes as
an input the key of the new element to be inserted into max-heap A.
 The procedure first expands the max-heap by adding to the tree a new leaf whose
key is -∞.
 Then it calls HEAP-INCREASE-KEY to set the key of this new node to its correct
value and maintain the max-heap property.
 Since the lines 1 and 2 runs in constant time and from we know that complexity
of HEAP-INCREASE-KEY is O(lg n), therefore the complexity of MAX-HEAP-
INSERT is O(lg n).
Implementation of the operations of max-priority queue
The lines 1 and 2 runs in constant
time

12. 67810
100
3050
1
2 3
4 5 6 7
(a) (b)
−∞
67810
100
3050
1
2 3
4 5 6 7
Key=55
(c)
55
67810
100
3050
1
2 3
4 5 6 7
HEAP-INCREASE-
KEY(A,8,55)
8
8
(d)
10
67855
100
3050
1
2 3
4 5 6 7
8
(e)
10
67850
100
3055
1
2 3
4 5 6 7
8

13. Application of MAX PRIORITY QUEUE
• One of the most popular application Max Priority queue is job
scheduler in a computer.
• The max-priority queue keeps track of the jobs to be performed
and their relative priorities. When a job is finished or interrupted,
the scheduler selects the highest-priority job from among those
pending by calling EXTRACT-MAX. The scheduler can add a new job
to the queue at any time by calling INSERT.

14. Conclusion
 A heap can support any priority-queue operation on a set of size n in O(lg n)
time.
 Implementation of an efficient Priority Queue is one of the applications of the heap.
 If we want to decrease the value of a key in the heap, after decreasing the value
we have to call the MAX-HEAPIFY procedure on that node.

15. Bibliography
 Introduction to algorithms – 3rd edition
 Ita.skanev.com