1. 1 Chapter 25 Trees Iterators Heaps Priority Queues

2. 2 Objectives F To design and implement a binary search tree (§25.2). F To insert an element to a binary search tree (§25.2.2). F To traverse elements in a binary tree (§25.2.3). F To delete elements from a binary search tree (§25.3). F To create iterators for traversing a binary tree (§25.4). F To design and implement a heap (§25.5). F To design and implement a priority queue (§25.6).

3. 3 Binary Trees F A list, stack, or queue is a linear structure –consists of a sequence of elements F A binary tree is a hierarchical structure –It is either empty or consists of an element called the root and two distinct binary trees called the u left subtree and u right subtree

4. 4 See How a Binary Tree Works www.cs.armstrong.edu/liang/intro7e/exer cise/Exercise25_15.html

5. 5 Binary Tree Terms F root of left (right) subtree of a node is called a left (right) child of the node F leaf - –A node without children F binary search tree – A special type of binary tree is often useful F A binary search tree (with no duplicate elements) has the property that for every node in the tree : –the value of any node in its left subtree is less than the value of the node and –the value of any node in its right subtree is greater than the value of the node F The binary trees in Figure 25.1 are all binary search trees. This section is concerned with binary search trees.

6. 6 Representing Binary Trees F A binary tree can be represented using a set of linked nodes F Each node contains: – a value and two links named left and right that reference the left child and right child, respectively class TreeNode { E element; TreeNode left; TreeNode right; public TreeNode(E o) { element = o; }

7. 7 Inserting an Element to a Binary Tree F If a binary tree is empty –create a root node with the new element F Otherwise –locate the parent node for the new element node –If the new element is less than the parent element u the node for the new element becomes the left child of the parent –If the new element is greater than the parent element u the node for the new element becomes the right child of the parent

8. 8 Inserting an Element to a Binary Tree if (root == null) root = new TreeNode(element); else { // Locate the parent node current = root; while (current != null) if (element value < the value in current.element) { parent = current; current = current.left; } else if (element value > the value in current.element) { parent = current; current = current.right; } else return false; // Duplicate node not inserted // Create the new node and attach it to the parent node if (element < parent.element) parent.left = new TreeNode(elemenet); else parent.right = new TreeNode(elemenet); return true; // Element inserted } Insert 101 into the following tree.

9. 9 Trace Inserting 101 into the following tree if (root == null) root = new TreeNode(element); else { // Locate the parent node current = root; while (current != null) if (element value < the value in current.element) { parent = current; current = current.left; } else if (element value > the value in current.element) { parent = current; current = current.right; } else return false; // Duplicate node not inserted // Create the new node and attach it to the parent node if (element < parent.element) parent.left = new TreeNode(elemenet); else parent.right = new TreeNode(elemenet); return true; // Element inserted } Insert 101 into the following tree.

10. 10 Trace Inserting 101 into the following tree, cont. if (root == null) root = new TreeNode(element); else { // Locate the parent node current = root; while (current != null) if (element value < the value in current.element) { parent = current; current = current.left; } else if (element value > the value in current.element) { parent = current; current = current.right; } else return false; // Duplicate node not inserted // Create the new node and attach it to the parent node if (element < parent.element) parent.left = new TreeNode(elemenet); else parent.right = new TreeNode(elemenet); return true; // Element inserted } Insert 101 into the following tree.

11. 11 Trace Inserting 101 into the following tree, cont. if (root == null) root = new TreeNode(element); else { // Locate the parent node current = root; while (current != null) if (element value < the value in current.element) { parent = current; current = current.left; } else if (element value > the value in current.element) { parent = current; current = current.right; } else return false; // Duplicate node not inserted // Create the new node and attach it to the parent node if (element < parent.element) parent.left = new TreeNode(elemenet); else parent.right = new TreeNode(elemenet); return true; // Element inserted } Insert 101 into the following tree.

12. 12 Trace Inserting 101 into the following tree, cont. if (root == null) root = new TreeNode(element); else { // Locate the parent node current = root; while (current != null) if (element value < the value in current.element) { parent = current; current = current.left; } else if (element value > the value in current.element) { parent = current; current = current.right; } else return false; // Duplicate node not inserted // Create the new node and attach it to the parent node if (element < parent.element) parent.left = new TreeNode(elemenet); else parent.right = new TreeNode(elemenet); return true; // Element inserted } Insert 101 into the following tree. 101 < 60?

13. 13 Trace Inserting 101 into the following tree, cont. if (root == null) root = new TreeNode(element); else { // Locate the parent node current = root; while (current != null) if (element value < the value in current.element) { parent = current; current = current.left; } else if (element value > the value in current.element) { parent = current; current = current.right; } else return false; // Duplicate node not inserted // Create the new node and attach it to the parent node if (element < parent.element) parent.left = new TreeNode(elemenet); else parent.right = new TreeNode(elemenet); return true; // Element inserted } Insert 101 into the following tree. 101 > 60?

14. 14 Trace Inserting 101 into the following tree, cont. if (root == null) root = new TreeNode(element); else { // Locate the parent node current = root; while (current != null) if (element value < the value in current.element) { parent = current; current = current.left; } else if (element value > the value in current.element) { parent = current; current = current.right; } else return false; // Duplicate node not inserted // Create the new node and attach it to the parent node if (element < parent.element) parent.left = new TreeNode(elemenet); else parent.right = new TreeNode(elemenet); return true; // Element inserted } Insert 101 into the following tree. 101 > 60 true

15. 15 Trace Inserting 101 into the following tree, cont. if (root == null) root = new TreeNode(element); else { // Locate the parent node current = root; while (current != null) if (element value < the value in current.element) { parent = current; current = current.left; } else if (element value > the value in current.element) { parent = current; current = current.right; } else return false; // Duplicate node not inserted // Create the new node and attach it to the parent node if (element < parent.element) parent.left = new TreeNode(elemenet); else parent.right = new TreeNode(elemenet); return true; // Element inserted } Insert 101 into the following tree. 101 > 60 true

16. 16 Trace Inserting 101 into the following tree, cont. if (root == null) root = new TreeNode(element); else { // Locate the parent node current = root; while (current != null) if (element value < the value in current.element) { parent = current; current = current.left; } else if (element value > the value in current.element) { parent = current; current = current.right; } else return false; // Duplicate node not inserted // Create the new node and attach it to the parent node if (element < parent.element) parent.left = new TreeNode(elemenet); else parent.right = new TreeNode(elemenet); return true; // Element inserted } Insert 101 into the following tree. 101 > 60 true

17. 17 Trace Inserting 101 into the following tree, cont. if (root == null) root = new TreeNode(element); else { // Locate the parent node current = root; while (current != null) if (element value < the value in current.element) { parent = current; current = current.left; } else if (element value > the value in current.element) { parent = current; current = current.right; } else return false; // Duplicate node not inserted // Create the new node and attach it to the parent node if (element < parent.element) parent.left = new TreeNode(elemenet); else parent.right = new TreeNode(elemenet); return true; // Element inserted } Insert 101 into the following tree. 101 > 100 false

18. 18 Trace Inserting 101 into the following tree, cont. if (root == null) root = new TreeNode(element); else { // Locate the parent node current = root; while (current != null) if (element value < the value in current.element) { parent = current; current = current.left; } else if (element value > the value in current.element) { parent = current; current = current.right; } else return false; // Duplicate node not inserted // Create the new node and attach it to the parent node if (element < parent.element) parent.left = new TreeNode(elemenet); else parent.right = new TreeNode(elemenet); return true; // Element inserted } Insert 101 into the following tree. 101 > 100 true

19. 19 Trace Inserting 101 into the following tree, cont. if (root == null) root = new TreeNode(element); else { // Locate the parent node current = root; while (current != null) if (element value < the value in current.element) { parent = current; current = current.left; } else if (element value > the value in current.element) { parent = current; current = current.right; } else return false; // Duplicate node not inserted // Create the new node and attach it to the parent node if (element < parent.element) parent.left = new TreeNode(elemenet); else parent.right = new TreeNode(elemenet); return true; // Element inserted } Insert 101 into the following tree. 101 > 100 true

20. 20 Trace Inserting 101 into the following tree, cont. if (root == null) root = new TreeNode(element); else { // Locate the parent node current = root; while (current != null) if (element value < the value in current.element) { parent = current; current = current.left; } else if (element value > the value in current.element) { parent = current; current = current.right; } else return false; // Duplicate node not inserted // Create the new node and attach it to the parent node if (element < parent.element) parent.left = new TreeNode(elemenet); else parent.right = new TreeNode(elemenet); return true; // Element inserted } Insert 101 into the following tree. 101 > 100 true

21. 21 Trace Inserting 101 into the following tree, cont. if (root == null) root = new TreeNode(element); else { // Locate the parent node current = root; while (current != null) if (element value < the value in current.element) { parent = current; current = current.left; } else if (element value > the value in current.element) { parent = current; current = current.right; } else return false; // Duplicate node not inserted // Create the new node and attach it to the parent node if (element < parent.element) parent.left = new TreeNode(elemenet); else parent.right = new TreeNode(elemenet); return true; // Element inserted } Insert 101 into the following tree. 101 > 100 true

22. 22 Trace Inserting 101 into the following tree, cont. if (root == null) root = new TreeNode(element); else { // Locate the parent node current = root; while (current != null) if (element value < the value in current.element) { parent = current; current = current.left; } else if (element value > the value in current.element) { parent = current; current = current.right; } else return false; // Duplicate node not inserted // Create the new node and attach it to the parent node if (element < parent.element) parent.left = new TreeNode(elemenet); else parent.right = new TreeNode(elemenet); return true; // Element inserted } Insert 101 into the following tree. 101 < 107 true

23. 23 Trace Inserting 101 into the following tree, cont. if (root == null) root = new TreeNode(element); else { // Locate the parent node current = root; while (current != null) if (element value < the value in current.element) { parent = current; current = current.left; } else if (element value > the value in current.element) { parent = current; current = current.right; } else return false; // Duplicate node not inserted // Create the new node and attach it to the parent node if (element < parent.element) parent.left = new TreeNode(elemenet); else parent.right = new TreeNode(elemenet); return true; // Element inserted } Insert 101 into the following tree. 101 < 107 true

24. 24 Trace Inserting 101 into the following tree, cont. if (root == null) root = new TreeNode(element); else { // Locate the parent node current = root; while (current != null) if (element value < the value in current.element) { parent = current; current = current.left; } else if (element value > the value in current.element) { parent = current; current = current.right; } else return false; // Duplicate node not inserted // Create the new node and attach it to the parent node if (element < parent.element) parent.left = new TreeNode(elemenet); else parent.right = new TreeNode(elemenet); return true; // Element inserted } Insert 101 into the following tree. 101 < 107 true

25. 25 Trace Inserting 101 into the following tree, cont. if (root == null) root = new TreeNode(element); else { // Locate the parent node current = root; while (current != null) if (element value < the value in current.element) { parent = current; current = current.left; } else if (element value > the value in current.element) { parent = current; current = current.right; } else return false; // Duplicate node not inserted // Create the new node and attach it to the parent node if (element < parent.element) parent.left = new TreeNode(elemenet); else parent.right = new TreeNode(elemenet); return true; // Element inserted } Insert 101 into the following tree. current is null now

26. 26 Trace Inserting 101 into the following tree, cont. if (root == null) root = new TreeNode(element); else { // Locate the parent node current = root; while (current != null) if (element value < the value in current.element) { parent = current; current = current.left; } else if (element value > the value in current.element) { parent = current; current = current.right; } else return false; // Duplicate node not inserted // Create the new node and attach it to the parent node if (element < parent.element) parent.left = new TreeNode(elemenet); else parent.right = new TreeNode(elemenet); return true; // Element inserted } Insert 101 into the following tree. 101 < 107 true

27. 27 Trace Inserting 101 into the following tree, cont. if (root == null) root = new TreeNode(element); else { // Locate the parent node current = root; while (current != null) if (element value < the value in current.element) { parent = current; current = current.left; } else if (element value > the value in current.element) { parent = current; current = current.right; } else return false; // Duplicate node not inserted // Create the new node and attach it to the parent node if (element < parent.element) parent.left = new TreeNode(elemenet); else parent.right = new TreeNode(elemenet); return true; // Element inserted } Insert 101 into the following tree. 101 < 107 true

28. 28 Trace Inserting 101 into the following tree, cont. if (root == null) root = new TreeNode(element); else { // Locate the parent node current = root; while (current != null) if (element value < the value in current.element) { parent = current; current = current.left; } else if (element value > the value in current.element) { parent = current; current = current.right; } else return false; // Duplicate node not inserted // Create the new node and attach it to the parent node if (element < parent.element) parent.left = new TreeNode(elemenet); else parent.right = new TreeNode(elemenet); return true; // Element inserted } Insert 101 into the following tree. 101 < 107 true

29. 29 Inserting 59 into the Tree if (root == null) root = new TreeNode(element); else { // Locate the parent node current = root; while (current != null) if (element value < the value in current.element) { parent = current; current = current.left; } else if (element value > the value in current.element) { parent = current; current = current.right; } else return false; // Duplicate node not inserted // Create the new node and attach it to the parent node if (element < parent.element) parent.left = new TreeNode(elemenet); else parent.right = new TreeNode(elemenet); return true; // Element inserted }

30. 30 Tree Traversal F Tree traversal – –Process of visiting each node in the tree exactly once –Several ways to traverse a tree u Inorder – visit the left subtree of the current node first, then the current node itself, and finally the right subtree of the current node u Preorder –visit the left subtree of the current node first, then the right subtree of the current node, and finally the current node itself u Postorder –visit the current node first, then the left subtree of the current node, and finally the right subtree of the current node u depth-first u breadth-first traversals –visit the nodes level by level. First visit the root, then all children of the root from left to right, then grandchildren of the root from left to right, and so on

31. 31 Tree Traversal F For example, in the tree in Figure 25.2 –inorder is u 45 55 57 59 60 67 100 101 107 –postorder is u 45 59 57 55 67 101 107 100 60 –preorder is u 60 55 45 57 59 100 67 107 101 –breadth-first traversal is u 60 55 100 45 57 67 107 59 101

32. 32 Tree Interface F Tree interface –defines common operations for trees, and the AbstractTree class partially implements Tree AbstractTree Tree

33. 33 BinaryTree Class F BinaryTree with A concrete BinaryTree class can be defined to extend AbstractTree BinaryTree

34. 34 Example: Using Binary Trees Write a program that creates a binary tree using BinaryTree Add strings into the binary tree and traverse the tree in – – inorder –Postorder –preorder TestBinaryTree Run

35. 35 Tree After Insertions Inorder: Adam, Daniel George, Jones, Michael, Peter, Tom Postorder: Daniel Adam, Jones, Peter, Tom, Michael, George Preorder: George, Adam, Daniel, Michael, Jones, Tom, Peter

36. 36 Deleting Elements in a Binary Search Tree F To delete an element from a binary tree – – first locate the node that contains the element and also its parent node –Let current point to the node that contains the element in the binary tree and –parent point to the parent of the current node – current node may be a left child or a right child of the parent node –There are two cases to consider:

37. 37 Deleting Elements in a Binary Search Tree F Case 1: –The current node does not have a left child –Simply connect the parent with the right child of the current node

38. 38 Deleting Elements in a Binary Search Tree For example, to delete node 10 in Figure 25.9(a). Connect the parent of node 10 with the right child of node 10, as shown in Figure 25.9(b).

39. 39 Deleting Elements in a Binary Search Tree F Case 2: –The current node has a left child –Let rightMost point to the node that contains the largest element in the left subtree of the current node and parentOfRightMost point to the parent node of the rightMost node –Note that the rightMost node cannot have a right child, but may have a left child –Replace the element value in the current node with the one in the rightMost node, connect the parentOfRightMost node with the left child of the rightMost node, and delete the rightMost node, as shown in Figure 25.10(b).

40. 40 Deleting Elements in a Binary Search Tree Case 2 diagram

41. 41 Deleting Elements in a Binary Search Tree Case 2 example, delete 20

42. 42 Examples

43. 43 Examples

44. 44 Examples TestBinaryTreeDelete Run

45. 45 binary tree time complexity F It is obvious that the time complexity for the inorder, preorder, and postorder is O(n) F since each node is traversed only once F The time complexity for search, insertion and deletion is the height of the tree F In the worst case, the height of the tree is O(n)

46. 46 Tree Visualization BinaryTreeView Run DisplayBinaryTree

47. 47 Iterators F is an object that provides a uniform way for traversing the elements in a container such as a set, list, binary tree, etc. TestBinaryTreeWithIterator Run

48. 48 Heap F Heap is a useful data structure for designing efficient sorting algorithms and priority queues F A heap is a binary tree with the following properties: –It is a complete binary tree –Each node is greater than or equal to any of its children

49. 49 Complete Binary Tree F A binary tree is complete – –if every level of the tree is full except that the last level may not be full and all the leaves on the last level are placed left-most –binary trees in (a) and (b) are complete –binary trees in (c) and (d) are not complete –binary tree in (a) is a heap –but the binary tree in (b) is not a heap, because the root (39) is less than its right child (42) (a) (b)(c) (d)

50. 50 See How a Heap Works www.cs.armstrong.edu/liang/intro7e/exer cise/Exercise25_20.html

51. 51 Representing a Heap F For a node at position i, its left child is at position 2i+1 and its right child is at position 2i+2, and its parent is (i-1)/2 F For example, the node for element 39 is at position 4, so its left child (element 14) is at 9 (2*4+1), its right child (element 33) is at 10 (2*4+2), and its parent (element 42) is at 1 ((4-1)/2).

52. 52 Adding Elements to the Heap Adding 3, 5, 1, 19, 11, and 22 to a heap, initially empty

53. 53 Rebuild the heap after adding a new node Adding 88 to the heap

54. 54 Removing the Root and Rebuild the Tree Removing root 62 from the heap

55. 55 Removing the Root and Rebuild the Tree Move 9 to root

56. 56 Removing the Root and Rebuild the Tree Swap 9 with 59

57. 57 Removing the Root and Rebuild the Tree Swap 9 with 44

58. 58 Removing the Root and Rebuild the Tree Swap 9 with 30

59. 59 Heap Class Heap Run TestHeap

60. 60 Priority Queue A regular queue is a first-in and first-out data structure. Elements are appended to the end of the queue and are removed from the beginning of the queue. In a priority queue, elements are assigned with priorities. When accessing elements, the element with the highest priority is removed first. A priority queue has a largest-in, first-out behavior. For example, the emergency room in a hospital assigns patients with priority numbers; the patient with the highest priority is treated first. MyPriorityQueue Run TestPriorityQueue