CSE 143 Lecture 20

1. CSE 143Lecture 20 Binary Search Trees read 17.3 slides created by Marty Stepp http://www.cs.washington.edu/143/

2. Binary search trees overall root 55 29 87 -3 42 60 91 • binary search tree ("BST"): a binary tree that is either: • empty (null), or • a root node R such that: • every element of R's left subtree contains data "less than" R's data, • every element of R's right subtree contains data "greater than" R's, • R's left and right subtrees are also binary search trees. • BSTs store their elements insorted order, which is helpfulfor searching/sorting tasks.

3. Exercise 8 m 5 11 g q 2 10 18 7 b k x 7.2 4 20 e -5 1.9 9.6 18 -1 -7 8.1 21.3 • Which of the trees shown are legal binary search trees? 42

4. Searching a BST overall root 18 12 35 4 22 15 58 13 40 -2 7 16 19 31 87 • Describe an algorithm for searching the tree below for the value 31. • Then search for the value 6. • What is the maximumnumber of nodes youwould need to examineto perform any search?

5. Exercise overall root 55 29 87 -3 42 60 91 • Convert the IntTree class into a SearchTree class. • The elements of the tree will constitute a legal binary search tree. • Add a method contains to the SearchTree class that searches the tree for a given integer, returning true if found. • If a SearchTree variable tree referred to the tree below, the following calls would have these results: • tree.contains(29) true • tree.contains(55)  true • tree.contains(63)  false • tree.contains(35)  false

6. Exercise solution // Returns whether this tree contains the given integer. public boolean contains(int value) { return contains(overallRoot, value); } private boolean contains(IntTreeNode node, int value) { if (node == null) { return false; } else if (node.data == value) { return true; } else if (node.data > value) { return contains(node.left, value); } else { // root.data < value return contains(node.right, value); } }

7. Adding to a BST 8 5 11 2 10 18 7 4 20 18 • Suppose we want to add the value 14 to the BST below. • Where should the new node be added? • Where would we add the value 3? • Where would we add 7? • If the tree is empty, whereshould a new value be added? • What is the general algorithm?

8. Adding exercise 20 75 11 98 31 23 39 80 150 77 • Draw what a binary search tree would look like if the following values were added to an initially empty tree in this order: 50 20 75 98 80 31 150 39 23 11 77 50

9. Exercise overall root 55 29 87 -3 42 60 91 49 • Add a method add to the SearchTree class that adds a given integer value to the tree. Assume that the elements of the SearchTree constitute a legal binary search tree, and add the new value in the appropriate place to maintain ordering. • tree.add(49);

10. An incorrect solution overallRoot 55 29 87 -3 42 60 91 // Adds the given value to this BST in sorted order. public void add(int value) { add(overallRoot, value); } private void add(IntTreeNode node, int value) { if (node == null) { node = new IntTreeNode(value); } else if (node.data > value) { add(node.left, value); } else if (node.data < value) { add(node.right, value); } // else node.data == value, so // it's a duplicate (don't add) } • Why doesn't this solution work?

11. The x = change(x)pattern read 17.3

12. A tangent: Change a point x 3 y 25 p • What is the state of the object referred to by p after this code? public static void main(String[] args) { Point p = new Point(3, 25); change(p); System.out.println(p); } public static void change(Point thePoint) { thePoint.x = 99; thePoint.y = -1; } // answer: (99, -1)

13. Change point, version 2 x x 3 99 y y 25 -1 p • What is the state of the object referred to by p after this code? public static void main(String[] args) { Point p = new Point(3, 25); change(p); System.out.println(p); } public static void change(Point thePoint) { thePoint = new Point(99, -1); } // answer: (3, 25)

14. Changing references • If a method dereferences a variable (with . ) and modifies the object it refers to, that change will be seen by the caller. public static void change(Point thePoint) { thePoint.x = 99; // affects p thePoint.setY(-12345); // affects p • If a method reassigns a variable to refer to a new object, that change will not affect the variable passed in by the caller. public static void change(Point thePoint) { thePoint = new Point(99, -1); // p unchanged thePoint = null; // p unchanged

15. Change point, version 3 x x 3 99 y y 25 -1 p • What is the state of the object referred to by p after this code? public static void main(String[] args) { Point p = new Point(3, 25); change(p); System.out.println(p); } public static Point change(Point thePoint) { thePoint = new Point(99, -1); return thePoint; } // answer: (3, 25)

16. Change point, version 4 x x 3 99 y y 25 -1 • What is the state of the object referred to by p after this code? public static void main(String[] args) { Point p = new Point(3, 25); p = change(p); System.out.println(p); } public static Point change(Point thePoint) { thePoint = new Point(99, -1); return thePoint; } // answer: (99, -1) p

17. x = change(x); • If you want to write a method that can change the object that a variable refers to, you must do three things: 1. pass in the original state of the object to the method 2. return the new (possibly changed) object from the method 3. re-assign the caller's variable to store the returned result p = change(p); // in main public static Point change(Point thePoint) { thePoint = new Point(99, -1); return thePoint; • We call this general algorithmic pattern x = change(x);

18. x = change(x) and strings • String methods that modify a string actually return a new one. • If we want to modify a string variable, we must re-assign it. String s = "lil bow wow"; s.toUpperCase(); System.out.println(s); // lil bow wow s = s.toUpperCase(); System.out.println(s); // LIL BOW WOW • We use x = change(x) in methods that modify a binary tree. • We will pass in a node as a parameter and return a node result. • The node passed in must be re-assigned via x = change(x).

19. The problem 49 node overallRoot 55 29 87 -3 42 60 91 • Much like with linked lists, if we just modify what a local variable refers to, it won't change the collection. private void add(IntTreeNode node, int value) { if (node == null) { node = new IntTreeNode(value); } • In the linked list case, how did weactually modify the list? • by changing the front • by changing a node's next field

20. Applying x = change(x) • Methods that modify a tree should have the following pattern: • input (parameter): old state of the node • output (return): new state of the node • In order to actually change the tree, you must reassign: node = change(node, parameters); node.left = change(node.left, parameters); node.right = change(node.right, parameters); overallRoot = change(overallRoot, parameters); parameter return node before node after your method

21. A correct solution overallRoot 55 29 87 -3 42 60 91 // Adds the given value to this BST in sorted order. public void add(int value) { overallRoot =add(overallRoot, value); } private IntTreeNode add(IntTreeNode node, int value) { if (node == null) { node = new IntTreeNode(value); } else if (node.data > value) { node.left = add(node.left, value); } else if (node.data < value) { node.right = add(node.right, value); } // else a duplicate return node; } • Think about the case when node is a leaf...

22. Searching BSTs overall root overall root 19 7 14 11 4 19 overall root 9 9 6 14 7 6 14 9 6 4 7 11 19 11 4 • The BSTs below contain the same elements. • What orders are "better" for searching?

23. Trees and balance overall root 9 6 14 4 8 19 7 • balanced tree: One whose subtrees differ in height by at most 1 and are themselves balanced. • A balanced tree of N nodes has a height of ~ log2 N. • A very unbalanced tree can have a height close to N. • The runtime of adding to / searching aBST is closely related to height. • Some tree collections (e.g. TreeSet)contain code to balance themselvesas new nodes are added. height = 4 (balanced)

24. Exercise overall root 55 29 87 -3 42 60 91 • Add a method getMin to the IntTree class that returns the minimum integer value from the tree. Assume that the elements of the IntTree constitute a legal binary search tree. Throw a NoSuchElementException if the tree is empty. int min = tree.getMin(); // -3

25. Exercise solution overallRoot 55 29 87 -3 42 60 91 // Returns the minimum value from this BST. // Throws a NoSuchElementException if the tree is empty. public int getMin() { if (overallRoot == null) { throw new NoSuchElementException(); } return getMin(overallRoot); } private int getMin(IntTreeNode root) { if (root.left == null) { return root.data; } else { return getMin(root.left); } }

26. Exercise overall root 55 29 87 42 60 91 36 73 • Add a method remove to the IntTree class that removes a given integer value from the tree, if present. Assume that the elements of the IntTree constitute a legal binary search tree, and remove the value in such a way as to maintain ordering. • tree.remove(73); • tree.remove(29); • tree.remove(87); • tree.remove(55);

27. Cases for removal 1 overall root overall root overall root overall root 55 55 29 42 42 29 29 -3 42 42 1. a leaf: replace with null 2. a node with a left child only: replace with left child 3. a node with a right child only: replace with right child tree.remove(29); tree.remove(-3); tree.remove(55);

28. Cases for removal 2 overall root overall root 55 60 29 87 29 87 -3 42 60 91 -3 42 91 4. a node with both children: replace with min from right tree.remove(55);

29. Exercise solution // Removes the given value from this BST, if it exists. public void remove(int value) { overallRoot =remove(overallRoot, value); } private IntTreeNode remove(IntTreeNode root, int value) { if (root == null) { return null; } else if (root.data > value) { root.left = remove(root.left, value); } else if (root.data < value) { root.right = remove(root.right, value); } else { // root.data == value; remove this node if (root.right == null) { return root.left; // no R child; replace w/ L } else if (root.left == null) { return root.right; // no L child; replace w/ R } else { // both children; replace w/ min from R root.data = getMin(root.right); root.right = remove(root.right, root.data); } } return root; }