Download Piority Queue (Heap)

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
2110211 Intro. to Data Structures Chapter 6 Priority Queue
(Heap) Veera Muangsin, Dept. of Computer Engineering,
1
Priority Queue (Heap) Operations
deleteMin
Priority Queue
insert
• insert (enqueue)
• deleteMin (dequeue)
– smaller value higher priority
– find, return, and remove the minimum element
2110211 Intro. to Data Structures Chapter 6 Priority Queue
(Heap) Veera Muangsin, Dept. of Computer Engineering,
2
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
2110211 Intro. to Data Structures Chapter 6 Priority Queue
(Heap) Veera Muangsin, Dept. of Computer Engineering,
3
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
2110211 Intro. to Data Structures Chapter 6 Priority Queue
(Heap) Veera Muangsin, Dept. of Computer Engineering,
4
Binary Heap
• binary tree
• completely filled (bottom level is filled from left
to right
• size between 2h (bottom level has only one node)
A
and 2h+1-1
B
C
D
H
E
I
F
G
J
2110211 Intro. to Data Structures Chapter 6 Priority Queue
(Heap) Veera Muangsin, Dept. of Computer Engineering,
5
Array Implementation of Binary Heap
A
B
C
D
F
E
G
left child is in position 2i
H
I
J
right child is in position (2i+1)
parent is in position i/2
0
A B C D E F G H I
J
1
10
2
3
4
5
6
7
8
9
11
12
13
2110211 Intro. to Data Structures Chapter 6 Priority Queue
(Heap) Veera Muangsin, Dept. of Computer Engineering,
6
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)
1
3
2
1
1
6
2
4
6
5
3
1
2
6
1
9
6
8
3
2
2110211 Intro. to Data Structures Chapter 6 Priority Queue
(Heap) Veera Muangsin, Dept. of Computer Engineering,
7
Insert
• 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)
1
3
1
3
2
1
1
6
2
4
6
5
3
1
2
6
3
2
1
9
2
1
1
6
2
4
6
8
6
5
1
9
2
6
3
2
2110211 Intro. to Data Structures Chapter 6 Priority Queue
(Heap) Veera Muangsin, Dept. of Computer Engineering,
6
8
3
1
8
Insert
insert 14
1
3
1
3
2
1
1
6
2
4
6
5
3
1
2
6
3
2
1
9
2
1
6
8
1
6
2
4
6
5
1
9
2
6
3
2
6
8
3
1
Percolate Up -> move the place to put 14 up
(move its parent down) until its parent <= 14
2110211 Intro. to Data Structures Chapter 6 Priority Queue
(Heap) Veera Muangsin, Dept. of Computer Engineering,
9
Insert
1
3
1
3
1
6
2
4
6
5
1
9
2
1
2
6
3
2
3
1
1
4
6
8
1
6
2
4
6
5
1
9
2
1
2
6
3
2
2110211 Intro. to Data Structures Chapter 6 Priority Queue
(Heap) Veera Muangsin, Dept. of Computer Engineering,
6
8
3
1
10
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)
1
3
1
4
1
6
1
9
6
5
1
9
2
1
2
6
3
2
3
1
1
4
1
6
1
9
6
8
6
5
1
9
2
1
2
6
3
2
2110211 Intro. to Data Structures Chapter 6 Priority Queue
(Heap) Veera Muangsin, Dept. of Computer Engineering,
6
8
31
11
deleteMin
1
3
1
4
1
6
1
9
6
5
1
9
2
1
2
6
3
2
3
1
1
4
6
8
1
6
1
9
6
5
1
9
2
1
2
6
3
2
6
8
31
Percolate Down -> move the place to put 31 down
(move its smaller child up) until its children >= 31
2110211 Intro. to Data Structures Chapter 6 Priority Queue
(Heap) Veera Muangsin, Dept. of Computer Engineering,
12
deleteMin
1
4
1
4
1
6
1
9
6
5
1
9
2
1
2
6
3
2
31
1
9
1
6
6
8
1
9
2
1
6
5
2
6
3
2
2110211 Intro. to Data Structures Chapter 6 Priority Queue
(Heap) Veera Muangsin, Dept. of Computer Engineering,
6
8
31
13
deleteMin
1
4
1
4
1
9
1
6
2
6
6
5
1
9
2
1
3
2
31
1
9
1
6
2
6
6
8
6
5
2
1
3
1
1
9
6
8
3
2
2110211 Intro. to Data Structures Chapter 6 Priority Queue
(Heap) Veera Muangsin, Dept. of Computer Engineering,
14
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)
2110211 Intro. to Data Structures Chapter 6 Priority Queue
(Heap) Veera Muangsin, Dept. of Computer Engineering,
15
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( )
2110211 Intro. to Data Structures Chapter 6 Priority Queue
(Heap) Veera Muangsin, Dept. of Computer Engineering,
16
public boolean isEmpty( )
public boolean isFull( )
public void
makeEmpty( )
private void
percolateDown( int hole )
private void
buildHeap( )
}
2110211 Intro. to Data Structures Chapter 6 Priority Queue
(Heap) Veera Muangsin, Dept. of Computer Engineering,
17
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 );
}
2110211 Intro. to Data Structures Chapter 6 Priority Queue
(Heap) Veera Muangsin, Dept. of Computer Engineering,
18
public BinaryHeap( )
{
this( DEFAULT_CAPACITY );
}
public BinaryHeap( int capacity )
{
currentSize = 0;
array = new Comparable[ capacity + 1 ];
}
public void makeEmpty( )
{
currentSize = 0;
}
2110211 Intro. to Data Structures Chapter 6 Priority Queue
(Heap) Veera Muangsin, Dept. of Computer Engineering,
19
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;
}
2110211 Intro. to Data Structures Chapter 6 Priority Queue
(Heap) Veera Muangsin, Dept. of Computer Engineering,
20
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;
}
2110211 Intro. to Data Structures Chapter 6 Priority Queue
(Heap) Veera Muangsin, Dept. of Computer Engineering,
21
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 ];
}
2110211 Intro. to Data Structures Chapter 6 Priority Queue
(Heap) Veera Muangsin, Dept. of Computer Engineering,
22
Other Operations
• buildHeap
– insert N times
• decreaseKey(p, D )
– decrease the value of the key and percolate up
• increaseKey(p, D )
– increase the value of the key and percolate down
• delete
– decreaseKey(p, ฅ ) and deleteMin( )
2110211 Intro. to Data Structures Chapter 6 Priority Queue
(Heap) Veera Muangsin, Dept. of Computer Engineering,
23
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
2110211 Intro. to Data Structures Chapter 6 Priority Queue
(Heap) Veera Muangsin, Dept. of Computer Engineering,
24
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
2110211 Intro. to Data Structures Chapter 6 Priority Queue
(Heap) Veera Muangsin, Dept. of Computer Engineering,
25
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
2110211 Intro. to Data Structures Chapter 6 Priority Queue
(Heap) Veera Muangsin, Dept. of Computer Engineering,
26
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)
2110211 Intro. to Data Structures Chapter 6 Priority Queue
(Heap) Veera Muangsin, Dept. of Computer Engineering,
27
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))
2110211 Intro. to Data Structures Chapter 6 Priority Queue
(Heap) Veera Muangsin, Dept. of Computer Engineering,
28
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 Engineering,
29