From 32ebd542502d64280c522d30b9ad437c10dfadcf Mon Sep 17 00:00:00 2001 From: Hallie Date: Sat, 22 Feb 2020 14:44:27 -0800 Subject: [PATCH 1/3] Can add and find a node. --- lib/tree.rb | 78 ++++++++++++++++---- test/tree_test.rb | 179 +++++++++++++++++++++++----------------------- 2 files changed, 153 insertions(+), 104 deletions(-) diff --git a/lib/tree.rb b/lib/tree.rb index c0d4b51..925f687 100644 --- a/lib/tree.rb +++ b/lib/tree.rb @@ -1,13 +1,13 @@ class TreeNode attr_reader :key, :value attr_accessor :left, :right - - def initialize(key, val) + + def initialize(key, val) @key = key @value = val @left = nil @right = nil - end + end end class Tree @@ -15,50 +15,98 @@ class Tree def initialize @root = nil end - + + 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: # Space Complexity: def add(key, value) - raise NotImplementedError + new_node = TreeNode.new(key,value) + + if @root.nil? + @root = new_node + else + add_helper(@root, key, value) + end end - - # Time Complexity: + + # Time Complexity: O(log n) # Space Complexity: + def find_helper(current_node, key) + return if current_node.nil? + + if key < current_node.key + current_node.left = find_helper(current_node.left, key) + elsif key > current_node.key + current_node.right = find_helper(current_node.right, key) + else + return current_node.value + end + + end + def find(key) - raise NotImplementedError + return if @root.nil? + + if @root == key + return @root.value + else + find_helper(@root, key) + end end - + # Time Complexity: # Space Complexity: + def inorder_helper(current_node, list) + return list if current_node.nil? + # left side + inorder_helper(current_node.left, list) + # middle node + list << { key: current_node.key, value: current_node.value } + # right side + inorder_helper(current_node.right, list) + return list + end + def inorder - raise NotImplementedError + return inorder_helper(@root, []) end - + # Time Complexity: # Space Complexity: def preorder raise NotImplementedError end - + # Time Complexity: # Space Complexity: def postorder raise NotImplementedError end - + # Time Complexity: # Space Complexity: def height raise NotImplementedError end - + # Optional Method # Time Complexity: # Space Complexity: def bfs raise NotImplementedError end - + # Useful for printing def to_s return "#{self.inorder}" diff --git a/test/tree_test.rb b/test/tree_test.rb index 345bf66..e0767a8 100644 --- a/test/tree_test.rb +++ b/test/tree_test.rb @@ -2,7 +2,7 @@ describe Tree do let (:tree) {Tree.new} - + let (:tree_with_nodes) { tree.add(5, "Peter") tree.add(3, "Paul") @@ -12,111 +12,112 @@ tree.add(25, "Kari") tree } - + describe "add and find" do it "add & find values" do tree.add(5, "Peter") expect(tree.find(5)).must_equal "Peter" - + tree.add(15, "Ada") expect(tree.find(15)).must_equal "Ada" - + tree.add(3, "Paul") expect(tree.find(3)).must_equal "Paul" end - + it "can't find anything when the tree is empty" do expect(tree.find(50)).must_be_nil end end - - describe "inorder" do + + xdescribe "inorder" do it "will give an empty array for an empty tree" do expect(tree.inorder).must_equal [] end - + it "will return the tree in order" do expect(tree_with_nodes.inorder).must_equal [{:key=>1, :value=>"Mary"}, {:key=>3, :value=>"Paul"}, - {:key=>5, :value=>"Peter"}, {:key=>10, :value=>"Karla"}, - {:key=>15, :value=>"Ada"}, {:key=>25, :value=>"Kari"}] - end - end - - - describe "preorder" do - it "will give an empty array for an empty tree" do - expect(tree.preorder).must_equal [] - end - - it "will return the tree in preorder" do - expect(tree_with_nodes.preorder).must_equal [{:key=>5, :value=>"Peter"}, {:key=>3, :value=>"Paul"}, - {:key=>1, :value=>"Mary"}, {:key=>10, :value=>"Karla"}, - {:key=>15, :value=>"Ada"}, {:key=>25, :value=>"Kari"}] - end - end - - describe "postorder" do - it "will give an empty array for an empty tree" do - expect(tree.postorder).must_equal [] - end - - it "will return the tree in postorder" do - expect(tree_with_nodes.postorder).must_equal [{:key=>1, :value=>"Mary"}, {:key=>3, :value=>"Paul"}, - {:key=>25, :value=>"Kari"}, {:key=>15, :value=>"Ada"}, - {:key=>10, :value=>"Karla"}, {:key=>5, :value=>"Peter"}] - end - end - - describe "breadth first search" do - it "will give an empty array for an empty tree" do - expect(tree.bfs).must_equal [] - end - - it "will return an array of a level-by-level output of the tree" do - expect(tree_with_nodes.bfs).must_equal [{:key=>5, :value=>"Peter"}, {:key=>3, :value=>"Paul"}, - {:key=>10, :value=>"Karla"}, {:key=>1, :value=>"Mary"}, - {:key=>15, :value=>"Ada"}, {:key=>25, :value=>"Kari"}] - end - end - - describe "height" do - it "will return 0 if tree is empty" do - expect(tree.height()).must_equal 0 - end - - it "will return the nuber of nodes in the longest path" do - expect(tree_with_nodes.height).must_equal 4 - tree_with_nodes.add(60, "sam") - tree_with_nodes.add(58, "penny") - tree_with_nodes.add(65, "sam") - expect(tree_with_nodes.height).must_equal 6 + {:key=>5, :value=>"Peter"}, {:key=>10, :value=>"Karla"}, + {:key=>15, :value=>"Ada"}, {:key=>25, :value=>"Kari"}] + end end - it "will give the correct height of a binary search tree" do - tree_with_nodes.add(30, "Tatiana") - expect(tree_with_nodes.height).must_equal 5 - end - end - - describe "delete" do - it "can delete a note in the tree" do - # Arrange & Assert - expect(tree_with_nodes.find(15)).must_equal "Ada" - - # Act - tree_with_nodes.delete(15) - - # Assert - expect(tree_with_nodes.find(15)).must_be_nil - end - - it "will return nil if the node is not in the tree when it's deleted" do - # Arrange & Act - answer = tree_with_nodes.delete(47) - - # Assert - expect(answer).must_be_nil - expect(tree_with_nodes.find(47)).must_be_nil - end - end -end + + xdescribe "preorder" do + it "will give an empty array for an empty tree" do + expect(tree.preorder).must_equal [] + end + + it "will return the tree in preorder" do + expect(tree_with_nodes.preorder).must_equal [{:key=>5, :value=>"Peter"}, {:key=>3, :value=>"Paul"}, + {:key=>1, :value=>"Mary"}, {:key=>10, :value=>"Karla"}, + {:key=>15, :value=>"Ada"}, {:key=>25, :value=>"Kari"}] + end + end + + xdescribe "postorder" do + it "will give an empty array for an empty tree" do + expect(tree.postorder).must_equal [] + end + + it "will return the tree in postorder" do + expect(tree_with_nodes.postorder).must_equal [{:key=>1, :value=>"Mary"}, {:key=>3, :value=>"Paul"}, + {:key=>25, :value=>"Kari"}, {:key=>15, :value=>"Ada"}, + {:key=>10, :value=>"Karla"}, {:key=>5, :value=>"Peter"}] + end + end + + xdescribe "breadth first search" do + it "will give an empty array for an empty tree" do + expect(tree.bfs).must_equal [] + end + + it "will return an array of a level-by-level output of the tree" do + expect(tree_with_nodes.bfs).must_equal [{:key=>5, :value=>"Peter"}, {:key=>3, :value=>"Paul"}, + {:key=>10, :value=>"Karla"}, {:key=>1, :value=>"Mary"}, + {:key=>15, :value=>"Ada"}, {:key=>25, :value=>"Kari"}] + end + end + + xdescribe "height" do + it "will return 0 if tree is empty" do + expect(tree.height()).must_equal 0 + end + + it "will return the nuber of nodes in the longest path" do + expect(tree_with_nodes.height).must_equal 4 + tree_with_nodes.add(60, "sam") + tree_with_nodes.add(58, "penny") + tree_with_nodes.add(65, "sam") + expect(tree_with_nodes.height).must_equal 6 + end + + it "will give the correct height of a binary search tree" do + tree_with_nodes.add(30, "Tatiana") + expect(tree_with_nodes.height).must_equal 5 + end + end + + xdescribe "delete" do + it "can delete a note in the tree" do + # Arrange & Assert + expect(tree_with_nodes.find(15)).must_equal "Ada" + + # Act + tree_with_nodes.delete(15) + + # Assert + expect(tree_with_nodes.find(15)).must_be_nil + end + + it "will return nil if the node is not in the tree when it's deleted" do + # Arrange & Act + answer = tree_with_nodes.delete(47) + + # Assert + expect(answer).must_be_nil + expect(tree_with_nodes.find(47)).must_be_nil + end + end + end + \ No newline at end of file From 6180d54370ac4531325063aab6170c41b6db603d Mon Sep 17 00:00:00 2001 From: Hallie Date: Sat, 22 Feb 2020 15:16:52 -0800 Subject: [PATCH 2/3] Traverses in-order and pre-order. --- lib/tree.rb | 16 ++++++++++++++-- test/tree_test.rb | 4 ++-- 2 files changed, 16 insertions(+), 4 deletions(-) diff --git a/lib/tree.rb b/lib/tree.rb index 925f687..c4f7305 100644 --- a/lib/tree.rb +++ b/lib/tree.rb @@ -41,7 +41,7 @@ def add(key, value) end # Time Complexity: O(log n) - # Space Complexity: + # Space Complexity: O(n) def find_helper(current_node, key) return if current_node.nil? @@ -84,8 +84,20 @@ def inorder # Time Complexity: # Space Complexity: + def preorder_helper(current_node, list) + return list if current_node.nil? + # middle node + list << { key: current_node.key, value: current_node.value } + # left side + preorder_helper(current_node.left, list) + # right side + preorder_helper(current_node.right, list) + + return list + end + def preorder - raise NotImplementedError + return preorder_helper(@root, []) end # Time Complexity: diff --git a/test/tree_test.rb b/test/tree_test.rb index e0767a8..205946b 100644 --- a/test/tree_test.rb +++ b/test/tree_test.rb @@ -30,7 +30,7 @@ end end - xdescribe "inorder" do + describe "inorder" do it "will give an empty array for an empty tree" do expect(tree.inorder).must_equal [] end @@ -43,7 +43,7 @@ end - xdescribe "preorder" do + describe "preorder" do it "will give an empty array for an empty tree" do expect(tree.preorder).must_equal [] end From 71e87843bf0d459d572f3be7c6053967842a66ea Mon Sep 17 00:00:00 2001 From: Hallie Date: Mon, 24 Feb 2020 07:34:30 -0800 Subject: [PATCH 3/3] Traverses postorder and can determine height. --- lib/tree.rb | 57 ++++++++++++++++++++++++++++++++++++----------- test/tree_test.rb | 10 ++++----- 2 files changed, 49 insertions(+), 18 deletions(-) diff --git a/lib/tree.rb b/lib/tree.rb index c4f7305..fa9d683 100644 --- a/lib/tree.rb +++ b/lib/tree.rb @@ -28,8 +28,8 @@ def add_helper(current_node, key, value) return current_node end - # Time Complexity: - # Space Complexity: + # Time Complexity: O(log n) + # Space Complexity: O(log n) def add(key, value) new_node = TreeNode.new(key,value) @@ -40,7 +40,7 @@ def add(key, value) end end - # Time Complexity: O(log n) + # Time Complexity: Best: O(log n), Worst: O(n) # Space Complexity: O(n) def find_helper(current_node, key) return if current_node.nil? @@ -65,8 +65,8 @@ def find(key) end end - # Time Complexity: - # Space Complexity: + # Time Complexity: O(n) + # Space Complexity: O(n) def inorder_helper(current_node, list) return list if current_node.nil? # left side @@ -82,8 +82,8 @@ def inorder return inorder_helper(@root, []) end - # Time Complexity: - # Space Complexity: + # Time Complexity: O(n) + # Space Complexity: O(n) def preorder_helper(current_node, list) return list if current_node.nil? # middle node @@ -100,16 +100,47 @@ def preorder return preorder_helper(@root, []) end - # Time Complexity: - # Space Complexity: + # Time Complexity: O(n) + # Space Complexity: O(n) + def postorder_helper(current_node, list) + return list if current_node.nil? + # left side + postorder_helper(current_node.left, list) + # right side + postorder_helper(current_node.right, list) + # middle node + list << { key: current_node.key, value: current_node.value } + + return list + end + def postorder - raise NotImplementedError + return postorder_helper(@root, []) + end + + # Time Complexity: O(n) + # Space Complexity:O(n) + def height_helper(current_node) + if current_node.nil? + return 0 + else + left = height_helper(current_node.left) + right = height_helper(current_node.right) + + if (left > right) + return left + 1 + else + return right + 1 + end + end end - # Time Complexity: - # Space Complexity: def height - raise NotImplementedError + if @root.nil? + return 0 + else + height_helper(@root) + end end # Optional Method diff --git a/test/tree_test.rb b/test/tree_test.rb index 205946b..347f50c 100644 --- a/test/tree_test.rb +++ b/test/tree_test.rb @@ -55,7 +55,7 @@ end end - xdescribe "postorder" do + describe "postorder" do it "will give an empty array for an empty tree" do expect(tree.postorder).must_equal [] end @@ -79,12 +79,12 @@ end end - xdescribe "height" do + describe "height" do it "will return 0 if tree is empty" do expect(tree.height()).must_equal 0 end - it "will return the nuber of nodes in the longest path" do + it "will return the number of nodes in the longest path" do expect(tree_with_nodes.height).must_equal 4 tree_with_nodes.add(60, "sam") tree_with_nodes.add(58, "penny") @@ -98,8 +98,8 @@ end end - xdescribe "delete" do - it "can delete a note in the tree" do + describe "delete" do + it "can delete a node in the tree" do # Arrange & Assert expect(tree_with_nodes.find(15)).must_equal "Ada"