From aeac65b9d821053c7e5362a1ec304559e874f250 Mon Sep 17 00:00:00 2001 From: Gabe Kelemen Date: Thu, 26 May 2022 16:02:21 -0400 Subject: [PATCH 1/6] Add find, add, add_helper methods --- binary_search_tree/tree.py | 67 ++++++++++++++++++++++++++++++-------- 1 file changed, 53 insertions(+), 14 deletions(-) diff --git a/binary_search_tree/tree.py b/binary_search_tree/tree.py index cdd5abc..cec0d0f 100644 --- a/binary_search_tree/tree.py +++ b/binary_search_tree/tree.py @@ -9,34 +9,73 @@ def __init__(self, key, val = None): self.right = None - class Tree: def __init__(self): self.root = None - # Time Complexity: - # Space Complexity: + # Time Complexity: 0(log n) + # Space Complexity: 0(log n) + + def add_helper(self, current_node, key, value): + # helper takes advantage of recursive + # if node is empty, return new node with key and 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 + + # else: + # parent = None + # current = self.root + # while current != None: + # parent = current + # if key <= current.key: + # current = current.right + # else: + # current = current.left + # if parent.key > key: + # parent.left = TreeNode(key, value) + + def add(self, key, value = None): - pass + if self.root == None: + self.root = TreeNode(key, value) + else: + self.add_helper(self.root, key, value) + + - # Time Complexity: - # Space Complexity: + # Time Complexity: 0(log n) + # Space Complexity: 0(log n) def find(self, key): - pass + if self.root == None: + return None + current = self.root + while current != None: + if current.key == key: + return current.value + elif current.key Date: Thu, 26 May 2022 16:21:07 -0400 Subject: [PATCH 2/6] Add inorder and inorder_helper --- binary_search_tree/tree.py | 27 ++++++++++++--------------- 1 file changed, 12 insertions(+), 15 deletions(-) diff --git a/binary_search_tree/tree.py b/binary_search_tree/tree.py index cec0d0f..6c16bcc 100644 --- a/binary_search_tree/tree.py +++ b/binary_search_tree/tree.py @@ -27,26 +27,12 @@ def add_helper(self, current_node, key, value): current_node.right = self.add_helper(current_node.right, key, value) return current_node - # else: - # parent = None - # current = self.root - # while current != None: - # parent = current - # if key <= current.key: - # current = current.right - # else: - # current = current.left - # if parent.key > key: - # parent.left = TreeNode(key, value) - - def add(self, key, value = None): if self.root == None: self.root = TreeNode(key, value) else: self.add_helper(self.root, key, value) - # Time Complexity: 0(log n) # Space Complexity: 0(log n) @@ -65,8 +51,19 @@ def find(self, key): # Time Complexity: 0(n) # Space Complexity: 0(n) + + def inorder_helper(self, current_node, items): + if current_node != None: + self.inorder_helper(current_node.left, items) + items.append({"key": current_node.key, "value": current_node.value}) + self.inorder_helper(current_node.right, items) + + def inorder(self): - pass + #list of items to be returned + items = [] + self.inorder_helper(self.root, items) + return items # Time Complexity: 0(n) # Space Complexity: 0(n) From 101fa783414a75b5e3dda131787328f2db76e8ab Mon Sep 17 00:00:00 2001 From: Gabe Kelemen Date: Thu, 26 May 2022 16:48:50 -0400 Subject: [PATCH 3/6] Add height and height_helper --- binary_search_tree/tree.py | 30 +++++++++++++++++++++--------- 1 file changed, 21 insertions(+), 9 deletions(-) diff --git a/binary_search_tree/tree.py b/binary_search_tree/tree.py index 6c16bcc..7b1d589 100644 --- a/binary_search_tree/tree.py +++ b/binary_search_tree/tree.py @@ -71,14 +71,29 @@ def preorder(self): pass # Time Complexity: 0(n) - # Space Complexity: 0(n) - def postorder(self): - pass + # Space Complexity: 0(n) + + # def postorder_helper(self): + + # def postorder(self): + # items = [] + # self.postorder_helper(self.root, items) - # Time Complexity: - # Space Complexity: + # Time Complexity: 0(n) + # Space Complexity: 0(n) + def height_helper(self, current_node): + # uses stack and recursion for each node in tree + # plus one for the root node / the current node + if current_node != None: + height_left = self.height_helper(current_node.left) + height_right = self.height_helper(current_node.right) + return (max(height_left, height_right) + 1) + + else: + return 0 + def height(self): - pass + return self.height_helper(self.root) # # Optional Method @@ -87,9 +102,6 @@ def height(self): def bfs(self): pass - - - # # Useful for printing def to_s(self): return f"{self.inorder()}" From baa7ac65b5d75894b8175e352e86e1440e8a7d69 Mon Sep 17 00:00:00 2001 From: Gabe Kelemen Date: Thu, 26 May 2022 17:07:52 -0400 Subject: [PATCH 4/6] Add postorder and postorder_helper --- binary_search_tree/tree.py | 29 ++++++++++++++++++++--------- 1 file changed, 20 insertions(+), 9 deletions(-) diff --git a/binary_search_tree/tree.py b/binary_search_tree/tree.py index 7b1d589..8d823ad 100644 --- a/binary_search_tree/tree.py +++ b/binary_search_tree/tree.py @@ -1,3 +1,6 @@ +from multiprocessing.dummy import current_process + + class TreeNode: def __init__(self, key, val = None): if val == None: @@ -14,8 +17,7 @@ def __init__(self): self.root = None # Time Complexity: 0(log n) - # Space Complexity: 0(log n) - + # Space Complexity: 0(log n) def add_helper(self, current_node, key, value): # helper takes advantage of recursive # if node is empty, return new node with key and value @@ -49,35 +51,43 @@ def find(self, key): current = current.left return None + # Time Complexity: 0(n) # Space Complexity: 0(n) - def inorder_helper(self, current_node, items): if current_node != None: self.inorder_helper(current_node.left, items) items.append({"key": current_node.key, "value": current_node.value}) self.inorder_helper(current_node.right, items) - def inorder(self): #list of items to be returned items = [] self.inorder_helper(self.root, items) return items + # Time Complexity: 0(n) # Space Complexity: 0(n) def preorder(self): pass + # Time Complexity: 0(n) # Space Complexity: 0(n) - - # def postorder_helper(self): + def postorder_helper(self, current_node, items): + if current_node: + self.postorder_helper(current_node.left, items) + self.postorder_helper(current_node.right, items) + items.append({"key": current_node.key, "value": current_node.value}) + return items - # def postorder(self): - # items = [] - # self.postorder_helper(self.root, items) + def postorder(self): + items = [] + if self.root: + self.postorder_helper(self.root, items) + return items + # Time Complexity: 0(n) # Space Complexity: 0(n) @@ -96,6 +106,7 @@ def height(self): return self.height_helper(self.root) + # # Optional Method # # Time Complexity: # # Space Complexity: From 65dd3597dbf95ab3b3b8d9b25a8563b632af75aa Mon Sep 17 00:00:00 2001 From: Gabe Kelemen Date: Thu, 26 May 2022 17:27:36 -0400 Subject: [PATCH 5/6] Add preorder and preorder_helper --- binary_search_tree/tree.py | 21 ++++++++++++++++++--- 1 file changed, 18 insertions(+), 3 deletions(-) diff --git a/binary_search_tree/tree.py b/binary_search_tree/tree.py index 8d823ad..73514d6 100644 --- a/binary_search_tree/tree.py +++ b/binary_search_tree/tree.py @@ -1,4 +1,5 @@ from multiprocessing.dummy import current_process +from typing import ItemsView class TreeNode: @@ -61,16 +62,29 @@ def inorder_helper(self, current_node, items): self.inorder_helper(current_node.right, items) def inorder(self): - #list of items to be returned + #list of items to be returned --> depth-first traversal sorted key values in an ascending order, Left,Current,Right items = [] self.inorder_helper(self.root, items) return items # Time Complexity: 0(n) - # Space Complexity: 0(n) + # Space Complexity: 0(n) + def preorder_helper(self, current_node, items): + if current_node == None: + return items + else: + items.append({"key": current_node.key, "value": current_node.value}) + self.preorder_helper(current_node.left, items) + self.preorder_helper(current_node.right, items) + return items + def preorder(self): - pass + #list of items to be returned --> depth-first traversal sorted current, left, right + items = [] + if self.root: + self.preorder_helper(self.root, items) + return items # Time Complexity: 0(n) @@ -83,6 +97,7 @@ def postorder_helper(self, current_node, items): return items def postorder(self): + #list of items to be returned --> depth-first traversal sorted left, right, current items = [] if self.root: self.postorder_helper(self.root, items) From 89f5f96c124cb9d38a8a278d708923b11096234f Mon Sep 17 00:00:00 2001 From: Gabe Kelemen Date: Sat, 28 May 2022 08:09:18 -0400 Subject: [PATCH 6/6] Add bfs and bfs_helper --- binary_search_tree/tree.py | 30 +++++++++++++++++++++++++++--- 1 file changed, 27 insertions(+), 3 deletions(-) diff --git a/binary_search_tree/tree.py b/binary_search_tree/tree.py index 73514d6..3ac9341 100644 --- a/binary_search_tree/tree.py +++ b/binary_search_tree/tree.py @@ -123,10 +123,34 @@ def height(self): # # Optional Method -# # Time Complexity: -# # Space Complexity: +# # Time Complexity: O(n) +# # Space Complexity: O(n) + + def bfs_helper(self, current_node, sub_list): + if current_node.left: + sub_list.append(current_node.left) + if current_node.right: + sub_list.append(current_node.right) + + def bfs(self): - pass + # uses queues to create sublists for each level, pops off elements from queue from left to right until sublist is empty to creates list, then adds children of each element to queue as popping off, repeats, + # recursion for each level + items = [] + sub_list = [] + + if not self.root: + return items + + items.append({"key": self.root.key, "value": self.root.value}) + self.bfs_helper(self.root, sub_list) + + while sub_list: + current_node = sub_list.pop(0) + items.append({"key": current_node.key, "value": current_node.value}) + self.bfs_helper(current_node, sub_list) + return items + # # Useful for printing def to_s(self):