From 81aae42118439713b4a629040f0896380bf60cd1 Mon Sep 17 00:00:00 2001
From: Shaina Beth <shainabeth94@gmail.com>
Date: Sat, 16 Jul 2022 21:29:48 -0700
Subject: [PATCH 1/2] implement methods

---
 binary_search_tree/tree.py | 146 ++++++++++++++++++++++++++++++++-----
 1 file changed, 129 insertions(+), 17 deletions(-)

diff --git a/binary_search_tree/tree.py b/binary_search_tree/tree.py
index cdd5abc..4d2baad 100644
--- a/binary_search_tree/tree.py
+++ b/binary_search_tree/tree.py
@@ -14,42 +14,154 @@ class Tree:
     def __init__(self):
         self.root = None
 
-    # Time Complexity: 
-    # Space Complexity: 
+    # Time Complexity: O(log n)
+    # Space Complexity: O(1)
     def add(self, key, value = None):
-        pass
+        cur = self.root
+        if cur == None:
+            self.root = TreeNode(key, value)
+            return
+        while True:
+            if key < cur.key:
+                if cur.left == None:
+                    cur.left = TreeNode(key, value)
+                    return
+                else:
+                    cur = cur.left
+            else:
+                if cur.right == None:
+                    cur.right = TreeNode(key, value)
+                    return
+                else:
+                    cur = cur.right
+            
 
-    # Time Complexity: 
-    # Space Complexity: 
+
+    # Time Complexity: O(log n)
+    # Space Complexity: O(1)
     def find(self, key):
-        pass
+        cur = self.root
+        if cur == None:
+            return None
+        while cur != None and cur.key != key:
+            if key < cur.key:
+                cur = cur.left
+            else:
+                cur = cur.right
+        if cur == None:
+            return None
+        return cur.value
 
-    # Time Complexity: 
-    # Space Complexity: 
+    # Time Complexity: O(n)
+    # Space Complexity: O(n)
     def inorder(self):
-        pass
+        result = []
+        def inorder_helper(node):
+            if node == None:
+                return
+            if node.left != None:
+                inorder_helper(node.left)
+            result.append({
+                "key": node.key,
+                "value": node.value
+            })
+            if node.right != None:
+                inorder_helper(node.right)
+        inorder_helper(self.root)
+        return result
+                
 
-    # Time Complexity: 
-    # Space Complexity:     
+        
+
+        
+
+    # Time Complexity: O(n)
+    # Space Complexity:  O(n)  
     def preorder(self):
-        pass
+        result = []
+        def preorder_helper(node):
+            if node == None:
+                return
+            result.append({
+                "key": node.key,
+                "value": node.value
+            })
+            if node.left != None:
+                preorder_helper(node.left)
+            if node.right != None:
+                preorder_helper(node.right)
+        preorder_helper(self.root)
+        return result
 
     # Time Complexity: 
     # Space Complexity:     
     def postorder(self):
-        pass
-
+        result = []
+        def postorder_helper(node):
+            if node == None:
+                return
+            if node.left != None:
+                postorder_helper(node.left)
+            if node.right != None:
+                postorder_helper(node.right)
+            result.append({
+                "key": node.key,
+                "value": node.value
+            })
+        postorder_helper(self.root)
+        return result
+    
     # Time Complexity: 
     # Space Complexity:     
     def height(self):
-        pass
-
+        if self.root == None:
+            return 0
+        def height_helper(node, height):
+            if node == None:
+                return
+            left_best = -1
+            right_best = -1
+            if node.left != None:
+                left_best = height_helper(node.left, height + 1)
+            if node.right != None:
+                right_best = height_helper(node.right, height + 1)
+            return max([left_best, right_best, height])
+        return height_helper(self.root, 1)
 
 #   # Optional Method
 #   # Time Complexity: 
 #   # Space Complexity: 
     def bfs(self):
-        pass
+        cur = self.root
+        if cur == None:
+            return []
+        
+        res = [{
+            "key": self.root.key,
+            "value": self.root.value
+        }]
+        parents = [self.root]
+
+        while len(parents) > 0:
+            new_parents = []
+            for parent in parents:
+                if parent.left != None:
+                    res.append({
+                        "key": parent.left.key,
+                        "value": parent.left.value
+                    })
+                    new_parents.append(parent.left)
+                if parent.right != None:
+                    res.append({
+                        "key": parent.right.key,
+                        "value": parent.right.value
+
+                    })
+                    new_parents.append(parent.right)
+            parents = new_parents
+        return res
+
+        
 
         
 

From 443696e3b3fe9dcaa90a77e00d7cfa0beaeaa8d0 Mon Sep 17 00:00:00 2001
From: Shaina Beth <shainabeth94@gmail.com>
Date: Sat, 16 Jul 2022 21:30:27 -0700
Subject: [PATCH 2/2] fill in missing complexities

---
 binary_search_tree/tree.py | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/binary_search_tree/tree.py b/binary_search_tree/tree.py
index 4d2baad..0db20e4 100644
--- a/binary_search_tree/tree.py
+++ b/binary_search_tree/tree.py
@@ -93,8 +93,8 @@ def preorder_helper(node):
         preorder_helper(self.root)
         return result
 
-    # Time Complexity: 
-    # Space Complexity:     
+    # Time Complexity:  O(n)
+    # Space Complexity:  O(n)
     def postorder(self):
         result = []
         def postorder_helper(node):
@@ -111,8 +111,8 @@ def postorder_helper(node):
         postorder_helper(self.root)
         return result
     
-    # Time Complexity: 
-    # Space Complexity:     
+    # Time Complexity: O(n)
+    # Space Complexity:   O(1)
     def height(self):
         if self.root == None:
             return 0
@@ -129,8 +129,8 @@ def height_helper(node, height):
         return height_helper(self.root, 1)
 
 #   # Optional Method
-#   # Time Complexity: 
-#   # Space Complexity: 
+#   # Time Complexity: O(n)
+#   # Space Complexity: O(n)
     def bfs(self):
         cur = self.root
         if cur == None: