From 9764fa130a8d34e4808862d58ea117fb83cc3b79 Mon Sep 17 00:00:00 2001 From: Jillianne Ramirez Date: Thu, 12 Sep 2019 12:43:15 -0700 Subject: [PATCH 1/6] solutions to tree --- lib/tree.rb | 75 ++++++++++++++++++++++++++++++++++++++++++++++++----- 1 file changed, 69 insertions(+), 6 deletions(-) diff --git a/lib/tree.rb b/lib/tree.rb index c0d4b51..dd73452 100644 --- a/lib/tree.rb +++ b/lib/tree.rb @@ -19,31 +19,94 @@ def initialize # Time Complexity: # Space Complexity: def add(key, value) - raise NotImplementedError + new_node = TreeNode.new(key, value) + if @root == nil + @root = new_node + else + node = @root + add_value(node, new_node) + end + end + + def add_value(current, new_node) + if !current + current = new_node + elsif current.key < new_node.key + add_value(current.right, new_node) + else + add_value(current.left, new_node) + end end # Time Complexity: # Space Complexity: def find(key) - raise NotImplementedError + return nil if @head == nil + find_value(@head, key) + end + + def find_value(current, key) + if current.key == key + return current.value + elsif current.key > key + find_value(current.right, key) + else + find_value(current.left, key) + end end # Time Complexity: # Space Complexity: def inorder - raise NotImplementedError + return [] if @head == nil + return inorder_key(@head) + end + + def inorder_key(current_node) + values = [] + if !current_node + return values + else + inorder_key(current_node.left) + values << {key: current.key, value: current.value} + inorder_key(current_node.right) + end end # Time Complexity: # Space Complexity: def preorder - raise NotImplementedError + return [] if @head == nil + return preorder_key(@head) + end + + def preorder_key(current_node) + values = [] + if !current_node + return values + else + values << {key: current.key, value: current.value} + preorder_key(current_node.left) + preorder_key(current_node.right) + end end # Time Complexity: # Space Complexity: def postorder - raise NotImplementedError + return [] if @head == nil + return postorder_key(@head) + end + + def postorder_key(current_node) + values = [] + if !current_node + return values + else + postorder_key(current_node.left) + postorder_key(current_node.right) + values << {key: current.key, value: current.value} + end end # Time Complexity: @@ -63,4 +126,4 @@ def bfs def to_s return "#{self.inorder}" end -end +end \ No newline at end of file From 5927dc689aa4d2629b4ad360ea931106a92a7de5 Mon Sep 17 00:00:00 2001 From: Jillianne Ramirez Date: Thu, 19 Sep 2019 15:09:40 -0700 Subject: [PATCH 2/6] add and find value in binary search tree --- lib/tree.rb | 62 +++++++++++++++++++++++++++++++---------------------- 1 file changed, 36 insertions(+), 26 deletions(-) diff --git a/lib/tree.rb b/lib/tree.rb index dd73452..ccddbdc 100644 --- a/lib/tree.rb +++ b/lib/tree.rb @@ -20,57 +20,66 @@ def initialize # Space Complexity: def add(key, value) new_node = TreeNode.new(key, value) - if @root == nil + if !@root @root = new_node else - node = @root - add_value(node, new_node) + add_value(@root, new_node) end end + # TODO: Refactor solution with loop def add_value(current, new_node) - if !current - current = new_node - elsif current.key < new_node.key - add_value(current.right, new_node) + if current.key < new_node.key + if current.right + add_value(current.right, new_node) + else + current.right = new_node + end else - add_value(current.left, new_node) + if current.left + add_value(current.left, new_node) + else + current.left = new_node + end end end # Time Complexity: # Space Complexity: def find(key) - return nil if @head == nil - find_value(@head, key) - end + return nil if !@root - def find_value(current, key) - if current.key == key - return current.value - elsif current.key > key - find_value(current.right, key) - else - find_value(current.left, key) + current = @root + + while current + return current.value if current.key == key + + if current.key < key + current = current.right + else + current = current.left + end end + return nil end # Time Complexity: # Space Complexity: def inorder - return [] if @head == nil - return inorder_key(@head) + return [] if !@head + values = [] + return inorder_key(@head, values) end - def inorder_key(current_node) - values = [] + def inorder_key(current_node, array) if !current_node - return values + return array else inorder_key(current_node.left) - values << {key: current.key, value: current.value} + varray << {key: current_node.key, value: current_node.value} inorder_key(current_node.right) end + return end # Time Complexity: @@ -95,7 +104,7 @@ def preorder_key(current_node) # Space Complexity: def postorder return [] if @head == nil - return postorder_key(@head) + postorder_key(@head) end def postorder_key(current_node) @@ -105,8 +114,9 @@ def postorder_key(current_node) else postorder_key(current_node.left) postorder_key(current_node.right) - values << {key: current.key, value: current.value} + values << {key: current_node.key, value: current_node.value} end + return values end # Time Complexity: From 0356b58d3ebcd3103a9b0638d5fb50235d3921fa Mon Sep 17 00:00:00 2001 From: Jillianne Ramirez Date: Sun, 22 Sep 2019 12:06:39 -0700 Subject: [PATCH 3/6] add and find key --- lib/tree.rb | 39 +++++++++++++++++++-------------------- 1 file changed, 19 insertions(+), 20 deletions(-) diff --git a/lib/tree.rb b/lib/tree.rb index ccddbdc..7681dc7 100644 --- a/lib/tree.rb +++ b/lib/tree.rb @@ -16,30 +16,29 @@ def initialize @root = nil end - # Time Complexity: - # Space Complexity: + # Time Complexity: O(log n) - side eliminated + # Space Complexity: O(1) def add(key, value) new_node = TreeNode.new(key, value) + if !@root @root = new_node else - add_value(@root, new_node) - end - end - - # TODO: Refactor solution with loop - def add_value(current, new_node) - if current.key < new_node.key - if current.right - add_value(current.right, new_node) - else - current.right = new_node - end - else - if current.left - add_value(current.left, new_node) - else - current.left = new_node + current = @root + until !current + if current.key < new_node.key + if current.right + current = current.right + else + return current.right = new_node + end + else + if current.left + current = current.left + else + return current.left = new_node + end + end end end end @@ -51,7 +50,7 @@ def find(key) current = @root - while current + until !current return current.value if current.key == key if current.key < key From 3189a8c38aba09d39b14e9886c45a1f0430e0cf1 Mon Sep 17 00:00:00 2001 From: Jillianne Ramirez Date: Sun, 22 Sep 2019 13:08:33 -0700 Subject: [PATCH 4/6] preorder, inorder, postorder --- lib/tree.rb | 60 +++++++++++++++++++++++------------------------ test/tree_test.rb | 25 ++++++++++---------- 2 files changed, 42 insertions(+), 43 deletions(-) diff --git a/lib/tree.rb b/lib/tree.rb index 7681dc7..3f75818 100644 --- a/lib/tree.rb +++ b/lib/tree.rb @@ -43,8 +43,8 @@ def add(key, value) end end - # Time Complexity: - # Space Complexity: + # Time Complexity: O(log n) - side eliminated + # Space Complexity: O(1) def find(key) return nil if !@root @@ -62,60 +62,58 @@ def find(key) return nil end - # Time Complexity: - # Space Complexity: + # Time Complexity: O(n) - all nodes visited + # Space Complexity: O(n) - array size based on node amount def inorder - return [] if !@head + return [] if !@root values = [] - return inorder_key(@head, values) + inorder_key(@root, values) end def inorder_key(current_node, array) if !current_node return array else - inorder_key(current_node.left) - varray << {key: current_node.key, value: current_node.value} - inorder_key(current_node.right) + inorder_key(current_node.left, array) + array << {key: current_node.key, value: current_node.value} + inorder_key(current_node.right, array) end - return end - # Time Complexity: - # Space Complexity: + # Time Complexity: O(n) - all nodes visited + # Space Complexity: O(n) - array size based on node amount def preorder - return [] if @head == nil - return preorder_key(@head) + return [] if !@root + values = [] + preorder_key(@root, values) end - def preorder_key(current_node) - values = [] + def preorder_key(current_node, array) if !current_node - return values + return array else - values << {key: current.key, value: current.value} - preorder_key(current_node.left) - preorder_key(current_node.right) + array << {key: current_node.key, value: current_node.value} + preorder_key(current_node.left, array) + preorder_key(current_node.right, array) end end - # Time Complexity: - # Space Complexity: + # Time Complexity: O(n) - all nodes visited + # Space Complexity: O(n) - array size based on node amount def postorder - return [] if @head == nil - postorder_key(@head) + return [] if !@root + values = [] + postorder_key(@root, values) end - def postorder_key(current_node) - values = [] + def postorder_key(current_node, array) if !current_node - return values + return array else - postorder_key(current_node.left) - postorder_key(current_node.right) - values << {key: current_node.key, value: current_node.value} + postorder_key(current_node.left, array) + postorder_key(current_node.right, array) + array << {key: current_node.key, value: current_node.value} end - return values end # Time Complexity: diff --git a/test/tree_test.rb b/test/tree_test.rb index 8811f14..3761b09 100644 --- a/test/tree_test.rb +++ b/test/tree_test.rb @@ -32,6 +32,7 @@ end describe "inorder" do + it "will give an empty array for an empty tree" do expect(tree.inorder).must_equal [] end @@ -44,8 +45,8 @@ end end - describe "preorder" do + it "will give an empty array for an empty tree" do expect(tree.preorder).must_equal [] end @@ -69,15 +70,15 @@ 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 "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 end \ No newline at end of file From 0a416cd1d5b6620f3ea4216980f999fecfffba05 Mon Sep 17 00:00:00 2001 From: Jillianne Ramirez Date: Sun, 22 Sep 2019 13:31:54 -0700 Subject: [PATCH 5/6] height of tree & tests for height --- lib/tree.rb | 19 ++++++++++++++++--- test/tree_test.rb | 32 +++++++++++++++++++++----------- 2 files changed, 37 insertions(+), 14 deletions(-) diff --git a/lib/tree.rb b/lib/tree.rb index 3f75818..eacb459 100644 --- a/lib/tree.rb +++ b/lib/tree.rb @@ -116,10 +116,23 @@ def postorder_key(current_node, array) end end - # Time Complexity: - # Space Complexity: + # Time Complexity: O(n) - possible to visit each node + # Space Complexity: O(1) def height - raise NotImplementedError + return 0 if !@root + height_helper(@root) + end + + def height_helper(current) + return 0 if !current + left = height_helper(current.left) + right = height_helper(current.right) + + if left < right + return right + 1 + else + return left + 1 + end end # Optional Method diff --git a/test/tree_test.rb b/test/tree_test.rb index 3761b09..15fb9ef 100644 --- a/test/tree_test.rb +++ b/test/tree_test.rb @@ -70,15 +70,25 @@ 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 give height of 0 if empty tree" do + expect(tree.height).must_equal 0 + end + + it "will return height value for non-empty 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 + 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 end \ No newline at end of file From ab4bef0bee660e8aac8e3a8dc45839d2e195cc6b Mon Sep 17 00:00:00 2001 From: Jillianne Ramirez Date: Sun, 22 Sep 2019 18:00:26 -0700 Subject: [PATCH 6/6] breadth first search --- lib/tree.rb | 27 ++++++++++++++++++++++++--- 1 file changed, 24 insertions(+), 3 deletions(-) diff --git a/lib/tree.rb b/lib/tree.rb index eacb459..63cbeed 100644 --- a/lib/tree.rb +++ b/lib/tree.rb @@ -136,10 +136,31 @@ def height_helper(current) end # Optional Method - # Time Complexity: - # Space Complexity: + # Time Complexity: O(n) - all nodes visited + # Space Complexity: O(n) - array size based on size of tree def bfs - raise NotImplementedError + return [] if !@root + + values = [{key: @root.key, value: @root.value}] + bfs_helper(@root, values) + end + + def bfs_helper(current, array) + if current.left + array << {key: current.left.key, value: current.left.value} + end + if current.right + array << {key: current.right.key, value: current.right.value} + end + if !current.left && !current.right + return array + end + if current.left + bfs_helper(current.left, array) + end + if current.right + bfs_helper(current.right, array) + end end # Useful for printing