From 59a6d528ccc79528f559c15920751b7cfa6a9b19 Mon Sep 17 00:00:00 2001 From: lolkinetzky <81205315+lolkinetzky@users.noreply.github.com> Date: Sat, 29 Jan 2022 09:55:13 -0700 Subject: [PATCH 1/4] Update tree.py --- binary_search_tree/tree.py | 146 ++++++++++++++++++++++++++++++++----- 1 file changed, 126 insertions(+), 20 deletions(-) diff --git a/binary_search_tree/tree.py b/binary_search_tree/tree.py index cdd5abc..a46d28a 100644 --- a/binary_search_tree/tree.py +++ b/binary_search_tree/tree.py @@ -7,8 +7,7 @@ def __init__(self, key, val = None): self.value = val self.left = None self.right = None - - + class Tree: def __init__(self): @@ -17,42 +16,149 @@ def __init__(self): # Time Complexity: # Space Complexity: def add(self, key, value = None): - pass + if self.root == None: + self.root = TreeNode(key, value) + else: + self._add(self.root, key, value) - # Time Complexity: + def _add(self, current_node, key, value): + if current_node == None: + return TreeNode(key, value) + + if key <= current_node.key: + current_node.left = self._add(current_node.left, key, value) + else: + current_node.right = self._add(current_node.right, key, value) + return current_node + + + # Time Complexity: # Space Complexity: def find(self, key): - pass + if self.root == None: + return None + current = self.root + while current: + if current.key == key: + return current.value + elif key > current.key: + current = current.right + else: + current = current.left + return None + # Time Complexity: # Space Complexity: def inorder(self): - pass + values =[] + + if self.root == None: + return values - # Time Complexity: - # Space Complexity: + return self.in_order(self.root, values) + + def in_order(self, node, values): + if node == None: + return + + self.in_order(node.left, values) + values.append({ + 'key': node.key, + 'value': node.value + }) + self.in_order(node.right, values) + + return values + + + # Time Complexity: + # Space Complexity: def preorder(self): - pass + values = [] - # Time Complexity: - # Space Complexity: + if self.root == None: + return values + + return self.pre_order(self.root, values) + + def pre_order(self, node, values): + if node == None: + return + + values.append({ + 'key': node.key, + 'value': node.value + }) + self.pre_order(node.left, values) + self.pre_order(node.right, values) + + return values + + + # Time Complexity: + # Space Complexity: def postorder(self): - pass + values = [] - # Time Complexity: - # Space Complexity: + if self.root == None: + return values + + return self.post_order(self.root, values) + + def post_order(self, node, values): + if node == None: + return + + self.post_order(node.left, values) + self.post_order(node.right, values) + values.append({ + 'key': node.key, + 'value': node.value + }) + + return values + + + # Time Complexity: + # Space Complexity: def height(self): - pass + if self.root == None: + return 0 + + return self._height(self.root) + + def _height(self, node): + if node == None: + return 0 + l = self._height(node.left) + r = self._height(node.right) + return (1 + max(l, r)) + + # # Optional Method -# # Time Complexity: -# # Space Complexity: +# # Time Complexity: +# # Space Complexity: def bfs(self): - pass - - + values = [] + queue = [] + if self.root: + queue.append(self.root) + while len(queue) > 0: + current_node = queue.pop(0) + if current_node.left: + queue.append(current_node.left) + if current_node.right: + queue.append(current_node.right) + + values.append({ + "key": current_node.key, + "value": current_node.value, + }) + return values # # Useful for printing def to_s(self): From 454f488f64a06471ea4956c149e9f13ace8db9b2 Mon Sep 17 00:00:00 2001 From: lolkinetzky <81205315+lolkinetzky@users.noreply.github.com> Date: Mon, 31 Jan 2022 21:20:04 -0700 Subject: [PATCH 2/4] Update README.md --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index e414413..275d3b0 100644 --- a/README.md +++ b/README.md @@ -1,6 +1,6 @@ # Tree Exercise -In this exercise you will implement, in Ruby, several Tree methods. +In this exercise you will implement, in Python, several Tree methods. - `add(value)` - This method adds a key-value pair to the Binary Search Tree - `find(value)` - This method returns the matching value for the given key if it is in the tree and `None` if the key is not found in the tree. From a24093242013f760014be7e8d3dd3ba2b0c07d44 Mon Sep 17 00:00:00 2001 From: lolkinetzky <81205315+lolkinetzky@users.noreply.github.com> Date: Mon, 31 Jan 2022 21:22:08 -0700 Subject: [PATCH 3/4] submitted --- binary_search_tree/tree.py | 59 +++++++++++++++++--------------------- 1 file changed, 27 insertions(+), 32 deletions(-) diff --git a/binary_search_tree/tree.py b/binary_search_tree/tree.py index a46d28a..64fd76c 100644 --- a/binary_search_tree/tree.py +++ b/binary_search_tree/tree.py @@ -13,8 +13,8 @@ class Tree: def __init__(self): self.root = None - # Time Complexity: - # Space Complexity: + # Time Complexity: O(n) + # Space Complexity: O(1) def add(self, key, value = None): if self.root == None: self.root = TreeNode(key, value) @@ -31,9 +31,8 @@ def _add(self, current_node, key, value): current_node.right = self._add(current_node.right, key, value) return current_node - - # Time Complexity: - # Space Complexity: + # Time Complexity: O(log n) + # Space Complexity: O(1) def find(self, key): if self.root == None: return None @@ -47,42 +46,40 @@ def find(self, key): current = current.left return None - - # Time Complexity: - # Space Complexity: + # Time Complexity: O(n) + # Space Complexity: O(n) def inorder(self): values =[] if self.root == None: return values - return self.in_order(self.root, values) + return self._in_order(self.root, values) - def in_order(self, node, values): + def _in_order(self, node, values): if node == None: return - self.in_order(node.left, values) + self._in_order(node.left, values) values.append({ 'key': node.key, 'value': node.value }) - self.in_order(node.right, values) + self._in_order(node.right, values) return values - - # Time Complexity: - # Space Complexity: + # Time Complexity: O(n) + # Space Complexity: O(n) def preorder(self): values = [] if self.root == None: return values - return self.pre_order(self.root, values) + return self._pre_order(self.root, values) - def pre_order(self, node, values): + def _pre_order(self, node, values): if node == None: return @@ -90,28 +87,27 @@ def pre_order(self, node, values): 'key': node.key, 'value': node.value }) - self.pre_order(node.left, values) - self.pre_order(node.right, values) + self._pre_order(node.left, values) + self._pre_order(node.right, values) return values - - # Time Complexity: - # Space Complexity: + # Time Complexity: O(n) + # Space Complexity: O(n) def postorder(self): values = [] if self.root == None: return values - return self.post_order(self.root, values) + return self._post_order(self.root, values) - def post_order(self, node, values): + def _post_order(self, node, values): if node == None: return - self.post_order(node.left, values) - self.post_order(node.right, values) + self._post_order(node.left, values) + self._post_order(node.right, values) values.append({ 'key': node.key, 'value': node.value @@ -119,9 +115,8 @@ def post_order(self, node, values): return values - - # Time Complexity: - # Space Complexity: + # Time Complexity: O(n) + # Space Complexity: O(log n) def height(self): if self.root == None: return 0 @@ -137,10 +132,9 @@ def _height(self, node): return (1 + max(l, r)) - # # Optional Method -# # Time Complexity: -# # Space Complexity: +# # Time Complexity: O(n) +# # Space Complexity: O(n) def bfs(self): values = [] queue = [] @@ -160,6 +154,7 @@ def bfs(self): }) return values + # # Useful for printing def to_s(self): return f"{self.inorder()}" From 5c3bd2b52b061e2e34ebd4680c39d1cd572ff92e Mon Sep 17 00:00:00 2001 From: lolkinetzky <81205315+lolkinetzky@users.noreply.github.com> Date: Fri, 4 Feb 2022 05:48:53 -0700 Subject: [PATCH 4/4] Update tree.py --- binary_search_tree/tree.py | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/binary_search_tree/tree.py b/binary_search_tree/tree.py index 64fd76c..428025e 100644 --- a/binary_search_tree/tree.py +++ b/binary_search_tree/tree.py @@ -13,8 +13,9 @@ class Tree: def __init__(self): self.root = None - # Time Complexity: O(n) - # Space Complexity: O(1) + # Time/ Space Complexity for unbalanced tree: O(n) + #Time/ Space Complexity for unbalanced tree: O(log n) + def add(self, key, value = None): if self.root == None: self.root = TreeNode(key, value) @@ -116,7 +117,7 @@ def _post_order(self, node, values): return values # Time Complexity: O(n) - # Space Complexity: O(log n) + # Space Complexity: O(log n) (balanced) or O(n) for unbalanced def height(self): if self.root == None: return 0 @@ -133,8 +134,10 @@ def _height(self, node): return (1 + max(l, r)) # # Optional Method -# # Time Complexity: O(n) +# # Time Complexity: O(n^2) # # Space Complexity: O(n) +## to-do: rewrite below using dequeue or linked list for linear time + def bfs(self): values = [] queue = []