From 1e906dabb74963dae970c9a08ff8753641a22f4f Mon Sep 17 00:00:00 2001 From: Laurel S Date: Fri, 27 May 2022 00:22:08 -0700 Subject: [PATCH 1/4] Adds find() and add() methods for bst --- binary_search_tree/tree.py | 32 ++++++++++++++++++++++++++++++-- 1 file changed, 30 insertions(+), 2 deletions(-) diff --git a/binary_search_tree/tree.py b/binary_search_tree/tree.py index cdd5abc..e30fc5b 100644 --- a/binary_search_tree/tree.py +++ b/binary_search_tree/tree.py @@ -17,12 +17,40 @@ def __init__(self): # Time Complexity: # Space Complexity: def add(self, key, value = None): - pass + node = TreeNode(key, value) + if not self.root: + self.root = node + return self.root + + current = self.root + previous = None + while current: + previous = current + if key <= current.key: + current = current.left + else: + current = current.right + if key <= previous.key: + previous.left = node + else: + previous.right = node # Time Complexity: # Space Complexity: def find(self, key): - pass + if not self.root: + return None + if self.root.key == key: + return self.root.value + current = self.root + while current: + if current.key == key: + return current.value + if key <= current.key: + current = current.left + else: + current = current.right + return None # Time Complexity: # Space Complexity: From 84200816e9a09e6b702c0c9b71a7cd5b41da122b Mon Sep 17 00:00:00 2001 From: Laurel S Date: Fri, 27 May 2022 00:29:35 -0700 Subject: [PATCH 2/4] Adds BFS method --- binary_search_tree/tree.py | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-) diff --git a/binary_search_tree/tree.py b/binary_search_tree/tree.py index e30fc5b..8eb5235 100644 --- a/binary_search_tree/tree.py +++ b/binary_search_tree/tree.py @@ -77,7 +77,19 @@ def height(self): # # Time Complexity: # # Space Complexity: def bfs(self): - pass + if not self.root: + return [] + queue = [ self.root ] + values = [] + while queue: + current = queue.pop(0) + # {'key': 5, 'value': 'Peter'} + values.append({'key': current.key, 'value': current.value}) + if current.left: + queue.append(current.left) + if current.right: + queue.append(current.right) + return values From 58f7a32e1b29ae09335a190d803c74ac93e66638 Mon Sep 17 00:00:00 2001 From: Laurel S Date: Fri, 27 May 2022 13:03:35 -0700 Subject: [PATCH 3/4] Adds methods for preorder, inorder, postorder traversals --- binary_search_tree/tree.py | 54 +++++++++++++++++++++++++++++++++++--- 1 file changed, 51 insertions(+), 3 deletions(-) diff --git a/binary_search_tree/tree.py b/binary_search_tree/tree.py index 8eb5235..f3905d9 100644 --- a/binary_search_tree/tree.py +++ b/binary_search_tree/tree.py @@ -11,6 +11,7 @@ def __init__(self, key, val = None): class Tree: + # # ITERATIVE def __init__(self): self.root = None @@ -35,6 +36,14 @@ def add(self, key, value = None): else: previous.right = node + # RECURSIVE + # Time Complexity: + # Space Complexity: + # def add(self, key, value = None): + # # base case + # if not current.left and not current.right: + + # Time Complexity: # Space Complexity: def find(self, key): @@ -52,20 +61,59 @@ def find(self, key): current = current.right return None + def inorder_helper(self, root, nodes): + if root: + self.inorder_helper(root.left, nodes) + nodes.append({'key': root.key, 'value': root.value}) + self.inorder_helper(root.right, nodes) + # Time Complexity: # Space Complexity: def inorder(self): - pass + # left, root, right + if not self.root: + return [] + nodes = [] + + self.inorder_helper(self.root, nodes) + return nodes + # nodes.append({'key': current.key, 'value': current.value}) + # this has to be recursive + + def preorder_helper(self, current, nodes): + if current: + nodes.append({'key': current.key, 'value': current.value}) + self.preorder_helper(current.left, nodes) + self.preorder_helper(current.right, nodes) + return + # Time Complexity: # Space Complexity: def preorder(self): - pass + # root -> left -> right + if not self.root: + return [] + nodes_list = [] + self.preorder_helper(self.root, nodes_list) + return nodes_list + + def postorder_helper(self, current, nodes_list): + if current: + self.postorder_helper(current.left, nodes_list) + self.postorder_helper(current.right, nodes_list) + nodes_list.append({'key': current.key, 'value': current.value}) + # Time Complexity: # Space Complexity: def postorder(self): - pass + # left -> right -> root + if not self.root: + return [] + nodes_list = [] + self.postorder_helper(self.root, nodes_list) + return nodes_list # Time Complexity: # Space Complexity: From 6d052e77bf485b24378d4a41287ae308c6b5a965 Mon Sep 17 00:00:00 2001 From: Laurel S Date: Fri, 27 May 2022 13:42:36 -0700 Subject: [PATCH 4/4] Adds space and time complexity analysis --- binary_search_tree/tree.py | 47 +++++++++++++++++++++++--------------- 1 file changed, 28 insertions(+), 19 deletions(-) diff --git a/binary_search_tree/tree.py b/binary_search_tree/tree.py index f3905d9..82a4e15 100644 --- a/binary_search_tree/tree.py +++ b/binary_search_tree/tree.py @@ -15,8 +15,8 @@ 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): node = TreeNode(key, value) if not self.root: @@ -44,8 +44,8 @@ def add(self, key, value = None): # if not current.left and not current.right: - # Time Complexity: - # Space Complexity: + # Time Complexity: O(log n) + # Space Complexity: O(1) def find(self, key): if not self.root: return None @@ -67,8 +67,8 @@ def inorder_helper(self, root, nodes): nodes.append({'key': root.key, 'value': root.value}) self.inorder_helper(root.right, nodes) - # Time Complexity: - # Space Complexity: + # Time Complexity: O(n) while n = number of nodes in BST + # Space Complexity: O(n) def inorder(self): # left, root, right if not self.root: @@ -77,8 +77,6 @@ def inorder(self): self.inorder_helper(self.root, nodes) return nodes - # nodes.append({'key': current.key, 'value': current.value}) - # this has to be recursive def preorder_helper(self, current, nodes): @@ -88,8 +86,8 @@ def preorder_helper(self, current, nodes): self.preorder_helper(current.right, nodes) return - # Time Complexity: - # Space Complexity: + # Time Complexity: O(n) n = number of nodes in BST + # Space Complexity: O(n) def preorder(self): # root -> left -> right if not self.root: @@ -104,9 +102,9 @@ def postorder_helper(self, current, nodes_list): self.postorder_helper(current.left, nodes_list) self.postorder_helper(current.right, nodes_list) nodes_list.append({'key': current.key, 'value': current.value}) - - # Time Complexity: - # Space Complexity: + + # Time Complexity: O(n) n = number of nodes in BST + # Space Complexity: O(n) def postorder(self): # left -> right -> root if not self.root: @@ -115,15 +113,26 @@ def postorder(self): self.postorder_helper(self.root, nodes_list) return nodes_list - # Time Complexity: - # Space Complexity: + + def height_helper(self, root): + if not root: + return 0 + left_height = self.height_helper(root.left) + right_height = self.height_helper(root.right) + return 1 + max(left_height, right_height) + + + # Time Complexity: O(n) and n = # of nodes in BST + # Space Complexity: O(n) ? not sure on this one def height(self): - pass + if not self.root: + return 0 + return self.height_helper(self.root) -# # Optional Method -# # Time Complexity: -# # Space Complexity: + # Optional Method + # Time Complexity: O(n) where n = number of nodes in BST + # Space Complexity: O(n) def bfs(self): if not self.root: return []