Add recursive search and delete methods to binary tree template

Author: neptunius

Class10.md

@@ -15,9 +15,6 @@
 - Play with VisuAlgo's [interactive binary search tree visualization][visualgo bst]
 
 ### Challenges
-- Implement recursive tree search methods on the `BinarySearchTree` class using [binary tree starter code]:
-    - `_find_node_recursive(item)` - return the node containing `item` in the tree, or `None` if not found (*hint: implement this first*)
-    - `_find_parent_node_recursive(item)` - return the parent of the node containing `item` (or the parent of where `item` would be if inserted) in the tree, or `None` if the tree is empty or has only a root node
 - Implement tree traversal methods on the `BinarySearchTree` class using [binary tree starter code]:
     - `_traverse_in_order_recursive` - traverse the tree with recursive in-order traversal (DFS)
     - `_traverse_pre_order_recursive` - traverse the tree with recursive pre-order traversal (DFS)

Class8.md

@@ -9,7 +9,7 @@
 - Read Vaidehi Joshi's [article on sets and their use in databases][BaseCS sets] with beautiful drawings and excellent examples
 
 ### Challenges
-- Implement `Set` class (backed by hash table) with the following [set operations] as instance methods and properties:
+- Implement `Set` class (abstract data type backed by data structure of your choice) with the following [set operations] as instance methods and properties:
     - `__init__(elements=None)` - initialize a new empty set structure, and add each element if a sequence is given
     - `size` - property that tracks the number of elements in constant time
     - `contains(element)` - return a boolean indicating whether `element` is in this set

Class9.md

@@ -21,16 +21,19 @@
     - `is_leaf` - check if the node is a leaf (an external node that has no children)
     - `is_branch` - check if the node is a branch (an internal node that has at least one child)
     - `height` - return the node's height (the number of edges on the longest downward path from the node to a descendant leaf node)
-- Implement `BinarySearchTree` class using `BinaryTreeNode` objects with the following properties and instance methods using [binary tree starter code]:
+- Implement `BinarySearchTree` class (using `BinaryTreeNode` objects) with the following properties and instance methods using [binary tree starter code]:
     - `root` - the tree's root node, or `None` (if the tree is empty)
     - `size` - property that tracks the number of nodes in constant time
     - `is_empty` - check if the tree is empty (has no nodes)
     - `height` - return the tree's height (the number of edges on the longest downward path from the tree's root node to a descendant leaf node)
     - `contains(item)` - return a boolean indicating whether `item` is present in the tree
     - `search(item)` - return an item in the tree matching the given `item`, or `None` if not found
     - `insert(item)` - insert the given `item` in order into the tree
-    - `_find_node(item)` - return the node containing `item` in the tree, or `None` if not found (*hint: implement this first*)
-    - `_find_parent_node(item)` - return the parent of the node containing `item` (or the parent of where `item` would be if inserted) in the tree, or `None` if the tree is empty or has only a root node
+- To simplify the `contains`, `search`, and `insert` methods with code reuse, implement iterative and recursive tree search helper methods:
+    - `_find_node_iterative(item)` - return the node containing `item` in the tree, or `None` if not found
+    - `_find_node_recursive(item)` - return the node containing `item` in the tree, or `None` if not found
+    - `_find_parent_node_iterative(item)` - return the parent of the node containing `item` (or the parent of where `item` would be if inserted) in the tree, or `None` if the tree is empty or has only a root node
+    - `_find_parent_node_recursive(item)` - return the parent of the node containing `item` (or the parent of where `item` would be if inserted) in the tree, or `None` if the tree is empty or has only a root node
 - Run `python binarytree.py` to test `BinarySearchTree` class instance methods on a small example
 - Run `pytest binarytree_test.py` to run the [binary tree unit tests] and fix any failures
 - Write additional unit tests for the `BinaryTreeNode` and `BinarySearchTree` classes
@@ -41,6 +44,8 @@
 ### Stretch Challenges
 - Implement this additional `BinarySearchTree` class instance method:
     - `delete(item)` - remove `item` from the tree, if present, or else raise `ValueError` (*hint: break this down into cases based on how many children the node containing `item` has and implement helper methods for subtasks of the more complex cases*)
+- Write additional unit tests for the `BinarySearchTree` class
+    - Include several test cases for the `delete` instance method covering each case handled by the algorithm
 - Implement binary search tree with singly linked list nodes (having only one link to another node) instead of binary tree nodes (having two links to other nodes)
 
 

source/binarytree.py

@@ -65,7 +65,7 @@ def contains(self, item):
         TODO: Best case running time: ??? under what conditions?
         TODO: Worst case running time: ??? under what conditions?"""
         # Find a node with the given item, if any
-        node = self._find_node(item)
+        node = self._find_node_recursive(item, self.root)
         # Return True if a node was found, or False
         return node is not None
 
@@ -75,7 +75,7 @@ def search(self, item):
         TODO: Best case running time: ??? under what conditions?
         TODO: Worst case running time: ??? under what conditions?"""
         # Find a node with the given item, if any
-        node = self._find_node(item)
+        node = self._find_node_recursive(item, self.root)
         # TODO: Return the node's data if found, or None
         return node.data if ... else None
 
@@ -91,7 +91,7 @@ def insert(self, item):
             self.size ...
             return
         # Find the parent node of where the given item should be inserted
-        parent = self._find_parent_node(item)
+        parent = self._find_parent_node_recursive(item, self.root)
         # TODO: Check if the given item should be inserted left of parent node
         if ...:
             # TODO: Create a new node and set the parent's left child
@@ -103,9 +103,10 @@ def insert(self, item):
         # TODO: Increase the tree size
         self.size ...
 
-    def _find_node(self, item):
+    def _find_node_iterative(self, item):
         """Return the node containing the given item in this binary search tree,
-        or None if the given item is not found.
+        or None if the given item is not found. Search is performed iteratively
+        starting from the root node.
         TODO: Best case running time: ??? under what conditions?
         TODO: Worst case running time: ??? under what conditions?"""
         # Start with the root node
@@ -127,10 +128,34 @@ def _find_node(self, item):
         # Not found
         return None
 
-    def _find_parent_node(self, item):
+    def _find_node_recursive(self, item, node):
+        """Return the node containing the given item in this binary search tree,
+        or None if the given item is not found. Search is performed recursively
+        starting from the given node (give the root node to start recursion).
+        TODO: Best case running time: ??? under what conditions?
+        TODO: Worst case running time: ??? under what conditions?"""
+        # Check if starting node exists
+        if node is None:
+            # Not found (base case)
+            return None
+        # TODO: Check if the given item matches the node's data
+        elif ...:
+            # Return the found node
+            return node
+        # TODO: Check if the given item is less than the node's data
+        elif ...:
+            # TODO: Recursively descend to the node's left child, if it exists
+            return ...
+        # TODO: Check if the given item is greater than the node's data
+        elif ...:
+            # TODO: Recursively descend to the node's right child, if it exists
+            return ...
+
+    def _find_parent_node_iterative(self, item):
         """Return the parent node of the node containing the given item
         (or the parent node of where the given item would be if inserted)
         in this tree, or None if this tree is empty or has only a root node.
+        Search is performed iteratively starting from the root node.
         TODO: Best case running time: ??? under what conditions?
         TODO: Worst case running time: ??? under what conditions?"""
         # Start with the root node and keep track of its parent
@@ -145,17 +170,46 @@ def _find_parent_node(self, item):
             # TODO: Check if the given item is less than the node's data
             elif ...:
                 # TODO: Update the parent and descend to the node's left child
-                parent = node
+                parent = ...
                 node = ...
             # TODO: Check if the given item is greater than the node's data
             elif ...:
                 # TODO: Update the parent and descend to the node's right child
-                parent = node
+                parent = ...
                 node = ...
         # Not found
         return parent
 
-    # This space intentionally left blank (please do not delete this comment)
+    def _find_parent_node_recursive(self, item, node, parent=None):
+        """Return the parent node of the node containing the given item
+        (or the parent node of where the given item would be if inserted)
+        in this tree, or None if this tree is empty or has only a root node.
+        Search is performed recursively starting from the given node
+        (give the root node to start recursion)."""
+        # Check if starting node exists
+        if node is None:
+            # Not found (base case)
+            return None
+        # TODO: Check if the given item matches the node's data
+        if ...:
+            # Return the parent of the found node
+            return parent
+        # TODO: Check if the given item is less than the node's data
+        elif ...:
+            # TODO: Recursively descend to the node's left child, if it exists
+            return ...  # Hint: Remember to update the parent parameter
+        # TODO: Check if the given item is greater than the node's data
+        elif ...:
+            # TODO: Recursively descend to the node's right child, if it exists
+            return ...  # Hint: Remember to update the parent parameter
+
+    def delete(self, item):
+        """Remove given item from this tree, if present, or raise ValueError.
+        TODO: Best case running time: ??? under what conditions?
+        TODO: Worst case running time: ??? under what conditions?"""
+        # TODO: Use helper methods and break this algorithm down into 3 cases
+        # based on how many children the node containing the given item has and
+        # implement new helper methods for subtasks of the more complex cases
 
     def items_in_order(self):
         """Return an in-order list of all items in this binary search tree."""

source/binarytree_test.py

@@ -47,6 +47,26 @@ def test_is_branch(self):
         node.right = None
         assert node.is_branch() is False
 
+    def test_height(self):
+        # Create node with no children
+        node = BinaryTreeNode(4)
+        assert node.height() == 0
+        # Attach left child node
+        node.left = BinaryTreeNode(2)
+        assert node.height() == 1
+        # Attach right child node
+        node.right = BinaryTreeNode(6)
+        assert node.height() == 1
+        # Attach left-left grandchild node
+        node.left.left = BinaryTreeNode(1)
+        assert node.height() == 2
+        # Attach right-right grandchild node
+        node.right.right = BinaryTreeNode(8)
+        assert node.height() == 2
+        # Attach right-right-left great-grandchild node
+        node.right.right.left = BinaryTreeNode(7)
+        assert node.height() == 3
+
 
 class BinarySearchTreeTest(unittest.TestCase):
 
@@ -154,7 +174,50 @@ def test_insert_with_7_items(self):
         assert tree.root.right.left.data == 5
         assert tree.root.right.right.data == 7
 
-    # This space intentionally left blank (please do not delete this comment)
+    def DISABLED_test_delete_with_3_items(self):
+        # Create a complete binary search tree of 3 items in level-order
+        items = [2, 1, 3]
+        tree = BinarySearchTree(items)
+        assert tree.root.data == 2
+        assert tree.root.left.data == 1
+        assert tree.root.right.data == 3
+        # TODO: Test structure of tree after each deletion
+        # tree.delete(2)
+        # assert tree.root.data == ...
+        # assert tree.root.left is ...
+        # assert tree.root.right is ...
+        # tree.delete(1)
+        # assert tree.root.data == ...
+        # assert tree.root.left is ...
+        # assert tree.root.right is ...
+        # tree.delete(3)
+        # assert tree.root.data is ...
+        # assert tree.root.left is ...
+        # assert tree.root.right is ...
+
+    def DISABLED_test_delete_with_7_items(self):
+        # Create a complete binary search tree of 7 items in level-order
+        items = [4, 2, 6, 1, 3, 5, 7]
+        tree = BinarySearchTree(items)
+        # TODO: Test structure of tree after each deletion
+        # tree.delete(4)
+        # assert tree.root.data == ...
+        # assert tree.root.left.data == ...
+        # assert tree.root.right.data == ...
+        # assert ...
+        # assert ...
+        # tree.delete(...)
+        # assert tree.root.data == ...
+        # assert tree.root.left.data == ...
+        # assert tree.root.right.data == ...
+        # assert ...
+        # assert ...
+        # tree.delete(...)
+        # assert tree.root.data == ...
+        # assert tree.root.left.data == ...
+        # assert tree.root.right.data == ...
+        # assert ...
+        # assert ...
 
     def test_items_in_order_with_3_strings(self):
         # Create a complete binary search tree of 3 strings in level-order