2110211 intro. to data structures chapter 6 priority queue (heap) veera muangsin, dept. of computer...

2110211 Intro. to Data Structures Chapter 6 Priority Queue (Heap) Veera Muangsin, Dept. of Computer Engineering, Chulalongkorn University

1

Priority Queue (Heap)• A kind of queue• Dequeue gets element with the highest priority• Priority is based on a comparable value (key) of each

object (smaller value higher priority, or higher value higher priority)

• Example Applications: – printer -> print (dequeue) the shortest document first– operating system -> run (dequeue) the shortest job first– normal queue -> dequeue the first enqueued element first


2

Priority Queue (Heap) Operations

• insert (enqueue)• deleteMin (dequeue)

– smaller value higher priority– find, return, and remove the minimum element

Priority QueueinsertdeleteMin


3

Implementation using Linked List

• Unsorted linked list– insert takes O(1) time– deleteMin takes O(N) time

• Sorted linked list– insert takes O(N) time– deleteMin takes O(1) time


4

Implementation using Binary Search Tree

• insert takes O(log N) time• deleteMin takes O(log N) time

• support other operations that are not required by priority queue (for example, findMax)

• deleteMin make the tree unbalanced


5

Binary Heap• binary tree• completely filled (bottom level is filled from left to right• size between 2h (bottom level has only one node) and 2h+1-1

A

C

GF

B

E

J

D

H I


6

Array Implementation of Binary Heap

A

C

GF

B

E

J

D

H I

A B C D E F G H I J0 1 2 3 4 5 6 7 8 9 10 11 12 13

left child is in position 2i

right child is in position (2i+1)

parent is in position i/2


7

Heap Order Property (for Minimum Heap)

• Any node is smaller than (or equal to) all of its children (any subtree is a heap)

• Smallest element is at the root (findMin take O(1) time)

13

16

6819

21

31

32

24

65 26


8

Insert

13

16

6819

21

31

32

24

65 26

• Create a hole in the next available location• Move the hole up (swap with its parent) until data can be placed in the

hole without violating the heap order property (called percolate up)

13

16

6819

21

32

24

65 26 31


9

Insert

13

16

6819

21

31

32

24

65 26

13

16

6819

21

32

24

65 26 31

Percolate Up -> move the place to put 14 up

(move its parent down) until its parent <= 14

insert 14


10

Insert

13

16

681921

3132

24

65 26

13

16

681921

3132

24

65 26

14


11

deleteMin• Create a hole at the root• Move the hole down (swap with the smaller one of its children) until the last element of the

heap can be placed in the hole without violating the heap order property (called percolate down)

13

16

681921

3132

19

65 26

14 16

681921

32

19

65 26

14

31


12

deleteMin

13

16

681921

3132

19

65 26

14 16

681921

32

19

65 26

14

31

Percolate Down -> move the place to put 31 down (move its smaller child up) until its children >= 31


13

deleteMin

16

681921

32

19

65 26

14

31

16

681921

32

19

65 26

14

31


14

deleteMin

16

681921

32

19

65

14

31

26

16

681921

32

19

65

26

14

31


15

Running Time• insert

– worst case: takes O(log N) time, moves an element from the bottom to the top

– on average: takes a constant time (2.607 comparisons), moves an element up 1.607 levels

• deleteMin – worst case: takes O(log N) time– on average: takes O(log N) time (element that is placed at the

root is large, so it is percolated almost to the bottom)


16

public class BinaryHeap

{

private static final int DEFAULT_CAPACITY = 100;

private int currentSize;

private Comparable [ ] array;

public BinaryHeap( )

public BinaryHeap( int capacity )

public void insert( Comparable x ) throws Overflow

public Comparable findMin( )

public Comparable deleteMin( )


17

public boolean isEmpty( )

public boolean isFull( )

public void makeEmpty( )

private void percolateDown( int hole )

private void buildHeap( )

}


18

public static void main( String [ ] args ) { int numItems = 10000; BinaryHeap h = new BinaryHeap( numItems ); int i = 37;

for( i = 37; i != 0; i = ( i + 37 ) % numItems ) h.insert( new MyInteger( i ) );

for( i = 1; i < numItems; i++ ) if( ((MyInteger)( h.deleteMin( ) )).intValue( ) != i ) System.out.println( "Oops! " + i ); }


19

public BinaryHeap( ) { this( DEFAULT_CAPACITY ); }

public BinaryHeap( int capacity ) { currentSize = 0; array = new Comparable[ capacity + 1 ]; }

public void makeEmpty( ) { currentSize = 0; }


20

public void insert( Comparable x ) throws Overflow{ if( isFull( ) ) throw new Overflow( ); int hole = ++currentSize; for( ; hole > 1 && x.compareTo( array[ hole / 2 ] ) < 0; hole /= 2 ) array[ hole ] = array[ hole / 2 ]; array[ hole ] = x;}

public Comparable deleteMin( ){ if( isEmpty( ) ) return null; Comparable minItem = findMin( ); array[ 1 ] = array[ currentSize-- ]; percolateDown( 1 ); return minItem;}


21

private void percolateDown( int hole ){ int child; Comparable tmp = array[ hole ];

for( ; hole * 2 <= currentSize; hole = child ) { child = hole * 2; if( child != currentSize && array[ child + 1 ].compareTo( array[ child ] ) < 0 ) child++; if( array[ child ].compareTo( tmp ) < 0 ) array[ hole ] = array[ child ]; else break; } array[ hole ] = tmp;}


22

public boolean isEmpty( ){ return currentSize == 0; }

public boolean isFull( ){ return currentSize == array.length - 1; }

private void buildHeap( ){ for( int i = currentSize / 2; i > 0; i-- ) percolateDown( i );}

public Comparable findMin( ){ if( isEmpty( ) ) return null; return array[ 1 ];}


23

Other Operations• buildHeap

– insert N times

• decreaseKey(p, )– decrease the value of the key and percolate up

• increaseKey(p, )– increase the value of the key and percolate down

• delete– decreaseKey(p, ฅ) and deleteMin( )


24

buildHeap

• insert N times

• each insert takes O(1) average time, O(log N) worst-case time

• buildHeap takes O(N) average time, O(N log N) worst-case time


25

buildHeap: another method

• Place N items in to the tree in any order and percolate down every node from bottom up to the root

• Worst-case time of buildHeap is the sum of worst-case time to percolate these nodes, or the sum of heights of these nodes

• This method has O(N) worst-case time


26

Application: Selection Problem• Find the kth smallest element in a list

• Algorithm A– buildHeap from all elements and deleteMin k times

– running time O(N + k log N)

– if k = O(N / log N) then running time is O(N)

– if k = O(N) then running time is O(N log N)

– if k = N and record the values deleted by deleteMin --> heap sort


27

Application: Selection Problem

• Algorithm B (find the kth largest element)– Maintain a set S of k largest elements all the time

– buildHeap from first k elements, the kth largest element (the smallest in S, called Sk) is on top

– If the next element in the input is larger than Sk , then Sk is removed and the new one is inserted into S

– Running time is O(k) + O(N-k) + O((N-k)log k) = O(N log k)


28

Application: Event Simulation• Simulation of a bank with k tellers and C customers

• Each customer causes two events, arrival and departure. Each event has a timestamp

• Arrival events are put into a queue and departure events are put into a priority queue

• Find event that should occur next and process it

• Running time is O(C log(k+1))


29

d-Heaps

• In a d-heap, all nodes have d children

• A binary heap is a 2-heap

• insert takes O(logd N)

• deleteMin takes O(d logd N)

2110211 intro. to data structures chapter 6 priority queue (heap) veera muangsin, dept. of computer...

Documents