Cedar - Lux Barker

binary_search_tree/tree.py

@@ -1,3 +1,4 @@
+from collections import deque
 class TreeNode:
     def __init__(self, key, val = None):
         if val == None:
@@ -7,7 +8,7 @@ def __init__(self, key, val = None):
         self.value = val
         self.left = None
         self.right = None
-        
+
 
 
 class Tree:
@@ -17,41 +18,103 @@ def __init__(self):
     # Time Complexity: 
     # Space Complexity: 
     def add(self, key, value = None):
-        pass
+        new_node = TreeNode(key, value)
+        if self.root is None:
+            self.root = new_node
+            return self.root
+        return self.add_helper(self.root, new_node)
+
+    def add_helper(self, curr, new_node):
+        if curr is None:
+            curr = new_node
+        elif new_node.key < curr.key:
+            curr.left = self.add_helper(curr.left, new_node)
+        else:
+            curr.right = self.add_helper(curr.right, new_node)
+        return curr
 
     # Time Complexity: 
     # Space Complexity: 
     def find(self, key):
-        pass
+        return self.find_helper(self.root, key)
+
+    def find_helper(self, curr, key):
+        if curr is None:
+            return None
+        if curr.key == key:
+            return curr.value
+        if key < curr.key:
+            return self.find_helper(curr.left, key)
+        return self.find_helper(curr.right, key)
 
     # Time Complexity: 
     # Space Complexity: 
     def inorder(self):
-        pass
+        arr = []
+        self.inorder_helper(self.root, arr)
+        return arr
 
-    # Time Complexity: 
+    def inorder_helper(self, curr, arr):
+        if curr is not None:
+            self.inorder_helper(curr.left, arr)
+            arr.append({"key": curr.key, "value": curr.value})
+            self.inorder_helper(curr.right, arr)
+
+    # Time Complexity:
     # Space Complexity:     
     def preorder(self):
-        pass
+        arr = []
+        self.preorder_helper(self.root, arr)
+        return arr
 
-    # Time Complexity: 
+    def preorder_helper(self, curr, arr):
+        if curr is not None:
+            arr.append({"key": curr.key, "value": curr.value})
+            self.preorder_helper(curr.left, arr)
+            self.preorder_helper(curr.right, arr)
+    # Time Complexity:
     # Space Complexity:     
     def postorder(self):
-        pass
+        arr = []
+        self.postorder_helper(self.root, arr)
+        return arr
+
+    def postorder_helper(self, curr, arr):
+        if curr is not None:
+            self.postorder_helper(curr.left, arr)
+            self.postorder_helper(curr.right, arr)
+            arr.append({"key": curr.key, "value": curr.value})
 
     # Time Complexity: 
     # Space Complexity:     
     def height(self):
-        pass
+        return self.height_helper(self.root, 0)
 
+    def height_helper(self, curr, count):
+        if curr is None:
+            return count
+        left_height = self.height_helper(curr.left, count + 1)
+        right_height = self.height_helper(curr.right, count + 1)
+        return max(left_height, right_height)
 
-#   # Optional Method
-#   # Time Complexity: 
-#   # Space Complexity: 
+    # Optional Method
+    # Time Complexity:
+    # Space Complexity:
     def bfs(self):
-        pass
+        visited = []
+        if self.root is None:
+            return visited
+        q = deque()
+        q.append(self.root)
+        while q:
+            curr = q.popleft()
+            visited.append({"key": curr.key, "value": curr.value})
+            if curr.left is not None:
+                q.append(curr.left)
+            if curr.right is not None:
+                q.append(curr.right)
+        return visited
 
-
 
 
 #   # Useful for printing