From b5c4dade0f7c14509892ca1c025bd806d293fcaf Mon Sep 17 00:00:00 2001
From: saebaebae <73720393+saebaebae@users.noreply.github.com>
Date: Thu, 23 Dec 2021 11:59:09 -0800
Subject: [PATCH] binary search tree solutions

---
 binary_search_tree/tree.py                | 149 ++++++++++++++++++----
 tests/__pycache__/__init__.cpython-39.pyc | Bin 152 -> 0 bytes
 2 files changed, 126 insertions(+), 23 deletions(-)
 delete mode 100644 tests/__pycache__/__init__.cpython-39.pyc

diff --git a/binary_search_tree/tree.py b/binary_search_tree/tree.py
index cdd5abc..c74ebd8 100644
--- a/binary_search_tree/tree.py
+++ b/binary_search_tree/tree.py
@@ -8,48 +8,151 @@ def __init__(self, key, val = None):
         self.left = None
         self.right = None
         
-
-
 class Tree:
     def __init__(self):
         self.root = None
 
-    # Time Complexity: 
-    # Space Complexity: 
+    # Time Complexity: On
+    # Space Complexity: O1
     def add(self, key, value = None):
-        pass
+        if self.root == None:
+            self.root = TreeNode(key, value)
+        else:
+            self.add_helper(self.root, key, value)
+
+    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: 
-    # Space Complexity: 
+    # Time Complexity: On
+    # Space Complexity: O1
     def find(self, key):
-        pass
+        if self.root == None:
+            return None
+        else:
+            return self.find_helper(self.root, key)
+
+    def find_helper(self, curr, key):
+        if not curr:
+            return None
+        elif curr.key == key:
+            return curr.value 
+        elif key < curr.key:
+            return self.find_helper(curr.left, key)
+        elif key > curr.key:
+            return self.find_helper(curr.right, key)
 
-    # Time Complexity: 
-    # Space Complexity: 
+    # Time Complexity: On
+    # Space Complexity: On
     def inorder(self):
-        pass
+        all_ele = []
+        return self.inorder_helper(self.root, all_ele)
+
+    def inorder_helper(self, curr, all_ele):
+        if not curr:
+            return all_ele
+        self.inorder_helper(curr.left, all_ele)
+        all_ele.append({
+            "key": curr.key,
+            "value": curr.value})
+        self.inorder_helper(curr.right, all_ele)
 
-    # Time Complexity: 
-    # Space Complexity:     
+        return all_ele
+
+    # Time Complexity: On
+    # Space Complexity: On    
     def preorder(self):
-        pass
+        all_ele = []
+        return self.preorder_helper(self.root, all_ele)
+        
+    def preorder_helper(self, curr, all_ele):
+        if not curr:
+            return all_ele
+
+        all_ele.append({
+            "key": curr.key,
+            "value": curr.value
+        })
+        self.preorder_helper(curr.left, all_ele)
+        self.preorder_helper(curr.right, all_ele)
+    
+        return all_ele
 
-    # Time Complexity: 
-    # Space Complexity:     
+    # Time Complexity: On
+    # Space Complexity: On    
     def postorder(self):
-        pass
+        all_ele = []
+        return self.postorder_helper(self.root, all_ele)
+    
+    def postorder_helper(self, curr, all_ele):
+        if not curr:
+            return all_ele
+
+        self.postorder_helper(curr.left, all_ele)
+        self.postorder_helper(curr.right, all_ele)
+
+        all_ele.append({
+            "key": curr.key,
+            "value": curr.value
+        })
 
-    # Time Complexity: 
-    # Space Complexity:     
+        return all_ele
+
+    # # Time Complexity: On
+    # # Space Complexity: O1    
     def height(self):
-        pass
+        return self.height_helper(self.root)
+
+    def height_helper(self, curr):
+        if not curr:
+            return 0
+
+        left_height = self.height_helper(curr.left)
+        right_height = self.height_helper(curr.right)
 
+        return max(left_height, right_height) +1
 
 #   # Optional Method
-#   # Time Complexity: 
-#   # Space Complexity: 
+#   # Time Complexity: On
+#   # Space Complexity: On
     def bfs(self):
-        pass
+
+        arr = []
+
+        if not self.root:
+            return arr
+
+        root = {
+            "key": self.root.key,
+            "value": self.root.value}
+
+        temp = [self.root]
+        arr.append(root)
+
+        while len(temp) > 0:
+            curr = temp[0]
+        
+            if curr.left:
+                temp.append(curr.left)
+                arr.append({
+                    "key": curr.left.key,
+                    "value": curr.left.value})
+            
+            if curr.right:
+                temp.append(curr.right)
+                arr.append({
+                    "key": curr.right.key,
+                    "value": curr.right.value})
+
+            temp.remove(curr)
+        
+        return arr
 
         
 
diff --git a/tests/__pycache__/__init__.cpython-39.pyc b/tests/__pycache__/__init__.cpython-39.pyc
deleted file mode 100644
index aa55c2ed2909da5566d50f92972b26b188bfaed0..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 152
zcmYe~<>g`kg1}aeL=gQLL?8o3AjbiSi&=m~3PUi1CZpd<h9ZzKg7{^tA6lGRRIHzz
zQIuJno1B=Jn3GefpO})UUy_<zpkGpynyOn+l$czSnVbp~DlRG3kB`sH%PfhH*DI*J
U#bJ}1pHiBWY6mj*GY~TX04vEO;Q#;t