1. CSC211 Data Structures Lecture 18 Heaps and Priority Queues Instructor: Prof. Xiaoyan Li Department of Computer Science Mount Holyoke College

2. p BST and B-Tree p The BST rules and The B-Tree Rules p Search for an Item in a BST and B-Tree p Insert an Item in BST and a B-Tree (*) p Remove an Item from a BST and B-Tree (*) Review: BST & B-Tree

3. Example: Is it a BST? ¶How to search an item? ¶Iowa ¶How to add an item? ¶Vermont ¶How to remove an item? ¶Florida Arizona Arkansas Washington Oklahoma Colorado Florida West Virginia Mass. New Hampshire Iowa

4. Examples: is it a B-Tree? 2 and 4 6 7 and 8 9 10 531 The 6 B-tree rules:  Entries in a node (3 rules): (minimum, maximum, storage )  Subtrees: (2 rules) (the number of subtrees, entry at index i and entries at subtree I or subtree i+1 )  Tree-leaves: (1 rule) (same depth)

5. p p Chapter 11 has several programming projects, including a project that uses heaps. p p This presentation shows you what a heap is, and demonstrates two of the important heap algorithms. Heaps Data Structures and Other Objects Using C++

6. Topics p Heap Definition p Heap Applications p priority queues (chapter 8), sorting (chapter 13) p Two Heap Operations – add, remove p reheapification upward and downward p why is a heap good for implementing a priority queue? p Heap Implementation p using binary_tree_node class p using fixed size or dynamic arrays

7. Heaps Definition A heap is a certain kind of complete binary tree.

8. Heaps A heap is a certain kind of complete binary tree. When a complete binary tree is built, its first node must be the root. When a complete binary tree is built, its first node must be the root. Root

9. Heaps Complete binary tree. Left child of the root The second node is always the left child of the root. The second node is always the left child of the root.

10. Heaps Complete binary tree. Right child of the root The third node is always the right child of the root. The third node is always the right child of the root.

11. Heaps Complete binary tree. The next nodes always fill the next. level from left-to-right. The next nodes always fill the next. level from left-to-right.

12. Heaps Complete binary tree. The next nodes always fill the next level from left-to-right. The next nodes always fill the next level from left-to-right.

13. Heaps Complete binary tree. The next nodes always fill the next level from left-to-right. The next nodes always fill the next level from left-to-right.

14. Heaps Complete binary tree. The next nodes always fill the next level from left-to-right. The next nodes always fill the next level from left-to-right.

15. Heaps Complete binary tree.

16. Heaps A heap is a certain kind of complete binary tree. Each node in a heap contains a key that can be compared to other nodes' keys. Each node in a heap contains a key that can be compared to other nodes' keys. 19 4222127 23 45 35

17. Heaps A heap is a certain kind of complete binary tree. The "heap property" requires that each node's key is >= the keys of its children The "heap property" requires that each node's key is >= the keys of its children 19 4222127 23 45 35

18. What it is not: It is not a BST p In a binary search tree, the entries of the nodes can be compared with a strict weak ordering. Two rules are followed for every node n: p The entry in node n is NEVER less than an entry in its left subtree p The entry in the node n is less than every entry in its right subtree. p BST is not necessarily a complete tree

19. What it is: Heap Definition p A heap is a binary tree where the entries of the nodes can be compared with the less than operator of a strict weak ordering. In addition, two rules are followed: p The entry contained by the node is NEVER less than the entries of the node’s children p The tree is a COMPLETE tree. p Q: where is the largest entry?  for what....

20. Application : Priority Queues p A priority queue is a container class that allows entries to be retrieved according to some specific priority levels p The highest priority entry is removed first p If there are several entries with equally high priorities, then the priority queue’s implementation determines which will come out first (e.g. FIFO) p Heap is suitable for a priority queue

21. The Priority Queue ADT with Heaps p The entry with the highest priority is always at the root node p Focus on two priority queue operations p adding a new entry p remove the entry with the highest priority p In both cases, we must ensure the tree structure remains to be a heap p we are going to work on a conceptual heap without worrying about the precise implementation p later I am going to show you how to implement...

22. Adding a Node to a Heap ¶ ¶Put the new node in the next available spot. · ·Push the new node upward, swapping with its parent until the new node reaches an acceptable location. 19 4222127 23 45 35 42

23. Adding a Node to a Heap ¶ ¶Put the new node in the next available spot. · ·Push the new node upward, swapping with its parent until the new node reaches an acceptable location. 19 4222142 23 45 35 27

24. Adding a Node to a Heap ¶ ¶Put the new node in the next available spot. · ·Push the new node upward, swapping with its parent until the new node reaches an acceptable location. 19 4222135 23 45 42 27

25. Adding a Node to a Heap 4 4The parent has a key that is >= new node, or 4 4The node reaches the root. Ú reheapification ÚThe process of pushing the new node upward is called reheapification upward. 19 4222135 23 45 42 27 Note: Note: we need to easily go from child to parent as well as parent to child.

26. Removing the Top of a Heap ¶ ¶Move the last node onto the root. 19 4222135 23 45 42 27

27. Removing the Top of a Heap ¶ ¶Move the last node onto the root. 19 4222135 23 27 42

28. Removing the Top of a Heap ¶ ¶Move the last node onto the root. · ·Push the out-of-place node downward, swapping with its larger child until the new node reaches an acceptable location. 19 4222135 23 27 42

29. Removing the Top of a Heap ¶ ¶Move the last node onto the root. · ·Push the out-of-place node downward, swapping with its larger child until the new node reaches an acceptable location. 19 4222135 23 42 27

30. Removing the Top of a Heap ¶ ¶Move the last node onto the root. · ·Push the out-of-place node downward, swapping with its larger child until the new node reaches an acceptable location. 19 4222127 23 42 35

31. Removing the Top of a Heap 4 4The children all have keys <= the out-of-place node, or 4 4The node reaches the leaf. Ø reheapification ØThe process of pushing the new node downward is called reheapification downward. 19 4222127 23 42 35

32. Priority Queues Revisited p A priority queue is a container class that allows entries to be retrieved according to some specific priority levels p The highest priority entry is removed first p If there are several entries with equally high priorities, then the priority queue’s implementation determines which will come out first (e.g. FIFO) p Heap is suitable for a priority queue

33. Adding a Node: same priority ¶ ¶Put the new node in the next available spot. · ·Push the new node upward, swapping with its parent until the new node reaches an acceptable location. 19 4222127 23 45 35 45*

34. Adding a Node : same priority ¶ ¶Put the new node in the next available spot. · ·Push the new node upward, swapping with its parent until the new node reaches an acceptable location. 19 4222145* 23 45 35 27

35. Adding a Node : same priority ¶ ¶Put the new node in the next available spot. · ·Push the new node upward, swapping with its parent until the new node reaches an acceptable location. 19 4222135 23 45 45* 27

36. Adding a Node : same priority 4 4The parent has a key that is >= new node, or 4 4The node reaches the root. Ú reheapification ÚThe process of pushing the new node upward is called reheapification upward. 19 4222135 23 45 45* 27 Note: Implementation determines which 45 will be in the root, and will come out first when popping.

37. Removing the Top of a Heap 4 4The children all have keys <= the out-of-place node, or 4 4The node reaches the leaf. Ø reheapification ØThe process of pushing the new node downward is called reheapification downward. 19 4222127 23 45* 35 Note: Implementation determines which 45 will be in the root, and will come out first when popping.

38. Heap Implementation (how?) p Use binary_tree_node class p node implementation is for a general binary tree p but we may need to have doubly linked node p Use arrays (page 475) p A heap is a complete binary tree p which can be implemented more easily with an array than with the node class p and do two-way links

39. Implementing a Heap p We will store the data from the nodes in a partially-filled array. An array of data 2127 23 42 35

40. Implementing a Heap p Data from the root goes in the first location of the array. An array of data 2127 23 42 35 42

41. Implementing a Heap p Data from the next row goesin the p Data from the next row goes in the next two array locations. An array of data 2127 23 42 35 423523

42. Implementing a Heap p Data from the next row goesin the p Data from the next row goes in the next two array locations. An array of data 2127 23 42 35 423523 2721

43. Implementing a Heap p Data from the next row goesin the p Data from the next row goes in the next two array locations. An array of data 2127 23 42 35 423523 2721 We don't care what's in this part of the array.

44. Important Points about the Implementation p The links between the tree's nodes are not actually stored as pointers, or in any other way. p The only way we "know" that "the array is a tree" is from the way we manipulate the data. An array of data 2127 23 42 35 423523 2721

45. Important Points about the Implementation p If you know the index of a node, then it is easy to figure out the indexes of that node's parent and children. Formulas are given in the book. [0] [0] [1] [2] [3] [4] 2127 23 42 35 423523 2721

46. Formulas for location children and parents in an array representation p Root at location [?] p Parent of the node in [i] is at [?] p Children of the node in [i] (if exist) is at [ ? ] and [ ? ]

47. Formulas for location children and parents in an array representation p Root at location [0] p Parent of the node in [i] is at [(i-1)/2] p Children of the node in [i] (if exist) is at [2i+1] and [2i+2] p Test: p complete tree of 10, 000 nodes p parent of 4999 is at p children of 4999 is at _____ and _____

48. Can you implement the heap class now? p Private variables: p Public functions:

49. Solutions... template class heap { public: heap () void push(const Item& entry); // add Item& pop(); // remove the highest size_t parent (size_t k) const ; size_t l_child (size_t k) const ; size_t r_child (size_t k) const ; private: Item data[CAPACITY]; size_type used; }

50. Solutions... template class heap { public: heap () { used = 0;} void push(const Item& entry); // add Item& pop(); // remove the highest size_t parent (size_t k) const { return (k-1)/2;} size_t l_child (size_t k) const { return 2*k+1;} size_t r_child (size_t k) const { return 2*k+2;} private: Item data[CAPACITY]; size_type used; }

51. Solutions...more p Can you implement the add and remove with the knowledge of these formulas? p Add p Remove template class heap { public: heap () { used = 0;} void push(const Item& entry); // add Item& pop(); // remove the highest size_t parent (size_t k) const { return (k-1)/2;} size_t l_child (size_t k) const { return 2*k+1;} size_t r_child (size_t k) const { return 2*k+2;} private: Item data[CAPACITY]; size_type used; }

52. Solutions...more p Can you implement the add and remove with the knowledge of these formulas? p Add p put the new entry in the last location p p Push the new node upward, swapping with its parent until the new node reaches an acceptable location p Remove p move the last node to the root p p Push the out-of-place node downward, swapping with its larger child until the new node reaches an acceptable location template class heap { public: heap () { used = 0;} void push(const Item& entry); // add Item& pop(); // remove the highest size_t parent (size_t k) const { return (k-1)/2;} size_t l_child (size_t k) const { return 2*k+1;} size_t r_child (size_t k) const { return 2*k+2;} private: Item data[CAPACITY]; size_type used; }

53. template void heap ::push(const Item& entry) { size_type i; data[used++] = entry; i = used –1; while ( ( i != 0 && (data[i] > data[( i-1)/2]) { swap(data[i], data[( i-1)/2]); i = ( i-1)/2; }

54. p p A heap is a complete binary tree, where the entry at each node is greater than or equal to the entries in its children. p p To add an entry to a heap, place the new entry at the next available spot, and perform a reheapification upward. p p To remove the biggest entry, move the last node onto the root, and perform a reheapification downward. Summary

55. T HE E ND Presentation copyright 1997 Addison Wesley Longman, For use with Data Structures and Other Objects Using C++ by Michael Main and Walter Savitch. Some artwork in the presentation is used with permission from Presentation Task Force (copyright New Vision Technologies Inc) and Corel Gallery Clipart Catalog (copyright Corel Corporation, 3G Graphics Inc, Archive Arts, Cartesia Software, Image Club Graphics Inc, One Mile Up Inc, TechPool Studios, Totem Graphics Inc). Students and instructors who use Data Structures and Other Objects Using C++ are welcome to use this presentation however they see fit, so long as this copyright notice remains intact.