Rock - Priscille

binary_search_tree/tree.py

@@ -7,53 +7,116 @@ def __init__(self, key, val = None):
         self.value = val
         self.left = None
         self.right = None
+
+    def dict(self):
+        return {"key": self.key, "value": self.value}
 
 
 
 class Tree:
     def __init__(self):
         self.root = None
 
-    # Time Complexity: 
-    # Space Complexity: 
+    # Time Complexity: O(n)
+    # Space Complexity: O(1)
     def add(self, key, value = None):
-        pass
+        tree = TreeNode(key, value)
+
+        if self.root == None:
+            self.root = tree
+        else:
+            current = self.root
+
+            while current != None:
+                if key == current.key:
+                    return None
+                if key < current.key:
+                    if current.left == None:
+                        current.left = tree
+                    current = current.left
+                elif key > current.key:
+                    if current.right == None:
+                        current.right = tree
+                    current = current.right
 
-    # Time Complexity: 
-    # Space Complexity: 
+    # Time Complexity: O(n)
+    # Space Complexity: O(1)
     def find(self, key):
-        pass
+        if self.root == None:
+            return None
+        current = self.root
+        while current != None:
+            if key == current.key:
+                return current.value
+            elif key > current.key:
+                current = current.right
+            else:
+                current = current.left 
+        return None
+
+    def inorder_helper(self, current, traversal_list):
+        if current == None:
+            return
+
+        self.inorder_helper(current.left, traversal_list)
+        traversal_list.append(current.dict())
+        self.inorder_helper(current.right, traversal_list)
 
-    # Time Complexity: 
-    # Space Complexity: 
+    # Time Complexity: O(n)
+    # Space Complexity: O(1)
     def inorder(self):
-        pass
+        traversal_list = []
+        self.inorder_helper(self.root, traversal_list)
+        return traversal_list   
+
+    def preorder_helper(self, current, traversal_list):
+        if current == None:
+            return
 
-    # Time Complexity: 
-    # Space Complexity:     
+        traversal_list.append(current.dict())
+        self.preorder_helper(current.left, traversal_list)
+        self.preorder_helper(current.right, traversal_list)
+
+    # Time Complexity: O(n)
+    # Space Complexity: O(1)    
     def preorder(self):
-        pass
+        traversal_list = []
+        self.preorder_helper(self.root, traversal_list)
+        return traversal_list
 
-    # Time Complexity: 
-    # Space Complexity:     
+    def postorder_helper(self, current, traversal_list):
+        if current == None:
+            return
+
+        self.postorder_helper(current.left, traversal_list)
+        self.postorder_helper(current.right, traversal_list)
+        traversal_list.append(current.dict())
+
+    # Time Complexity: O(n)
+    # Space Complexity: O(1)
     def postorder(self):
-        pass
+        traversal_list = []
+        self.postorder_helper(self.root, traversal_list)
+        return traversal_list
 
-    # Time Complexity: 
-    # Space Complexity:     
+    def height_helper(self, current):
+        if current == None:
+            return 0
+        left_height = self.height_helper(current.left)
+        right_height = self.height_helper(current.right)
+        return 1 +max(left_height, right_height)
+
+    # Time Complexity: O(n)
+    # Space Complexity: O(1)
     def height(self):
-        pass
+        return self.height_helper(self.root)
 
 
 #   # Optional Method
 #   # Time Complexity: 
 #   # Space Complexity: 
     def bfs(self):
         pass
-
-
-
-
-#   # Useful for printing
+#  Useful for printing
     def to_s(self):
         return f"{self.inorder()}"

tests/test_binary_search_tree.py

@@ -144,10 +144,11 @@ def test_height_of_many_node_tree(tree_with_nodes):
     tree_with_nodes.add(2, "pasta")
     tree_with_nodes.add(2.5, "bread")
     assert tree_with_nodes.height() == 5
-
+
+@pytest.mark.skip(reason="optional")    
 def test_bfs_with_empty_tree(empty_tree):
     assert empty_tree.bfs() == []
-
+@pytest.mark.skip(reason="optional")  
 def test_bfs_with_tree_with_nodes(tree_with_nodes):
     expected_answer = [
         {