lecture 8 : priority queue bong-soo sohn assistant professor school of computer science and...

Lecture 8 : Priority Queue

Bong-Soo Sohn

Assistant ProfessorSchool of Computer Science and Engineering

Chung-Ang University

Priority Queues

An efficient ADT to keep a dynamic set S of elements x to support the following operations : getMax(S) : return the element with the highest priority extractMax(S) : remove and return the element with

the highest priority insert(x,S) : insert element x into S increaseKey(S,x,k) – increase x’s priority to k

Priority queues are implemented using a heap, which is a tree structure with special properties.

Heap a tree that satisfies the heap property

Heap property If B is a child node of A, then key(A)>=key(B) can be reverse (max heap , min heap)

Heaps are used to implement priority queue

Efficiency of heap operations is crucial in some graph algorithms

Binary Heap

Has following properties shape property

all levels of the tree, except possibly the last one (deepest) are fully filled, and, if the last level of the tree is not complete, the nodes of that level are filled from left to right.

heap property

<ex. Binary max heap>

Operations (in max heap)

Insert(x,S)1. Add the element on the bottom level of the

heap2. Compare the added element with its parent;

if they are in the correct order, stop3. If not, swap the element with its parent and

return to the previous step.

Operations (in max heap)

getMax(S) : trivial - O(1) extractMax(S) : O(lg n) – tree height

1. Replace root node with the last element on the last level

2. repeat swapping parent-child until heap property becomes valid

Building a Heap

O(n lg n) : A heap can be built by successive insertions - not optimal

O(n) algorithm randomly putting the elements on a binary tree

if all the subtrees starting at some height h (measured from the bottom) have already been "heapified", the trees at depth h+1 can be heapified by sending their root down, along the path of maximum children

Example: building a heap

4 1 3 2 16 9 10 14 8 7 1 2 3 4 5 6 7 8 9 10

4

1

2 16

7814

3

9 10

1

2 3

4 5 6 7

8 9 10

Sorting with heaps: Heap-Sort

We can use the heap structure to sort an array A[i] of n elements in place:

Since the maximum element of the array is its first element, A[1], it can be put in its correct final position at the end of the array, in A[n].

We can now recursively fix the heap of the sub-tree rooted at node 1 and containing n – 1 elements with Max-Heapify until two elements are left.

Each call to Max-Heapify takes O(lg n), and it is called once for each element in the array, so the running time is O(n lg n) always (best, average, and worst case) with O(n) space.

10

Heap-Sort

Heap-Sort(A)1. Build-Max-Heap(A) 2. heapsize[A] length(A) 3. for i length[A] downto 2 4. do Exchange(A[1],A[i]) 5. heapsize[A] length(A) –1

6. Max-Heapify(A,1)

put maximum at the root

Example: Heap-Sort

16

14

8 7

142

10

9 3

1

2 3

4 5 6 7

8 9 10

16 14 10 8 7 9 3 2 4 1

Example: Heap-Sort (2)

14

8

4 7

1612

10

9 3

1

2 3

4 5 6 7

8 9 10

Example: Heap-Sort (3)

10

8

4 7

16142

9

1 3

1

2 3

4 5 6 7

8 9 10

Example: Heap-Sort (4)

9

8

4 7

161410

3

1 2

1

2 3

4 5 6 7

8 9 10

Example: Heap-Sort (5)

7

4

1 2

161410

3

8 9

1

2 3

4 5 6 7

8 9 10

Example: Heap-Sort (6)

4

2

1 7

161410

3

8 9

1

2 3

4 5 6 7

8 9 10

Example: Heap-Sort (7)

1

2

4 7

161410

3

8 9

1

2 3

4 5 6 7

8 9 10

Example: Heap-Sort (8)

1

2

4 7

161410

3

8 9

1

2 3

4 5 6 7

8 9 10

1 2 3 4 7 8 9 10 14 16