Abigail C - Rock

binary_search_tree/tree.py

@@ -17,41 +17,129 @@ def __init__(self):
     # Time Complexity: 
     # Space Complexity: 
     def add(self, key, value = None):
-        pass
+        if self.root == None:
+            self.root = TreeNode(key,value)
+        current = self.root
+
+        while True:
+            if self.root.key == key:
+                break
+            elif current.key > key:
+                if current.left != None:
+                    current = current.left
+                else:
+                    current.left = TreeNode(key,value)
+                    break
+            elif current.key < key:
+                if current.right != None:
+                    current = current.right
+                else:
+                    current.right = TreeNode(key,value)
+                    break
+        # return self.root
+        # if current ==
+
 
     # Time Complexity: 
     # Space Complexity: 
     def find(self, key):
-        pass
+        current = self.root
+        while current != None:
+            if current.key == key:
+                return current.value
+            elif key < current.key:
+                current = current.left
+            else:
+                current = current.right
+        return None
 
     # Time Complexity: 
     # Space Complexity: 
     def inorder(self):
-        pass
+        def helper(node):
+            if node == None:
+                return []
+            left_part= helper(node.left) 
+            middle_part = [{"key":node.key,"value":node.value}]
+            right_part = helper(node.right)
+            result = left_part + middle_part + right_part
+            return result
 
+        return helper(self.root)
+
+
+
     # Time Complexity: 
     # Space Complexity:     
     def preorder(self):
-        pass
+        def helper( node):
+            if node == None:
+                return []
+            left_part= helper(node.left) 
+            middle_part = [{"key":node.key,"value":node.value}]
+            right_part = helper(node.right)
+            result = middle_part + left_part +  right_part
+            return result
+
+        return helper(self.root)
 
     # Time Complexity: 
     # Space Complexity:     
     def postorder(self):
-        pass
+        def helper( node):
+            if node == None:
+                return []
+            left_part= helper(node.left) 
+            middle_part = [{"key":node.key,"value":node.value}]
+            right_part = helper(node.right)
+            result = left_part +  right_part + middle_part 
+            return result
+
+        return helper(self.root)
 
     # Time Complexity: 
     # Space Complexity:     
     def height(self):
-        pass
+        def helper(node):
+            if node == None:
+                return 0
+            left_part= helper(node.left)
+            right_part = helper(node.right)
+            result = max(left_part, right_part) + 1
+            return result
+        return helper(self.root)
 
 
 #   # Optional Method
 #   # Time Complexity: 
 #   # Space Complexity: 
     def bfs(self):
-        pass
+        if self.root == None:
+            return []
 
-
+        queue = []
+        leveled_order = [{ 
+                    "key" : self.root.key, 
+                    "value":self.root.value
+                    }]
+
+        queue.append(self.root)
+        while queue != []:
+            temp = queue.pop(0)
+            if temp.left:
+                queue.append(temp.left)
+                leveled_order.append({ 
+                    "key" : temp.left.key, 
+                    "value": temp.left.value
+                    })
+            if temp.right:
+                queue.append(temp.right)
+                leveled_order.append({ 
+                    "key" : temp.right.key, 
+                    "value": temp.right.value
+                    })
+
+        return leveled_order
 
 
 #   # Useful for printing