DESIGN & ANALYSIS OF ALGORITHM08 – 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 elementi.e., maybe someone decides to leave the hospital

Changing the priority of an arbitrary elementi.e., someone suddenly needs an immediate help !

Joining two priority queuesi.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 #1ORDERED 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 #1ORDERED 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

2 4 5 7 9 12

13

10

2 4 5 7 9 12

10

13

2 4 5 7 9 10

12

13

INSERT(10)

10<13 swap

10<12 swap

10≮9 stop

Time complexity is O(n)

IMPLEMENTATION #2UNORDERED 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

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.

IMPLEMENTATION #3ORDERED LINKED LIST

3

head tail = max

6 8

8

head = max

6 3

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

IMPLEMENTATION #3ORDERED LINKED LIST

8

head = max

6 3

5

5 < 8 5 < 6 5 ≮ 3

What is the time complexity

?

How do we INCREASE-KEY ?

Need a doubly linked-list to be able to move an element backward !

IMPLEMENTATION #3ORDERED LINKED LIST

8

head = max

6 5 3

increase this element’s key to

7 !

8

head = max

6 5 3

EXERCISE

Write the pseudocode of INCREASE-KEY(Node x, int newkey)

Assume that a Node has the following attribute: key next prev

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)

IMPLEMENTATION #4UNORDERED LINKED LIST

4

head ≠ max

7 5 2

COMPARISON

Array Linked-List Heap

unordered

ordered unordered

ordered

INSERT O(1) O(n) O(1) O(n) O(lgn)

MAXIMUM O(n) O(1) O(n) O(1) O(1)

EXTRACT-MAX O(n) O(1) O(n) O(1) O(lgn)

INCREASE-KEY O(1) O(n) O(1) O(n) O(lgn)