Priority Queues and Heaps

1. Priority Queues and Heaps

2. Priority Queues • We already know a ”standard” queue: • Elements can only be added to the start of the queue • Elements can only be removed from the end of the queue • Order of removal is FIFO (first in, first out) DCS – SWC

3. Priority Queues • In a Priority Queue, each element is assigned a priority as well • A priority is a numeric value – the lower the number, the higher the priority • Elements are removed in order of their priority – no longer FIFO • Can still add elements in any order DCS – SWC

4. Priority Queues public interface PriorityQueue<T> { void add(T element); T remove(); T peek(); } DCS – SWC

5. Priority Queues • The interface to a priority queue is almost the same as to a regular queue • However, elements in the queue must now be of the type Comparable (i.e. implement the interface) • The remove method always returns the element with highest priority (lowest numeric value…) DCS – SWC

6. Priority Queues • A Priority Queue is an abstract data structure, which can be implemented in various ways • Linked list, removal will be O(n) • Binary search tree, removal will usually be O(log(n)), but not always • Heap, removal will always be O(log(n)) DCS – SWC

7. Heaps • A Heap is a Binary Tree, but not a Binary Search Tree • In order for a Binary Tree to be a Heap, two conditions must be fulfilled: • A heap is almost complete; only nodes missing in bottom layer • All nodes store values which are at most as large as the values stored in any descendant DCS – SWC

8. Heaps DCS – SWC

9. Heaps • On a heap, only two operations are of interest: • Insert a new element • Remove the element with lowest value, i.e. the root element • However, both of these operations must preserve the heap property of the tree DCS – SWC

10. Heaps - insertion 32 23 29 42 37 56 Find an empty slot in the tree DCS – SWC

11. Heaps - insertion 32 23 29 42 If the value in the parent is larger than the new value, swap the parent and the new slot (repeat this) 37 56 DCS – SWC

12. Heaps - insertion 32 23 29 32 37 56 42 Now insert the new value DCS – SWC

13. Heaps - insertion • Since the heap is ”almost complete”, the number of layers in a tree with n nodes is at most (log(n) + 1) • Each swap operation can be done in constant time, so insertion of an element has the run-time complexity O(log(n)) DCS – SWC

14. Heaps - removal Remove the root node (always smallest) 23 29 32 37 56 42 DCS – SWC

15. Heaps - removal 29 32 Move the last element into the root position 37 56 42 DCS – SWC

16. Heaps - removal If any child has a lower value, swap position with child with lowest value (repeat this) 42 29 32 37 56 DCS – SWC

17. Heaps - removal If any child has a lower value, swap position with child with lowest value (repeat this) 29 42 32 37 56 DCS – SWC

18. Heaps - removal The heap property has now been reestablished This is known as ”fixing the heap” 29 37 32 42 56 DCS – SWC

19. Heaps - removal • Since the heap is ”almost complete”, the number of layers in a tree with n nodes is at most (log(n) + 1) • Each swap operation can be done in constant time, so deletion of an element has the run-time complexity O(log(n)) DCS – SWC

20. Heaps - removal • The important point is that for a heap, we are guaranteed O(log(n)) run time for insertion and deletion • This cannot be guaranteed for a binary search tree • A binary search tree can ”degenerate” into a linked list; a heap cannot DCS – SWC

21. Heaps - representation • Due to the regularity of a heap, it can efficiently be stored in an array • Root node is stored in position 1 (not 0) • A node in position i has its children stored in position 2i and (2i + 1) • A node in position i has its parent stored in position i/2 (integer division) • When running out of space, double the size DCS – SWC

22. Heapsort • A heap can be used for a quite efficient way of sorting an array of n objects • Run-time complexity of O(nlog(n)) • Does not use extra space • Main steps • Turn the array into a heap • Repeatedly remove the root element (which has the smallest value) DCS – SWC

23. Heapsort • In order to turn the array into a heap, we could just insert all the elements into a new heap • However, we can do this without using an extra heap! • We use the ”fix heap” procedure from the bottom in the tree and upwards DCS – SWC

24. Heapsort • Why will this work…? • Remember that the ”fix heap” procedure takes two ”subheaps” as input, plus a root node with a ”wrong” value • If we work from the bottom and up, the input will always be like above DCS – SWC

25. Heapsort Fix heap here Fix heaps here Fix heaps here Trivially a heap DCS – SWC

26. Heapsort • Now the tree is a heap • Repeatedly remove the root from the heap, and fix the remaining heap • We ”remove” the root by placing it at the end of the array, beyond the last element in the remaining heap DCS – SWC

27. Heapsort 23 29 32 37 56 42 23 29 32 37 56 42 DCS – SWC

28. Heapsort 29 32 37 56 42 29 32 37 56 42 23 DCS – SWC

29. Heapsort 29 37 32 42 56 29 37 32 42 56 23 DCS – SWC

30. Heapsort 37 32 42 56 37 32 42 56 29 23 DCS – SWC

31. Heapsort 32 37 56 42 32 37 56 42 29 23 DCS – SWC

32. Heapsort 37 56 42 37 56 42 32 29 23 DCS – SWC

33. Heapsort 37 42 56 37 42 56 32 29 23 DCS – SWC

34. Heapsort 42 56 42 56 37 32 29 23 DCS – SWC

35. Heapsort 42 56 42 56 37 32 29 23 DCS – SWC

36. Heapsort 56 56 42 37 32 29 23 DCS – SWC

37. Heapsort 56 56 42 37 32 29 23 DCS – SWC

38. Heapsort 56 42 37 32 29 23 DCS – SWC

39. Heapsort • One minor issue – numbers are sorted in wrong order • Could just reverse order, takes O(n) • Or use max-heap • Min-heap: All nodes store values at most as large as the values stored in any descendant • Max-heap: All nodes store values at least as large as the values stored in any descendant DCS – SWC