From 359b9d73bb0e653105fbebf076ffcac62c79d385 Mon Sep 17 00:00:00 2001 From: Anya Tokar Date: Sat, 10 Apr 2021 17:41:50 -0700 Subject: [PATCH 1/3] add and find --- .tool-versions | 1 + lib/tree.rb | 37 ++++++++++++++++++++++++++++++------- test/tree_test.rb | 8 ++++---- 3 files changed, 35 insertions(+), 11 deletions(-) create mode 100644 .tool-versions diff --git a/.tool-versions b/.tool-versions new file mode 100644 index 0000000..9eb38ed --- /dev/null +++ b/.tool-versions @@ -0,0 +1 @@ +ruby 2.7.2 diff --git a/lib/tree.rb b/lib/tree.rb index c0d4b51..76ce209 100644 --- a/lib/tree.rb +++ b/lib/tree.rb @@ -16,22 +16,45 @@ def initialize @root = nil end - # Time Complexity: - # Space Complexity: + # Time Complexity: O(log n) + # Space Complexity: O(1) + def add_helper(key, value, current) + if key <= current.key + current.left ? add_helper(key, value, current = current.left) : current.left = TreeNode.new(key, value) + else + current.right ? add_helper(key, value, current = current.right) : current.right = TreeNode.new(key, value) + end + end + def add(key, value) - raise NotImplementedError + if @root.nil? + @root = TreeNode.new(key, value) + return @root + end + add_helper(key, value, current = @root) + end + + # Time Complexity: O(log n) + # Space Complexity: O(1) + def find_helper(key, current) + return nil if current.nil? + return current.value if current.key == key + if key < current.key + find_helper(key, current = current.left) + else key > current.key + find_helper(key, current.right) + end end - # Time Complexity: - # Space Complexity: def find(key) - raise NotImplementedError + find_helper(key, current = @root) end # Time Complexity: # Space Complexity: def inorder - raise NotImplementedError + return [] if @root.nil? + end # Time Complexity: diff --git a/test/tree_test.rb b/test/tree_test.rb index 60f5981..151029f 100644 --- a/test/tree_test.rb +++ b/test/tree_test.rb @@ -45,7 +45,7 @@ end - describe "preorder" do + xdescribe "preorder" do it "will give an empty array for an empty tree" do expect(tree.preorder).must_equal [] end @@ -57,7 +57,7 @@ end end - describe "postorder" do + xdescribe "postorder" do it "will give an empty array for an empty tree" do expect(tree.postorder).must_equal [] end @@ -69,7 +69,7 @@ end end - describe "breadth first search" do + xdescribe "breadth first search" do it "will give an empty array for an empty tree" do expect(tree.bfs).must_equal [] end @@ -81,7 +81,7 @@ end end - describe "height" do + xdescribe "height" do it "will return 0 for an empty tree" do my_tree = Tree.new From 526889d91bb5031d710abee613290a23bed145e3 Mon Sep 17 00:00:00 2001 From: Anya Tokar Date: Sat, 10 Apr 2021 20:17:50 -0700 Subject: [PATCH 2/3] traversals --- lib/tree.rb | 62 +++++++++++++++++++++++++++++++++-------------- test/tree_test.rb | 6 ++--- 2 files changed, 47 insertions(+), 21 deletions(-) diff --git a/lib/tree.rb b/lib/tree.rb index 76ce209..4f263c5 100644 --- a/lib/tree.rb +++ b/lib/tree.rb @@ -20,18 +20,18 @@ def initialize # Space Complexity: O(1) def add_helper(key, value, current) if key <= current.key - current.left ? add_helper(key, value, current = current.left) : current.left = TreeNode.new(key, value) + current.left ? add_helper(key, value, current.left) : current.left = TreeNode.new(key, value) else - current.right ? add_helper(key, value, current = current.right) : current.right = TreeNode.new(key, value) + current.right ? add_helper(key, value, current.right) : current.right = TreeNode.new(key, value) end end - def add(key, value) + def add(key, value = nil) if @root.nil? @root = TreeNode.new(key, value) return @root end - add_helper(key, value, current = @root) + add_helper(key, value, @root) end # Time Complexity: O(log n) @@ -40,39 +40,65 @@ def find_helper(key, current) return nil if current.nil? return current.value if current.key == key if key < current.key - find_helper(key, current = current.left) + find_helper(key, current.left) else key > current.key find_helper(key, current.right) end end def find(key) - find_helper(key, current = @root) + find_helper(key, @root) + end + + # Time Complexity: 0(n) with n being number of nodes in the tree + # Space Complexity: O(n) + def inorder_helper(current, elements) + return elements if current.nil? + inorder_helper(current.left, elements) + elements << {:key => current.key, :value => current.value} + inorder_helper(current.right, elements) end - # Time Complexity: - # Space Complexity: def inorder - return [] if @root.nil? + inorder_helper(current = @root, elements = []) + end + # Time Complexity: 0(n) with n being number of nodes in the tree + # Space Complexity: O(n) + def preorder_helper(current, elements) + return elements if current.nil? + elements << {:key => current.key, :value => current.value} + preorder_helper(current.left, elements) + preorder_helper(current.right, elements) end - # Time Complexity: - # Space Complexity: + def preorder - raise NotImplementedError + preorder_helper(current = @root, elements = []) + end + + # Time Complexity: 0(n) with n being number of nodes in the tree + # Space Complexity: O(n) + def postorder_helper(current, elements) + return elements if current.nil? + postorder_helper(current.left, elements) + postorder_helper(current.right, elements) + elements << {:key => current.key, :value => current.value} end - # Time Complexity: - # Space Complexity: def postorder - raise NotImplementedError + postorder_helper(current = @root, elements = []) end - # Time Complexity: - # Space Complexity: + # Time Complexity: O(n) + # Space Complexity: O(n) + def height_helper(current) + return 0 if current.nil? + return 1 + [height_helper(current.left), height_helper(current.right)].max + end + def height - raise NotImplementedError + height_helper(@root) end # Optional Method diff --git a/test/tree_test.rb b/test/tree_test.rb index 151029f..013df58 100644 --- a/test/tree_test.rb +++ b/test/tree_test.rb @@ -45,7 +45,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 @@ -57,7 +57,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 @@ -81,7 +81,7 @@ end end - xdescribe "height" do + describe "height" do it "will return 0 for an empty tree" do my_tree = Tree.new From 7c4849b5b84f46276ab3db733e312b719763e849 Mon Sep 17 00:00:00 2001 From: Anya Tokar Date: Sun, 18 Apr 2021 22:06:02 -0700 Subject: [PATCH 3/3] removed unnecessary helpers --- lib/tree.rb | 72 ++++++++++++++++------------------------------------- 1 file changed, 22 insertions(+), 50 deletions(-) diff --git a/lib/tree.rb b/lib/tree.rb index 4f263c5..9cf4a71 100644 --- a/lib/tree.rb +++ b/lib/tree.rb @@ -16,89 +16,61 @@ def initialize @root = nil end - # Time Complexity: O(log n) - # Space Complexity: O(1) - def add_helper(key, value, current) + # Time Complexity: O(log n) for a balanced tree, O(n) for an unbalanced tree + # Space Complexity: same as time complexity + def add(key, value = nil, current = @root) + return @root = TreeNode.new(key, value) if current.nil? if key <= current.key - current.left ? add_helper(key, value, current.left) : current.left = TreeNode.new(key, value) + current.left ? add(key, value, current.left) : current.left = TreeNode.new(key, value) else - current.right ? add_helper(key, value, current.right) : current.right = TreeNode.new(key, value) + current.right ? add(key, value, current.right) : current.right = TreeNode.new(key, value) end end - def add(key, value = nil) - if @root.nil? - @root = TreeNode.new(key, value) - return @root - end - add_helper(key, value, @root) - end - - # Time Complexity: O(log n) - # Space Complexity: O(1) - def find_helper(key, current) + # Time Complexity: O(log n) for a balanced tree, O(n) for an unbalanced tree + # Space Complexity: same as time complexity + def find(key, current = @root) return nil if current.nil? return current.value if current.key == key if key < current.key - find_helper(key, current.left) + find(key, current.left) else key > current.key - find_helper(key, current.right) + find(key, current.right) end end - def find(key) - find_helper(key, @root) - end - # Time Complexity: 0(n) with n being number of nodes in the tree # Space Complexity: O(n) - def inorder_helper(current, elements) + def inorder(current = @root, elements = []) return elements if current.nil? - inorder_helper(current.left, elements) + inorder(current.left, elements) elements << {:key => current.key, :value => current.value} - inorder_helper(current.right, elements) - end - - def inorder - inorder_helper(current = @root, elements = []) + inorder(current.right, elements) end # Time Complexity: 0(n) with n being number of nodes in the tree # Space Complexity: O(n) - def preorder_helper(current, elements) + def preorder(current = @root, elements = []) return elements if current.nil? elements << {:key => current.key, :value => current.value} - preorder_helper(current.left, elements) - preorder_helper(current.right, elements) - end - - - def preorder - preorder_helper(current = @root, elements = []) + preorder(current.left, elements) + preorder(current.right, elements) end # Time Complexity: 0(n) with n being number of nodes in the tree # Space Complexity: O(n) - def postorder_helper(current, elements) + def postorder(current = @root, elements = []) return elements if current.nil? - postorder_helper(current.left, elements) - postorder_helper(current.right, elements) + postorder(current.left, elements) + postorder(current.right, elements) elements << {:key => current.key, :value => current.value} end - def postorder - postorder_helper(current = @root, elements = []) - end - # Time Complexity: O(n) # Space Complexity: O(n) - def height_helper(current) + def height(current = @root) return 0 if current.nil? - return 1 + [height_helper(current.left), height_helper(current.right)].max - end - - def height - height_helper(@root) + return 1 + [height(current.left), height(current.right)].max end # Optional Method