1. Priority Queues Binary Heaps
Mark Allen Weiss: Data Structures and Algorithm Analysis in Java
Priority Queues
Priority Queues
Binary Heaps

2. Priority Queues The model Implementations Binary heaps
Basic operations
Animation

3. The Model A priority queue is a queue where:
Requests are inserted in the order of arrival
The request with highest priority is processed first (deleted from the queue)
The priority is indicated by a number, the lower the number - the higher the priority.

4. Implementations Linked list: - Insert at the beginning - O(1)
-      Find the minimum - O(N)
Binary search tree (BST):
-      Insert O(logN)
-      Find minimum - O(logN)

5. Implementations Binary heap - Insert O(logN) - Find minimum O(logN)
Better than BST because it does not support links
-      Insert O(logN)
-      Find minimum O(logN)
Deleting the minimal element takes a constant time, however after that the heap structure has to be adjusted, and this requires O(logN) time.

6. Binary Heap Heap-Structure Property:
Complete Binary Tree - Each node has two children, except for the last two levels.
The nodes at the last level do not have children. New nodes are inserted at the last level from left to right.
Heap-Order Property:
Each node has a higher priority than its children

7. Binary Heap Next node to be inserted - right child of the yellow node6 10 12 15 17 18 23 20 19 34
Next node to be inserted - right child of the yellow node

8. Binary heap implementation with an array
Root - A(1)
Left Child of A(i) - A(2i)
Right child of A(i) - A(2i+1)
Parent of A(I) - A([i/2]).
The smallest element is always at the root, the access time to the element with highest priority is constant O(1).

9. Example Consider 17: position in the array - 5.
Consider 17:
position in the array
parent 10 is at position [5/2] = 2
left child is at position 5*2 = 10 (this is 34)
right child - position 2*5 + 1 = 11 (empty.)

10. Problems
Problem 1:
Reconstruct the binary heap

11. Problems Problem 2: Give the array representation for 3 10 16 13 12 1823 15 19 30 14

12. Basic Operations Insert a node – Percolate Up
Delete a node – Percolate Down
Decrease key, Increase key, Remove key
Build the heap

13. Percolate Up – Insert a Node
A hole is created at the bottom of the tree, in the next available position. 6 10 12 15 17 18 23 20 19 34

14. Percolate Up
Insert 20 6 10 12 15 17 18 23 21 19 34 20

15. Percolate Up
Insert 16 6 10 12 15 18 23 21 19 34 17

16. Percolate Up Complexity of insertion: O(logN) 6 10 12 15 18 23 21 1934 17 16
Complexity of insertion: O(logN)

17. Percolate Down – Delete a Node10 16 13 12 18 23 15 19 30 34

18. Percolate Down – the wrong way10 16 13 12 18 23 15 19 30 34

19. Percolate Down – the wrong way16 13 18 23 15 19 34 10 12 30
The empty hole violates the heap-structure property

20. Percolate Down Last element - 20. The hole at the root. 10 16 12 13 1823 15 19 30 20
We try to insert 20 in the hole by percolating the hole down

21. Percolate Down 16 12 13 18 23 15 19 30 20 10

22. Percolate Down 16 13 18 23 15 19 30 20 10 12

23. Percolate Down 10 12 15 Complexity of deletion: O(logN) 16 13 18 23 2019 30 10 12 15
Complexity of deletion: O(logN)

24. Other Heap Operations
 1. DecreaseKey(p,d)
increase the priority of element p in the heap with a positive value d. percolate up.
2. IncreaseKey(p,d)
decrease the priority of element p in the heap with a positive value d.
percolate down.

25. Other Heap Operations 3. Remove(p)
 a. Assigning the highest priority to p - percolate p up to the root.
 b.  Deleting the element in the root and filling the hole by percolating down and trying to insert the last element in the queue.
 4. BuildHeap
input N elements
· place them into an empty heap through successive inserts. The worst case running time is O(NlogN).

26. Build Heap - O(N)
Given an array of elements to be inserted in the heap,
treat the array as a heap with order property violated,
and then do operations to fix the order property.

27. Example:
150 80 40 30 10 70
110
100 20 90 60 50
120
140
130

28. Example (cont) After processing height 1 150 80 40 50 110 20 10 100 3090 60 70
120
140
130

29. Example (cont) After processing height 2 150 10 40 50 110 20 60 100 3090 80 70
120
140
130

30. Example (cont) After processing height 3 10 20 40 50 110 30 60 100 90
150 90 80 70
120
140
130

31. Theorem
For a perfect binary tree of height h containing N = 2 h nodes,
the sum S of the heights of the nodes is
S = 2 h (h + 1) = O(N)

32. Proof
The tree has 1 node at height h, 2 nodes at height h-1, 4 nodes at height h -2, etc
1 (20) h
2 (21) h - 1
4 (22) h - 2
8 (23) h - 3
…….
2 h
S =  2i (h - i), i = 0 to h

33. S = h + 2(h - 1) + 4(h - 2) + 8 (h - 3) + …. 2(h-2).2 + 2(h-1).1 (1)
Subtract (1) from (2):
S = h -2h …. 2 h
= - h (2 h+1 - 1)
= (2 h+1 - 1) - (h + 1)

34. Proof (cont.) Note: 1 + 2 + 4 + 8 + …. 2 h = (2 h+1 - 1)
Hence S = (2 h+1 - 1) - (h + 1)
Hence the complexity of building a heap with N nodes is linear O(N)