1. Design & Analysis of Algorithm Priority Queue
Informatics Department
Parahyangan Catholic University

2. Priority Queue
A priority queue is a data structure that supports two basic operations: inserting a new item and removing element with the largest (or smallest) key
Example : queue in hospital
prioritize patient with emergency issue

3. Priority Queue A few more operations:
Finding element with the largest key i.e., which patient has the most severe issue ?
Removing and arbitrary element i.e., maybe someone decides to leave the hospital
Changing the priority of an arbitrary element i.e., someone suddenly needs an immediate help !
Joining two priority queues i.e., received several transfer patients from other hospital

4. Priority Queue Operations
More specifically, a priority queue maintains a set S of elements. Each element has a key.
A max priority queue supports the following basic operations :
INSERT(x) inserts element x to S
MAXIMUM() returns the element in S that has the largest key
EXTRACT-MAX() removes and returns the element in S that has the largest key
INCREASE-KEY(x, k) increase the key of element x to k (assume the current key of x is at least as large as k)
Removing an element is the same as increasing its key to ∞, then do extract-max

5. Priority Queue Operations
Alternatively, a min priority queue supports the following operations:
INSERT(x) inserts element x to S
MINIMUM() returns the element in S that has the largest key
EXTRACT-MIN() removes and returns the element in S that has the smallest key
DECREASE-KEY(x,k) decrease the key of element x to k (assume the current key of x is at least as small as k)
Removing an element is the same as decreasing its key to -∞, then do extract-min

6. Various Implementation
Priority Queue is an ADT, means that we can implement it with various technique:
Array
Ordered Array
Unordered Array
Linked List
Ordered Linked List
Unordered Linked List
Heap (covered later)
Binomial Heap
Fibonacci Heap
etc.
Now we discuss how to implement a max priority queue that only stores keys.
Implementation of min priority queue is very similar, and left as an exercise 
Later we shall see how to “link” a priority queue’s element to an outside object.

7. Implementation #1 Ordered Array
Since an array has a fixed capacity, priority queue implemented using an array is also limited.
length = array’s length (=capacity)
size = the number of elements in priority queue
Example:
priority queue of length 10 with size=7
MAXIMUM and EXTRACT-MAX are O(1) 2 4 5 7 9 12 13
size = position of max element

8. Implementation #1 Ordered Array
INSERT
Similar to inserting an element on insertion sort
INCREASE-KEY is similar to INSERT, only to a different swap direction 2 4 5 7 9 12 13
INSERT(10) 2 4 5 7 9 12 13 10
10<13  swap 2 4 5 7 9 12 10 13
10<12  swap 2 4 5 7 9 10 12 13
10≮9  stop
Time complexity is O(n)

9. Implementation #2 Unordered Array
Example:
priority queue of length 10 with size=7
INSERT is simply adding the new element on an empty spot  O(1)
INCREASE-KEY is simply changing the key’s value  O(1)
EXTRACT-MAX and MAXIMUM requires sequential through the entire array  O(n) 5 4 2 1 11 6 7
size ≠ position of max element !!

10. Exercise
Write the pseudocode for the following operations on an unordered array priority queue ! Global variables are:
A = array of integers
length = maximum capacity of A
size = # of elements in priority queue, initially 0
INSERT(x)
MAXIMUM()
EXTRACT-MAX()
INCREASE-KEY(i, k) increase the key of the element stored at index i to the new value k. Assume the old key is ≤ k

11. Implementation #3 Ordered Linked List
Node of linked list can be ordered in ascending manner, and we keep track of “tail” pointer as the maximum element of the priority queue.
Alternatively, order the linked list in descending manner, thus the “head” is the maximum element of the priority queue. 3
head
tail = max 6 8 8
head = max 6 3

12. Implementation #3 Ordered Linked List
Since a linked list can have unlimited* nodes, keeping track of length variable is not necessary. *of course they are limited by computer’s memory space 
INSERT is similar to inserting on an ordered array
5 < 8
5 < 6
5 ≮ 3 5 8 6 3
What is the time complexity ?
head = max

13. Implementation #3 Ordered Linked List
How do we INCREASE-KEY ?
Need a doubly linked-list to be able to move an element backward ! 8 6 5 3
head = max
increase this element’s key to 7 ! 8 6 5 3
head = max

14. Exercise Write the pseudocode of INCREASE-KEY(Node x, int newkey)
Assume that a Node has the following attribute:
key
next
prev

15. Implementation #4 Unordered Linked List
In an unordered linked-list, head element is not necessarily the maximum of the priority queue.
New element can be inserted anywhere in the list, thus we can use the O(1) INSERT-FIRST method.
However, finding the maximum element requires sequential search through the entire list  O(n) 4 7 5 2
head ≠ max

16. Comparison Array Linked-List Heap unordered ordered INSERT O(1) O(n)
O(lgn)
MAXIMUM
EXTRACT-MAX
INCREASE-KEY