From 0be94f8fc84215add10df7c0ba813ce936e41c12 Mon Sep 17 00:00:00 2001 From: Chris M Date: Tue, 20 Aug 2019 22:31:14 -0700 Subject: [PATCH 1/3] Update README.md --- README.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/README.md b/README.md index 73287d1..eec9657 100644 --- a/README.md +++ b/README.md @@ -1,5 +1,7 @@ # Tree Exercise +This project is due **Monday September 2nd, 2019** + In this exercise you will implement, in Ruby, several Tree methods. - `add(value)` - This method adds a value to the Binary Search Tree From 5179a2804138b80c0b05f63abf60f656f47b3034 Mon Sep 17 00:00:00 2001 From: Elle K Date: Mon, 2 Sep 2019 20:37:09 -0700 Subject: [PATCH 2/3] Add a test for the height method One for empty tree, one for tree_with_nodes --- test/tree_test.rb | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/test/tree_test.rb b/test/tree_test.rb index 8811f14..222b693 100644 --- a/test/tree_test.rb +++ b/test/tree_test.rb @@ -68,6 +68,16 @@ {:key=>10, :value=>"Karla"}, {:key=>5, :value=>"Peter"}] end end + + describe "height" do + it "returns 0 for an empty tree" do + expect(tree.height).must_equal 0 + end + + it "returns correct height of tree" do + expect(tree_with_nodes.height).must_equal 4 + end + end describe "breadth first search" do it "will give an empty array for an empty tree" do @@ -80,4 +90,4 @@ {:key=>15, :value=>"Ada"}, {:key=>25, :value=>"Kari"}] end end -end \ No newline at end of file +end From b438e0e065073ca9e0d6bc46be4c9f37373c8ae8 Mon Sep 17 00:00:00 2001 From: daniela sanchez Date: Wed, 17 Jun 2020 12:33:31 -0700 Subject: [PATCH 3/3] Solution --- lib/tree.rb | 123 +++++++++++++++++++++++++++++++++++++++++++--------- 1 file changed, 102 insertions(+), 21 deletions(-) diff --git a/lib/tree.rb b/lib/tree.rb index c0d4b51..1ee1336 100644 --- a/lib/tree.rb +++ b/lib/tree.rb @@ -16,47 +16,128 @@ def initialize @root = nil end - # Time Complexity: - # Space Complexity: + # Time Complexity: O(log(n)) + # Space Complexity: O(1), because we are adding one node at the time. def add(key, value) - raise NotImplementedError + @root = add_helper(@root, key, value) end - # Time Complexity: - # Space Complexity: + def add_helper(root, key, value) + if root.nil? + root = TreeNode.new(key, value) + return root + end + + if root.key > key + root.left = add_helper(root.left, key, value) + else + root.right = add_helper(root.right, key, value) + end + + return root + end + + # Time Complexity: O(log(n)) + # Space Complexity: O(log(n)), because of the stack def find(key) - raise NotImplementedError + return find_helper(@root, key) + end + + def find_helper(node, key) + return nil if node.nil? + + if node.key == key + return node.value + elsif node.key > key + return find_helper(node.left, key) + else + return find_helper(node.right, key) + end end - # Time Complexity: - # Space Complexity: + # Time Complexity: O(n) + # Space Complexity: O(n), if tree is not balanced (stack) def inorder - raise NotImplementedError + result = [] + inorder_recursion(@root, result) + return result end - # Time Complexity: - # Space Complexity: + def inorder_recursion(node, result) + return if node.nil? + + inorder_recursion(node.left, result) + result.push({ :key => node.key, :value => node.value }) + inorder_recursion(node.right, result) + end + + # Time Complexity: O(n) + # Space Complexity: O(n) if tree is not balanced (stack) def preorder - raise NotImplementedError + result = [] + preorder_recursion(@root, result) + return result + end + + def preorder_recursion(node, result) + return if node.nil? + + result.push({ :key => node.key, :value => node.value }) + preorder_recursion(node.left, result) + preorder_recursion(node.right, result) end - # Time Complexity: - # Space Complexity: + # Time Complexity: O(n) + # Space Complexity: O(n) if tree is not balanced (stack) def postorder - raise NotImplementedError + result = [] + postorder_recursion(@root, result) + return result + end + + def postorder_recursion(node, result) + return if node.nil? + + postorder_recursion(node.left, result) + postorder_recursion(node.right, result) + result.push({ :key => node.key, :value => node.value }) end - # Time Complexity: - # Space Complexity: + # Time Complexity: O(n) + # Space Complexity: O(n) if tree is not balanced (stack) def height - raise NotImplementedError + return get_depth(@root, 0) end + def get_depth(node, depth) + return depth if node.nil? + + return [get_depth(node.left, depth + 1), get_depth(node.right, depth + 1)].max +end + # Optional Method - # Time Complexity: - # Space Complexity: + # Time Complexity: O(n) + # Space Complexity: O(n) (result array) def bfs - raise NotImplementedError + return bfs_helper(@root) + end + + def bfs_helper(node) + result = [] + queue = Queue.new() + queue.enq(node) + + while !queue.empty? + curr = queue.deq() + + next if curr.nil? + + result.push({:key => curr.key, :value => curr.value}) + queue.enq(curr.left) + queue.enq(curr.right) + end + + return result end # Useful for printing