Binary Search Trees Nilanjan Banerjee Goal of todays

Binary Search Trees Nilanjan Banerjee

Goal of today’s lecture Learn about Binary Search Trees Discuss the first midterm 2

Binary search trees binary search tree ("BST"): a binary tree where each non -empty node R has the following properties: elements of R's left subtree contain data "less than" R's data, elements of R's right subtree contain data "greater than" R's, R's left and right subtrees are also binary search trees. overall root BSTs store their elements in sorted order, which is helpful for searching/sorting tasks. 55 29 -3 87 42 60 91 3

BST examples Which of the trees shown are legal binary search trees? -5 m g b q k e -1 x 42 5 -7 2 7. 2 1. 9 11 7 10 18 4 9. 6 8. 1 8 21. 3 20 18 4

Searching a BST Describe an algorithm for searching a binary search tree. Try searching for the value 31, then 6. What is the maximum number of nodes you would need to examine to perform any search? What is the computational Complexity of searching? overall root 18 12 35 4 -2 22 15 7 13 16 19 31 58 40 87 5

Exercise Write a contains method that takes advantage of the BST structure. tree. contains(29) tree. contains(55) tree. contains(63) tree. contains(35) true false overall root 55 29 -3 87 42 60 91 6

Exercise solution // Returns whether this BST contains the given integer. public boolean contains(int value) { return contains(overall. Root, value); } private boolean contains(Int. Tree. Node node, int value) { if (node == null) { return false; // base case: not found here } else if (node. data == value) { return true; // base case: found here } else if (node. data > value) { return contains(node. left, value); } else { // root. data < value return contains(node. right, value); } } 7

Adding to a BST Suppose we want to add new values to the BST below. Where should the value 14 be added? Where should 3 be added? 7? overall root 8 If the tree is empty, where should a new value be added? 5 What is the general algorithm? 2 11 7 10 19 4 25 22 8

Adding exercise 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 20 11 75 98 31 23 39 80 150 77 9

Exercise Add a method add to the Search. Tree class that adds a given integer value to the BST. Add the new value in the proper place to maintain BST ordering. overall root tree. add(49); 55 29 -3 87 42 60 91 49 10

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

The x = change(x) pattern

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

Change point, version 2 What is the state of the object referred to by p after this code? public static void main(String[] args) { Point p = new Point(1, 2); p x change(p); System. out. println(p); } 1 y 2 public static void change(Point the. Point) { the. Point = new Point(3, 4); } x 3 y 4 // answer: (1, 2) 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 the. Point) { the. Point. x = 3; // affects p the. Point. set. Y(4); // 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 the. Point) { the. Point = new Point(3, 4); // p unchanged the. Point = null; // p unchanged What if we want to make the variable passed in become null? 15

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

Change point, version 4 What is the state of the object referred to by p after this code? public static void main(String[] args) { Point p = new Point(1, 2); p x p = change(p); System. out. println(p); } 1 y 2 public static Point change(Point the. Point) { the. Point = new Point(3, 4); return the. Point; } x 3 y 4 // answer: (3, 4) 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. 2. 3. pass in the original state of the object to the method return the new (possibly changed) object from the method re-assign the caller's variable to store the returned result p = change(p); // in main public static Point change(Point the. Point) { the. Point = new Point(99, -1); return the. Point; 18

The problem Much like with linked lists, if we just modify what a local variable refers to, it won't change the collection. node 49 private void add(Int. Tree. Node node, int value) { if (node == null) { overall. Root node = new Int. Tree. Node(value); } 55 29 -3 87 42 60 91 19

A correct solution // Adds the given value to this BST in sorted order. public void add(int value) { overall. Root = add(overall. Root, value); } private Int. Tree. Node add(Int. Tree. Node node, int value) { if (node == null) { node = new Int. Tree. Node(value); } else if (node. data > value) { overall. Root node. left = add(node. left, value); } else if (node. data < value) { 55 node. right = add(node. right, value); } // else a duplicate; do nothing 29 87 } return node; -3 42 60 91 What happens when node is a leaf? 20

Deletion There are the following possible cases when we delete a node: The node to be deleted has no children. In this case, all we need to do is delete the node. The node to be deleted has only a right subtree. We delete the node and attach the right subtree to the deleted node’s parent. The node to be deleted has only a left subtree. We delete the node and attach the left subtree to the deleted node’s parent. The node to be deleted has two subtrees. It is possible to delete a node from the middle of a tree, but the result tends to create very unbalanced trees. 21 21

Deletion from the middle of a tree Rather than simply delete the node, we try to maintain the existing structure as much as possible by finding data to take the place of the deleted data. This can be done in one of two ways. 22 22

Deletion from the middle of a tree We can find the largest node in the deleted node’s left subtree and move its data to replace the deleted node’s data. We can find the smallest node on the deleted node’s right subtree and move its data to replace the deleted node’s data. Either of these moves preserves the integrity of the binary search tree. 23 23

24 24

(continued) 25 25

27 27 26 26

Performance of BST methods What is the asymptotic performance of each of the BST methods? Best Case Worst Case Average Case searching insert remove 27 27

Exam Review Topic 1: Java Review Generics in Java, Type Erasure, Virtual Fuction invocation caused by Inheritance Asymptotic Analysis Big Oh notation --- you should be able to look at an implementation and figure it running time in Big Oh L’Hospital Rule Linked List Understand the difference between using an Array. List and a Linked. List Running time of a Linked. List insertion, deletion, searching an element One problem where you will have to manipulate a linked list Stack and Queues and Adapter Classes 28 28

Exam Trees Definition of a tree One algorithmic question with trees How to traverse a tree Recursive implementation as well as the non-recursive implementation Inorder, Preorder, Postorder, Level. Order 29 29