1. CSC 213 – Large Scale Programming

2. Priority Queue ADT  Prioritizes Entry s using their keys  For Entry s with equal priorities, order not specified  Priority given to each value when added to PQ  Normally, the priority not changeable while in PQ  Access single Entry : one with the lowest priority  Returns Entry using min() or removeMin()  Location are imaginary – only smallest matters

3. Heaps  Binary-tree based PQ implementation  Still structured using parent-child relationship  At most 2 children & 1 parent for each node in tree  Heaps must also satisfy 2 additional properties  Parent at least as important as its children  Structure must form a complete binary tree 2 95 67

4. Legal CompleteBinaryTree  ADT which extends BinaryTree  Add & remove methods defined plus those inherited  For this ADT, trees must maintain specific shape  Fill lowest level first, then can start new level below it 2 95 67 Illegal 2 95 7 6

5. CompleteBinaryTree  ADT which extends BinaryTree  Add & remove methods defined plus those inherited  For this ADT, trees must maintain specific shape  Fill lowest level first, then can start new level below it  Lowest level must be filled in from left-to-right Legal 2 95 67 Illegal 2 95 67

6. What Is Purpose of a Heap?  Root has critical Entry that we always access  Entry at root always has smallest priority in Heap  O(1) access time in min() without any real effort  CompleteBinaryTree makes insert() easy  Create leftmost child on lowest level  When a level completes, start next one  Useful when:

7. Upheap  Insertion may violate heap-order property  Upheap immediately after adding new Entry  Goes from new node to restore heap’s order  Compare priority of node & its parent  If out of order, swap node's Entry s  Continue upheaping from parent node  Stop only when either case occurs:  Found properly ordered node & parent  Binary tree's root is reached

8. 6 insert() in a Heap 2 5 79

9. 6 1 2 5 79

10. 6 1 Start your upheaping! 2 5 79

11. 6 1 2 5 79

12. 1 6 2 5 79

13. 1 6 Upheaping Must Continue 2 5 79

14. 1 6 2 5 79

15. 2 6 Upheaping Sounds Icky 1 5 79

16. 2 6 Check If We Should Continue 1 5 79

17. 2 6 Stop At The Root 1 5 79

18. 2 6 insert() Once Again 1 5 793

19. 2 6 Upheaping Begins Anew 1 5 793

20. 2 6 Already Obeys Heap Order Property 1 5 793

21. 2 6 We Are Done With This Upheap! 1 5 793

22. Removing From a Heap  removeMin() must kill Entry at heap’s root  For a complete tree, must remove last node added  How to reconcile these two different demands?  Removed node's Entry moved to the root  Then remove node from the complete tree  Heap's order preserved by going down

23. Downheap  Restores heap’s order during removeMin()  Downheap work starts at root  Swap with smallest child, if at least out-of-order  Downheaping continues with old smallest child  Stop at leaf or when node is legal

24. 5 Before removeMin() is called 1 2 97

25. 5 Move Last Entry Up To Root 1 2 97

26. 5 1 2 97

27. 5 9 2 7

28. 5 Compare Parent With Smaller Child 9 2 7

29. 5 9 2 7

30. 5 2 9 7

31. 5 Continue Downheaping With New Node 2 9 7

32. 5 2 9 7

33. 5 Swap If Out Of Order 2 7 9

34. 5 Check If We Should Continue 2 7 9

35. 5 Stop When We Reach a Leaf 2 7 9

36. Implementation Excuses  upheap & downheap travel height of tree  O (log n ) running time for each of these  Serves as bound for adding & removing from PQ  What drawbacks does heap have?  PriorityQueue can be faster using Sequence  Only for specific mix of operations, however  PriorityQueue using heaps are fastest overall

37. For Next Lecture  No weekly assignment this week  Instead, spend then time to prepare for midterm  Programming project #1 available  Tomorrow is 2 nd "check-in" – test cases are due  Read discussions of sorts from Chapter 8  How can we sort data using a priority queue?  What are the speed differences?  Why would it make a difference?