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

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

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

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

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

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.

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

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)

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 !!

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

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

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

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

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

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

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