cs 201 data structures and algorithms
DESCRIPTION
CS 201 Data Structures and Algorithms. Chapter 4: Priority Queues ( Binary Heaps ) T ext : Read Weiss, § 6.1 – 6.3. Izmir University of Economics. 1. Priority Queue (Heap). A kind of queue Dequeue gets element with the highest priority - PowerPoint PPT PresentationTRANSCRIPT
![Page 1: CS 201 Data Structures and Algorithms](https://reader034.vdocument.in/reader034/viewer/2022051416/56813090550346895d966e30/html5/thumbnails/1.jpg)
CS 201Data Structures and
Algorithms
Chapter 4: Priority Queues(Binary Heaps)
Text: Read Weiss, §6.1 – 6.3
1Izmir University of Economics
![Page 2: CS 201 Data Structures and Algorithms](https://reader034.vdocument.in/reader034/viewer/2022051416/56813090550346895d966e30/html5/thumbnails/2.jpg)
Source: Muangsin / Weiss 2
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
![Page 3: CS 201 Data Structures and Algorithms](https://reader034.vdocument.in/reader034/viewer/2022051416/56813090550346895d966e30/html5/thumbnails/3.jpg)
Source: Muangsin / Weiss 3
Priority Queue (Heap) Operations
• insert (enqueue)
• deleteMin (dequeue) – smaller value higher priority– Find / save the minimum element, delete it from
structure and return it
Priority QueueinsertdeleteMin
![Page 4: CS 201 Data Structures and Algorithms](https://reader034.vdocument.in/reader034/viewer/2022051416/56813090550346895d966e30/html5/thumbnails/4.jpg)
Source: Muangsin / Weiss 4
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
![Page 5: CS 201 Data Structures and Algorithms](https://reader034.vdocument.in/reader034/viewer/2022051416/56813090550346895d966e30/html5/thumbnails/5.jpg)
Source: Muangsin / Weiss 5
Implementation using Binary Search Tree
• insert takes O(log N) time on the average
• deleteMin takes O(log N) time on the average
• support other operations that are not required by priority queue (for example, findMax)
• deleteMin operations make the tree unbalanced
![Page 6: CS 201 Data Structures and Algorithms](https://reader034.vdocument.in/reader034/viewer/2022051416/56813090550346895d966e30/html5/thumbnails/6.jpg)
Source: Muangsin / Weiss6
Binary Heap Implementation• Property 1: Structure Property• Binary tree & completely filled (bottom level is filled from left
to right) (complete binary tree)
• if height is h, size between 2h (bottom level has only one node) and 2h+1-1
A
C
GF
B
E
J
D
H I
![Page 7: CS 201 Data Structures and Algorithms](https://reader034.vdocument.in/reader034/viewer/2022051416/56813090550346895d966e30/html5/thumbnails/7.jpg)
Source: Muangsin / Weiss 7
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 floor(i/2)
or integer division in C
![Page 8: CS 201 Data Structures and Algorithms](https://reader034.vdocument.in/reader034/viewer/2022051416/56813090550346895d966e30/html5/thumbnails/8.jpg)
Source: Muangsin / Weiss 8
Property 2: 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
![Page 9: CS 201 Data Structures and Algorithms](https://reader034.vdocument.in/reader034/viewer/2022051416/56813090550346895d966e30/html5/thumbnails/9.jpg)
Source: Muangsin / Weiss 9
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
![Page 10: CS 201 Data Structures and Algorithms](https://reader034.vdocument.in/reader034/viewer/2022051416/56813090550346895d966e30/html5/thumbnails/10.jpg)
Source: Muangsin / Weiss 10
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
![Page 11: CS 201 Data Structures and Algorithms](https://reader034.vdocument.in/reader034/viewer/2022051416/56813090550346895d966e30/html5/thumbnails/11.jpg)
Source: Muangsin / Weiss 11
Insert
13
16
681921
3132
24
65 26
13
16
681921
3132
24
65 26
14
![Page 12: CS 201 Data Structures and Algorithms](https://reader034.vdocument.in/reader034/viewer/2022051416/56813090550346895d966e30/html5/thumbnails/12.jpg)
Source: Muangsin / Weiss 12
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
![Page 13: CS 201 Data Structures and Algorithms](https://reader034.vdocument.in/reader034/viewer/2022051416/56813090550346895d966e30/html5/thumbnails/13.jpg)
Source: Muangsin / Weiss 13
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
![Page 14: CS 201 Data Structures and Algorithms](https://reader034.vdocument.in/reader034/viewer/2022051416/56813090550346895d966e30/html5/thumbnails/14.jpg)
Source: Muangsin / Weiss 14
deleteMin
16
681921
32
19
65 26
14
31
16
681921
32
19
65 26
14
31
![Page 15: CS 201 Data Structures and Algorithms](https://reader034.vdocument.in/reader034/viewer/2022051416/56813090550346895d966e30/html5/thumbnails/15.jpg)
Source: Muangsin / Weiss 15
deleteMin
16
681921
32
19
65
14
31
26
16
681921
32
19
65
26
14
31
![Page 16: CS 201 Data Structures and Algorithms](https://reader034.vdocument.in/reader034/viewer/2022051416/56813090550346895d966e30/html5/thumbnails/16.jpg)
Source: Muangsin / Weiss 16
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)
![Page 17: CS 201 Data Structures and Algorithms](https://reader034.vdocument.in/reader034/viewer/2022051416/56813090550346895d966e30/html5/thumbnails/17.jpg)
Implementation in C - HeapStruct
17
#define MinPQSize (10)#define MinData (-32767)typedef int ElementType;
struct HeapStruct{ int Capacity; int Size; ElementType *Elements;};typedef struct HeapStruct *PriorityQueue;
![Page 18: CS 201 Data Structures and Algorithms](https://reader034.vdocument.in/reader034/viewer/2022051416/56813090550346895d966e30/html5/thumbnails/18.jpg)
Implementation in C - Initialize
18
PriorityQueue Initialize( int MaxElements ){ PriorityQueue H;
if( MaxElements < MinPQSize ) Error( "Priority queue size is too small" ); H = malloc( sizeof( struct HeapStruct ) ); if( H ==NULL ) FatalError( "Out of space!!!" );
/* Allocate the array plus one extra for sentinel */ H->Elements = malloc((MaxElements + 1)*sizeof(ElementType)); if( H->Elements == NULL ) FatalError( "Out of space!!!" );
H->Capacity = MaxElements; H->Size = 0; H->Elements[ 0 ] = MinData;
return H;}
![Page 19: CS 201 Data Structures and Algorithms](https://reader034.vdocument.in/reader034/viewer/2022051416/56813090550346895d966e30/html5/thumbnails/19.jpg)
19
int IsEmpty( PriorityQueue H ) { return H->Size == 0; }
int IsFull( PriorityQueue H ) { return H->Size == H->Capacity; }
Implementation in C – IsEmpty, IsFull
![Page 20: CS 201 Data Structures and Algorithms](https://reader034.vdocument.in/reader034/viewer/2022051416/56813090550346895d966e30/html5/thumbnails/20.jpg)
20
Implementation in C – Insert
/* H->Element[ 0 ] is a sentinel */
void Insert( ElementType X, PriorityQueue H ) { int i;
if( IsFull( H ) ) { Error( "Priority queue is full" ); return; }
for( i = ++H->Size; H->Elements[ i / 2 ] > X; i /= 2 ) H->Elements[ i ] = H->Elements[ i / 2 ];
H->Elements[ i ] = X; }
![Page 21: CS 201 Data Structures and Algorithms](https://reader034.vdocument.in/reader034/viewer/2022051416/56813090550346895d966e30/html5/thumbnails/21.jpg)
21
Implementation in C – DeleteMin
ElementType DeleteMin( PriorityQueue H ){ ElementType MinElement;
if( IsEmpty( H ) ) { Error( "Priority queue is empty" ); return H->Elements[0]; }
MinElement = H->Elements[ 1 ]; H->Elements[ 1 ] = H->Elements[ H->Size-- ]; percolateDown( H, 1 );
return MinElement;}
![Page 22: CS 201 Data Structures and Algorithms](https://reader034.vdocument.in/reader034/viewer/2022051416/56813090550346895d966e30/html5/thumbnails/22.jpg)
22
Implementation in C – percolateDown
void percolateDown( PriorityQueue H, int hole ){ int child; ElementType tmp = H->Elements[ hole ];
for( ; hole * 2 <= H->Size; hole = child ) { /* Find smaller child */ child = hole * 2; if (child != H->Size && H->Elements[child+1]<H->Elements[child]) child++; /* Percolate one level */ if( tmp > H->Elements[child] ) H->Elements[ hole ] = H->Elements[ child ]; else break; } H->Elements[ hole ] = tmp;}
![Page 23: CS 201 Data Structures and Algorithms](https://reader034.vdocument.in/reader034/viewer/2022051416/56813090550346895d966e30/html5/thumbnails/23.jpg)
Building a Heap
• Sometimes it is required to construct it from an initial collection of items O(NlogN) in the worst case.
• But insertions take O(1) on the average.
• Hence the question: is it possible to do any better?
23
![Page 24: CS 201 Data Structures and Algorithms](https://reader034.vdocument.in/reader034/viewer/2022051416/56813090550346895d966e30/html5/thumbnails/24.jpg)
buildHeap Algorithm• General Algorithm
• Place the N items into the tree in any order, maintaining the structure property.
• Call buildHeap
24
void buildHeap( PriorityQueue H, int N ){ int i;
for( i = N / 2; i > 0; i-- ) percolateDown( H, i );}
![Page 25: CS 201 Data Structures and Algorithms](https://reader034.vdocument.in/reader034/viewer/2022051416/56813090550346895d966e30/html5/thumbnails/25.jpg)
buildHeap Example - I
25
initialheap
afterpercolateDown(7)
afterpercolateDown(6)
afterpercolateDown(5)
![Page 26: CS 201 Data Structures and Algorithms](https://reader034.vdocument.in/reader034/viewer/2022051416/56813090550346895d966e30/html5/thumbnails/26.jpg)
26
buildHeap Example - II
afterpercolateDown(4)
afterpercolateDown(3)
afterpercolateDown(2)
afterpercolateDown(1)
![Page 27: CS 201 Data Structures and Algorithms](https://reader034.vdocument.in/reader034/viewer/2022051416/56813090550346895d966e30/html5/thumbnails/27.jpg)
Complexity of buildHeap• The number of dashed lines must be bounded which can simply
be done by computing the sum of the heights of all the nodes in the heap.
• Theorem: For a perfect binary tree of height h with N=2h+1-1 nodes, this sum is 2h+1-1-(h+1).
• Proof:
• number of nodes in a complete tree of height h is less than or equal to the the number of nodes in a perfect binary tree of the same height. Therefore, O(N)
27
)1(1222...8422
)1(2...)3(16)2(8)1(4)(22
)1(2...)4(16)3(8)2(4)1(2)(1)(2
11
1
0
hhSSS
hhhhS
hhhhhihS
hhh
h
hh
i
i