From 0be94f8fc84215add10df7c0ba813ce936e41c12 Mon Sep 17 00:00:00 2001 From: Chris M Date: Tue, 20 Aug 2019 22:31:14 -0700 Subject: [PATCH 1/4] 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/4] 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 6deaf75174f343feb4f214847979d8c1202d0da1 Mon Sep 17 00:00:00 2001 From: Angele Zamarron Date: Tue, 25 Feb 2020 23:49:35 -0800 Subject: [PATCH 3/4] complete --- lib/tree.rb | 101 +++++++++++++++++++++++++++++++++++++--------- test/tree_test.rb | 33 +++++++++++++++ 2 files changed, 116 insertions(+), 18 deletions(-) diff --git a/lib/tree.rb b/lib/tree.rb index c0d4b51..f220e2c 100644 --- a/lib/tree.rb +++ b/lib/tree.rb @@ -16,40 +16,105 @@ def initialize @root = nil end - # Time Complexity: - # Space Complexity: + # Time Complexity: O(logn) in worst case scenario + # Space Complexity: O(1) always just adding 1 new node def add(key, value) - raise NotImplementedError + @root = add_helper(@root, key, value) end - # Time Complexity: - # Space Complexity: + def add_helper(current_node, key, value) + return TreeNode.new(key, value) if current_node.nil? + + if key < current_node.key + current_node.left = add_helper(current_node.left, key, value) + else + current_node.right = add_helper(current_node.right, key, value) + end + + return current_node + end + + # Time Complexity: O(logn) since binary + # Space Complexity: O(1) since adding nothing new def find(key) - raise NotImplementedError + return find_helper(@root, key) end - # Time Complexity: - # Space Complexity: + def find_helper(current_node, key) + return nil if current_node.nil? + return current_node.value if key == current_node.key + + if key < current_node.key + find_helper(current_node.left, key) + else + find_helper(current_node.right, key) + end + end + + + # Time Complexity: O(n) since going to each node once, backtracking but still backtracking a smaller number of times than there are nodes, so it depends on the number of nodes no matter what. + # Space Complexity: O(1) - nothing being made def inorder - raise NotImplementedError + return inorder_helper(@root, []) end - # Time Complexity: - # Space Complexity: + # helper + def inorder_helper(current_node, list) + # left, root, right + return list if current_node.nil? + # recursion! left side first + inorder_helper(current_node.left, list) + list << {key: current_node.key, value: current_node.value} + inorder_helper(current_node.right, list) + return list + end + + # Time Complexity: same as inorder + # Space Complexity: same as inorder def preorder - raise NotImplementedError + return preorder_helper(@root, []) end - # Time Complexity: - # Space Complexity: + def preorder_helper(current_node, list) + # root, left, right + return list if current_node.nil? + list << {key: current_node.key, value: current_node.value} + preorder_helper(current_node.left, list) + preorder_helper(current_node.right, list) + return list + end + + # Time Complexity: same as inorder + # Space Complexity: same as inorder def postorder - raise NotImplementedError + return postorder_helper(@root, []) end - # Time Complexity: - # Space Complexity: + def postorder_helper(current_node, list) + # left, right, root + return list if current_node.nil? + postorder_helper(current_node.left, list) + postorder_helper(current_node.right, list) + list << {key: current_node.key, value: current_node.value} + return list + end + + # Time Complexity: O(n) since each node is visited once + # Space Complexity: O(1) since it doesn't make anything new def height - raise NotImplementedError + return height_helper(@root, 0) + end + + def height_helper(current_node, current_height) + return 0 if current_node.nil? + left_height = height_helper(current_node.left, current_height) + right_height = height_helper(current_node.right, current_height) + if left_height > right_height + return left_height + 1 + else + return right_height + 1 + end + end # Optional Method diff --git a/test/tree_test.rb b/test/tree_test.rb index 222b693..9154916 100644 --- a/test/tree_test.rb +++ b/test/tree_test.rb @@ -5,6 +5,8 @@ describe Tree do let (:tree) {Tree.new} + let (:tree2) {Tree.new} + let (:tree3) {Tree.new} let (:tree_with_nodes) { tree.add(5, "Peter") @@ -16,6 +18,29 @@ tree } + let (:tree_with_nodes2) { + tree2.add(5, "Peter") + tree2.add(3, "Paul") + tree2.add(1, "Mary") + tree2.add(10, "Karla") + tree2.add(15, "Ada") + tree2.add(25, "Kari") + tree2.add(13, "Karino") + tree2 + } + + let (:tree_with_nodes3) { + tree3.add(5, "Peter") + tree3.add(3, "Paul") + tree3.add(1, "Mary") + tree3.add(10, "Karla") + tree3.add(15, "Ada") + tree3.add(25, "Kari") + tree3.add(17, "Karino") + tree3.add(30, "Karenina") + tree3 + } + it "add & find values" do tree.add(5, "Peter") expect(tree.find(5)).must_equal "Peter" @@ -77,6 +102,14 @@ it "returns correct height of tree" do expect(tree_with_nodes.height).must_equal 4 end + + it "returns correct height of 2nd tree" do + expect(tree_with_nodes2.height).must_equal 4 + end + + it "returns correct height of 3rd tree" do + expect(tree_with_nodes3.height).must_equal 5 + end end describe "breadth first search" do From d7ab1537c5f0bc945205e01a55d73d6324e3e496 Mon Sep 17 00:00:00 2001 From: Angele Zamarron Date: Mon, 2 Mar 2020 22:29:50 -0800 Subject: [PATCH 4/4] updates to space complexity --- lib/tree.rb | 21 +++++++++++++++------ 1 file changed, 15 insertions(+), 6 deletions(-) diff --git a/lib/tree.rb b/lib/tree.rb index f220e2c..d866bde 100644 --- a/lib/tree.rb +++ b/lib/tree.rb @@ -16,8 +16,8 @@ def initialize @root = nil end - # Time Complexity: O(logn) in worst case scenario - # Space Complexity: O(1) always just adding 1 new node + # Time Complexity: O(logn) in best case scenario + # Space Complexity: def add(key, value) @root = add_helper(@root, key, value) end @@ -35,7 +35,7 @@ def add_helper(current_node, key, value) end # Time Complexity: O(logn) since binary - # Space Complexity: O(1) since adding nothing new + # Space Complexity: O(n) since def find(key) return find_helper(@root, key) end @@ -53,7 +53,7 @@ def find_helper(current_node, key) # Time Complexity: O(n) since going to each node once, backtracking but still backtracking a smaller number of times than there are nodes, so it depends on the number of nodes no matter what. - # Space Complexity: O(1) - nothing being made + # Space Complexity: O(n) making an array that is number-of-nodes long def inorder return inorder_helper(@root, []) end @@ -100,7 +100,7 @@ def postorder_helper(current_node, list) end # Time Complexity: O(n) since each node is visited once - # Space Complexity: O(1) since it doesn't make anything new + # Space Complexity: O(logn) assuming balanced tree since max mem stack being used is height of tree def height return height_helper(@root, 0) end @@ -121,7 +121,16 @@ def height_helper(current_node, current_height) # Time Complexity: # Space Complexity: def bfs - raise NotImplementedError + list = [] + return list if @root.nil? + queue = [@root] + until queue.empty + current = queue.shift + queue.push(current.left) unless current.left.nil? + queue.push(current.right) unless current.right.nil? + + list << {key: current.key, value: current.value } + end end # Useful for printing