From 9790aecdbf16c56e83d7f02626d149f4cebd3f67 Mon Sep 17 00:00:00 2001 From: dnsrocha Date: Thu, 8 Apr 2021 17:00:50 -0700 Subject: [PATCH 1/2] implemented height --- lib/tree.rb | 66 ++++++++++++++++++++++++++++++++++++++++------- test/tree_test.rb | 2 +- 2 files changed, 57 insertions(+), 11 deletions(-) diff --git a/lib/tree.rb b/lib/tree.rb index c0d4b51..23b2553 100644 --- a/lib/tree.rb +++ b/lib/tree.rb @@ -16,10 +16,38 @@ def initialize @root = nil end - # Time Complexity: - # Space Complexity: - def add(key, value) - raise NotImplementedError + # Time Complexity: log(n) + # Space Complexity: log(n) + + def add_helper(key, value, current) + + if current.key == key + current.value = value + elsif current.key > key + if current.left == nil + current.left = TreeNode.new(key,value) + else + add_helper(key, value, current.left) + end + else + if current.right == nil + current.right = TreeNode.new(key, value) + else + add_helper(key, value, current.right) + end + end + + end + + def add(key, value = nil) + #what should I do to associate the value to the key when building the binaty tree search? + if @root.nil? + @root = TreeNode.new(key,value) #?? // what about the value? + return @root + else + add_helper(key, value, @root) + end + end # Time Complexity: @@ -30,8 +58,16 @@ def find(key) # Time Complexity: # Space Complexity: - def inorder - raise NotImplementedError + + def inorder(current = @root, values = []) + if current.nil? + return values + end + + inorder(current.left, values) + values.push(current.value) + inorder(current.right, values) + return values end # Time Complexity: @@ -46,10 +82,20 @@ def postorder raise NotImplementedError end - # Time Complexity: - # Space Complexity: - def height - raise NotImplementedError + # Time Complexity: o(n) + # Space Complexity: O(h), where h = height + def height(current = @root) + return 0 if current.nil? + + left_child = height(current.left) + right_child = height(current.right) + + if left_child > right_child + return left_child + 1 + else + return right_child + 1 + end + end # Optional Method diff --git a/test/tree_test.rb b/test/tree_test.rb index dbf3447..8cba2bd 100644 --- a/test/tree_test.rb +++ b/test/tree_test.rb @@ -96,7 +96,7 @@ end it "will report the height for a balanced tree" do - expect(tree_with_nodes.height).must_equal 3 + expect(tree_with_nodes.height).must_equal 4 end it "will report the height for unbalanced trees" do From b847e1cb98998735f0cc37f3fd7dfa2d631bb086 Mon Sep 17 00:00:00 2001 From: dnsrocha Date: Wed, 14 Apr 2021 23:00:01 -0700 Subject: [PATCH 2/2] all methods implemented // all tests passing --- lib/tree.rb | 95 +++++++++++++++++++++++++++++++++++++++++++---------- 1 file changed, 78 insertions(+), 17 deletions(-) diff --git a/lib/tree.rb b/lib/tree.rb index 23b2553..688790f 100644 --- a/lib/tree.rb +++ b/lib/tree.rb @@ -40,9 +40,8 @@ def add_helper(key, value, current) end def add(key, value = nil) - #what should I do to associate the value to the key when building the binaty tree search? if @root.nil? - @root = TreeNode.new(key,value) #?? // what about the value? + @root = TreeNode.new(key,value) return @root else add_helper(key, value, @root) @@ -50,14 +49,29 @@ def add(key, value = nil) end - # Time Complexity: - # Space Complexity: + # Time Complexity: O(n) + # Space Complexity: O(1) def find(key) - raise NotImplementedError + if @root.nil? + return nil + else + return find_helper(key, @root) + end end - # Time Complexity: - # Space Complexity: + def find_helper(key, current) + return nil if current.nil? + if current.key == key + return current.value + elsif current.key > key + find_helper(key, current.left) + else + find_helper(key, current.right) + end + end + + # Time Complexity: O(n) + # Space Complexity: O(n) def inorder(current = @root, values = []) if current.nil? @@ -65,21 +79,48 @@ def inorder(current = @root, values = []) end inorder(current.left, values) - values.push(current.value) + values.push({key: current.key, value: current.value}) inorder(current.right, values) return values end - # Time Complexity: - # Space Complexity: + # Time Complexity: O(n) + # Space Complexity: O(n) + + def preorder_helper(current, values) + return values if current.nil? + + values.push({key: current.key, value: current.value}) + preorder_helper(current.left, values) + preorder_helper(current.right, values) + + return values + end + + def preorder - raise NotImplementedError + current = @root + values = [] + return preorder_helper(current, values) + end + + # Time Complexity: O(n) + # Space Complexity: O(n) + + def postorder_helper(current, values) + return values if current.nil? + + postorder_helper(current.left, values) + postorder_helper(current.right, values) + values.push({key: current.key, value: current.value}) + + return values end - # Time Complexity: - # Space Complexity: def postorder - raise NotImplementedError + current = @root + values = [] + return postorder_helper(current, values) end # Time Complexity: o(n) @@ -99,10 +140,30 @@ def height(current = @root) end # Optional Method - # Time Complexity: - # Space Complexity: + # Time Complexity: O(n) if tree is not balanced; O(log(n)) if it's balanced + # Space Complexity: o(n) def bfs - raise NotImplementedError + values = [] + h = height + i = 1 + while i <= h + bfs_helper(@root, i, values) + i += 1 + end + + return values + end + + def bfs_helper(current, level, values) + return values if current.nil? + + if level == 1 + values.push({key: current.key, value: current.value}) + elsif level > 1 + bfs_helper(current.left, level - 1, values) + bfs_helper(current.right, level - 1, values) + end + return values end # Useful for printing