Rock - lin

binary_search_tree/tree.py

@@ -1,59 +1,117 @@
 class TreeNode:
-    def __init__(self, key, val = None):
-        if val == None:
-            val = key
+    def __init__(self, key, value=None):
+        if value == None:
+            value = key
 
         self.key = key
-        self.value = val
+        self.value = value
         self.left = None
         self.right = None
-
 
 
 class Tree:
     def __init__(self):
         self.root = None
 
-    # Time Complexity: 
-    # Space Complexity: 
-    def add(self, key, value = None):
-        pass
+    # Time Complexity: O(log(n))*assumes all balanced tree
+    # Space Complexity: O(1)
+    def add(self, key, value=None):
+        if self.root == None:
+            self.root = TreeNode(key, value)
+        else:
+            self.add_helper(self.root, key, value)
 
-    # Time Complexity: 
-    # Space Complexity: 
-    def find(self, key):
-        pass
+    def add_helper(self, current_node, key, value):
+        if current_node == None:
+            return TreeNode(key, value)
+        if key < current_node.key:
+            current_node.left = self.add_helper(current_node.left, key, value)
+        else:
+            current_node.right = self.add_helper(current_node.right, key, value)
+        return current_node
+
+    # Time Complexity: O(log(n))
+    # Space Complexity: O(1)
+    def find(self, value):
+        return self.find_helper(self.root, value)
+
+    def find_helper(self, current, key):
+        if current == None:
+            return None
+        elif current.key == key:
+            return current.value
+        elif key < current.key:
+            return self.find_helper(current.left, key)
+        return self.find_helper(current.right, key)
 
-    # Time Complexity: 
-    # Space Complexity: 
+    # Time Complexity: O(logn)
+    # Space Complexity: O(n)
     def inorder(self):
-        pass
+        array = []
+        if self.root == None:
+            return array
+        return self.inorder_helper(self.root, array)
+
+    def inorder_helper(self, current, array):
+        if current == None:
+            return
+        self.inorder_helper(current.left, array)
+        array.append({"key": current.key, "value": current.value})
+        self.inorder_helper(current.right, array)
+        return array
 
-    # Time Complexity: 
-    # Space Complexity:     
+    # Time Complexity: O(logn)
+    # Space Complexity: O(n)
     def preorder(self):
-        pass
+        array = []
+        if self.root == None:
+            return array
+        return self.preorder_helper(self.root, array)
 
-    # Time Complexity: 
-    # Space Complexity:     
+    def preorder_helper(self, current, array):
+        if current == None:
+            return
+        array.append({"key": current.key, "value": current.value})
+        self.preorder_helper(current.left, array)
+        self.preorder_helper(current.right, array)
+        return array
+
+    # Time Complexity: O(logn)
+    # Space Complexity: O(n)
     def postorder(self):
-        pass
+        array = []
+        if self.root == None:
+            return array
+        return self.postorder_helper(self.root, array)
+
+    def postorder_helper(self, current, array):
+        if current == None:
+            return
+        self.postorder_helper(current.left, array)
+        self.postorder_helper(current.right, array)
+        array.append({"key": current.key, "value": current.value})
+        return array
 
-    # Time Complexity: 
-    # Space Complexity:     
+    # Time Complexity: O(logn)
+    # Space Complexity: O(1)
     def height(self):
-        pass
+        if self.root == None:
+            return 0
+        return self.height_helper(self.root)
 
+    def height_helper(self, current):
+        if current == None:
+            return 0
+        left = self.height_helper(current.left)
+        right = self.height_helper(current.right)
+        return max(left, right) + 1
 
-#   # Optional Method
-#   # Time Complexity: 
-#   # Space Complexity: 
+    #   # 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

@@ -145,9 +145,11 @@ def test_height_of_many_node_tree(tree_with_nodes):
     tree_with_nodes.add(2.5, "bread")
     assert tree_with_nodes.height() == 5
 
+@pytest.mark.skip    
 def test_bfs_with_empty_tree(empty_tree):
     assert empty_tree.bfs() == []
 
+@pytest.mark.skip
 def test_bfs_with_tree_with_nodes(tree_with_nodes):
     expected_answer = [
         {