From 7f097f5d9d340e0bc2014f0a2e199822356ed214 Mon Sep 17 00:00:00 2001 From: Julia Bouvier Date: Tue, 25 Feb 2020 13:14:48 -0800 Subject: [PATCH 1/4] Implemented add and find methods --- lib/tree.rb | 49 ++++++++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 46 insertions(+), 3 deletions(-) diff --git a/lib/tree.rb b/lib/tree.rb index c0d4b51..0af19d2 100644 --- a/lib/tree.rb +++ b/lib/tree.rb @@ -19,19 +19,62 @@ def initialize # Time Complexity: # Space Complexity: def add(key, value) - raise NotImplementedError + new_node = TreeNode.new(key, value) + + if @root.nil? + @root = new_node + else + add_helper(@root, new_node, key) + end end + def add_helper(current, new_node, key) + return new_node if current.nil? + + if key <= current.key + current.left = add_helper(current.left, new_node, key) + else + current.right = add_helper(current.right, new_node, key) + end + return current + end + + # Time Complexity: # Space Complexity: def find(key) - raise NotImplementedError + if @root.nil? + return nil + else + find_helper(key, @root) + end + end + + def find_helper(key, current) + return nil if current.nil? + if current.key == key + return current.value + elsif key > current.key + find_helper(key, current.right) + else + find_helper(key, current.left) + end end # Time Complexity: # Space Complexity: def inorder - raise NotImplementedError + return inorder_helper(@root, []) + end + + def inorder_helper(current, list) + return list if current.nil? + + inorder_helper(current.left, list) + list << { key: current.key, value: current.value} + inorder_helper(current.right, list) + + return list end # Time Complexity: From 31da4914813f608768a8d902a54563a85fe75474 Mon Sep 17 00:00:00 2001 From: Julia Bouvier Date: Tue, 25 Feb 2020 20:21:40 -0800 Subject: [PATCH 2/4] Implemented preorder, postorder and height methods --- lib/tree.rb | 89 ++++++++++++++++++++++++++++++++++++++++++++--------- 1 file changed, 74 insertions(+), 15 deletions(-) diff --git a/lib/tree.rb b/lib/tree.rb index 0af19d2..1c23da9 100644 --- a/lib/tree.rb +++ b/lib/tree.rb @@ -16,8 +16,8 @@ def initialize @root = nil end - # Time Complexity: - # Space Complexity: + # Time Complexity: log(n) + # Space Complexity: log(n) def add(key, value) new_node = TreeNode.new(key, value) @@ -40,8 +40,8 @@ def add_helper(current, new_node, key) end - # Time Complexity: - # Space Complexity: + # Time Complexity: log(n) + # Space Complexity: log(n) def find(key) if @root.nil? return nil @@ -61,8 +61,38 @@ def find_helper(key, current) end end - # Time Complexity: - # Space Complexity: + def delete(key) + node = find_node(key) + unless node.nil? + remove(node) + end + end + + def remove(node) + if node.left.nil? && node.right.nil? + node = nil + elsif !node.left.nil? && node.right.nil? + node = node.left + elsif node.left.nil? && !node.right.nil? + node = node.right + else + min_node = find_min_node(node.right) + node.value = min_node.value + min_node = nil + end + end + + def find_min_node(node) + if node.left.nil? + min_node = node + return min_node + else + find_min_node(node.left) + end + end + + # Time Complexity: O(n) + # Space Complexity: O(n) def inorder return inorder_helper(@root, []) end @@ -77,22 +107,51 @@ def inorder_helper(current, list) return list end - # Time Complexity: - # Space Complexity: + # Time Complexity: O(n) + # Space Complexity: O(n) def preorder - raise NotImplementedError + return preorder_helper(@root, []) end - # Time Complexity: - # Space Complexity: + def preorder_helper(node, list) + return list if node.nil? + + list << { key: node.key, value: node.value} + preorder_helper(node.left, list) + preorder_helper(node.right, list) + end + + # Time Complexity: O(n) + # Space Complexity: O(n) def postorder - raise NotImplementedError + return postorder_helper(@root, []) end - # Time Complexity: - # Space Complexity: + def postorder_helper(node, list) + return list if node.nil? + + postorder_helper(node.left, list) + postorder_helper(node.right, list) + list << { key: node.key, value: node.value} + end + + # Time Complexity: O(n) + # Space Complexity: O(log n) def height - raise NotImplementedError + return height_helper(@root, 0, 0) + end + + def height_helper(node, left, right) + if node.nil? + if left >= right + return left + else + return right + end + end + + height_helper(node.left, left + 1, right) + height_helper(node.right, left, right + 1) end # Optional Method From 631067e02b88c632e05697dce29718247171d19e Mon Sep 17 00:00:00 2001 From: Julia Bouvier Date: Tue, 25 Feb 2020 20:38:38 -0800 Subject: [PATCH 3/4] Added helper methods to delete method--error, even though the node is successfully being replaced the old value is still searchable --- lib/tree.rb | 22 +++++++++++++++++++++- 1 file changed, 21 insertions(+), 1 deletion(-) diff --git a/lib/tree.rb b/lib/tree.rb index 1c23da9..561bedd 100644 --- a/lib/tree.rb +++ b/lib/tree.rb @@ -61,6 +61,25 @@ def find_helper(key, current) end end + def find_node(key) + if @root.nil? + return nil + else + find_node_helper(key, @root) + end + end + + def find_node_helper(key, current) + return nil if current.nil? + if current.key == key + return current + elsif key > current.key + find_node_helper(key, current.right) + else + find_node_helper(key, current.left) + end + end + def delete(key) node = find_node(key) unless node.nil? @@ -75,9 +94,10 @@ def remove(node) node = node.left elsif node.left.nil? && !node.right.nil? node = node.right + puts node.value else min_node = find_min_node(node.right) - node.value = min_node.value + node = min_node min_node = nil end end From 77cde87fc3cad809de4f50e87f745d2a72e5e8d2 Mon Sep 17 00:00:00 2001 From: Julia Bouvier Date: Thu, 27 Feb 2020 14:42:05 -0800 Subject: [PATCH 4/4] Updated height method --- lib/tree.rb | 18 +++++++----------- 1 file changed, 7 insertions(+), 11 deletions(-) diff --git a/lib/tree.rb b/lib/tree.rb index 561bedd..5deff2b 100644 --- a/lib/tree.rb +++ b/lib/tree.rb @@ -158,20 +158,16 @@ def postorder_helper(node, list) # Time Complexity: O(n) # Space Complexity: O(log n) def height - return height_helper(@root, 0, 0) + return height_helper(@root) end - def height_helper(node, left, right) - if node.nil? - if left >= right - return left - else - return right - end - end + def height_helper(current) + return 0 if current.nil? + + left_height = height_helper(current.left) + right_height = height_helper(current.right) - height_helper(node.left, left + 1, right) - height_helper(node.right, left, right + 1) + return [left_height, right_height].max + 1 end # Optional Method