1 / 29

CSE 143 Lecture 20

CSE 143 Lecture 20. Binary Search Trees read 17.3 slides created by Marty Stepp http://www.cs.washington.edu/143/. 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:

coney
Download Presentation

CSE 143 Lecture 20

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  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; }

More Related