From a37ad78ed32d2a871c19ac18b3b7bc1eb0d72b30 Mon Sep 17 00:00:00 2001 From: Hanh Solo Date: Sat, 1 May 2021 15:22:07 -0700 Subject: [PATCH 1/2] Tree practices --- lib/tree.rb | 122 +++++++++++++++++++++++++++++++++++++++++----------- 1 file changed, 96 insertions(+), 26 deletions(-) diff --git a/lib/tree.rb b/lib/tree.rb index c0d4b51..f2359c4 100644 --- a/lib/tree.rb +++ b/lib/tree.rb @@ -2,59 +2,129 @@ 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 attr_reader :root + def initialize @root = nil end - # Time Complexity: - # Space Complexity: + # Time Complexity: Olog(n) + # Space Complexity: O(1) def add(key, value) - raise NotImplementedError + new_node = TreeNode.new(key, value) + + if @root == nil + @root = new_node + else + current_node = @root + previouse_node = @root + + while current_node != nil + previouse_node = current_node + if key < current_node.key + current_node = current_node.left + else + current_node = current_node.right + end + + if key < previouse_node.key + previouse_node.left = new_node + else + previouse_node.right = new_node + end + end + + return new_node + end end - # Time Complexity: - # Space Complexity: + # Time Complexity: O(n) + # Space Complexity: O(1) def find(key) - raise NotImplementedError + def find_helper(key, current_node) + if current_node.nil? + return nil + elsif key == current_node.key + return current_node.value + elsif key < current_node.key + # look to the left + find_helper(key, current_node.left) + elsif key > current_node.key + # look to the right + find_helper(key, current_node.right) + end + end + + find_helper(key, @root) end - # Time Complexity: - # Space Complexity: - def inorder - raise NotImplementedError + # Time Complexity: O(n) + # Space Complexity: O(1) + def inorder(current_node = @root, answer = []) + return [] if current_node.nil? + + if current_node + inorder(current_node.left, answer) + answer.push({key: current_node.key, value: current_node.value}) + inorder(current_node.right) + end + + return answer end - # Time Complexity: - # Space Complexity: - def preorder - raise NotImplementedError + # Time Complexity: O(n) + # Space Complexity: O(1) + def preorder(current_node = @root, answer = []) + return [] if current_node.nil? + + answer.push({key: current_node.key, value: current_node.value}) + preorder(current_node.right, answer) + preorder(current_node.left) + + return answer end - # Time Complexity: - # Space Complexity: - def postorder - raise NotImplementedError + # Time Complexity: O(n) + # Space Complexity: O(1) + def postorder(current_node = @root, answer = []) + return [] if current_node.nil? + + postorder(current_node.left, answer) + postorder(current_node.right) + + answer.push({key: current_node.key, value: current_node.value}) + + return answer end - # Time Complexity: - # Space Complexity: - def height - raise NotImplementedError + # Time Complexity: O(n) + # Space Complexity: O(n) + def height(current_node = @root) + return 0 if current_node.nil? + + right_height = height(current_node.right) + left_height = height(current_node.left) + + if right_height < left_height + return left_height + 1 + else + return right_height + 1 + end + end # Optional Method - # Time Complexity: - # Space Complexity: + # Time Complexity: + # Space Complexity: def bfs raise NotImplementedError end From 387dd6baaccec73bcdf4fa218c6912de86aae5ed Mon Sep 17 00:00:00 2001 From: Hanh Solo Date: Tue, 6 Jul 2021 16:06:59 -0700 Subject: [PATCH 2/2] updated methods --- lib/add.rb | 62 ++++++++++++++++++++++++++++++++ lib/tree.rb | 90 ++++++++++++++++++++++------------------------- test/tree_test.rb | 31 ++++++++-------- 3 files changed, 119 insertions(+), 64 deletions(-) create mode 100644 lib/add.rb diff --git a/lib/add.rb b/lib/add.rb new file mode 100644 index 0000000..f3d4d07 --- /dev/null +++ b/lib/add.rb @@ -0,0 +1,62 @@ +def add(key, value = nil) + new_node = TreeNode.new(key, value) + if @root.nil? + @root = new_node + else + add_helper(@root, new_node) + end +end + +def add_helper(parent, new_node) + if parent.nil? + return new_node + end + + if new_node.key <= parent.key + # If left is nil, add new node to left, if not continue to evaluate. + parent.left.nil? ? parent.left = new_node : add_helper(parent.left, new_node) + else + parent.right.nil? ? parent.right = new_node : add_helper(parent.right, new_node) + end + + + + # if @root == nil + # @root = new_node + # else + # current_node = @root + # previous_node = @root + + # while current_node != nil + # previous_node = current_node + # if key <= current_node.key + # current_node = current_node.left + # else + # current_node = current_node.right + # end + + # if key < previous_node.key + # previous_node.left = new_node + # else + # previous_node.right = new_node + # end + # end + + # return new_node + # end +end + +def add(key, value = nil) + new_node = TreeNode.new(key, value) + + if @root == nil + @root = new_node + end + + current_node = @root + if new_node.key <= current_node.key + current_node.left.nil? ? current_node.left = new_node : add(current_node.left, new_node.value) + else + current_node.right.nil? ? current_node.right = new_node : add(current_node.right, new_node.value) + end +end \ No newline at end of file diff --git a/lib/tree.rb b/lib/tree.rb index f2359c4..2a92e9f 100644 --- a/lib/tree.rb +++ b/lib/tree.rb @@ -14,68 +14,63 @@ class Tree attr_reader :root def initialize + # we have access to @root-instance variable of class tree because the below methods are class methods @root = nil end # Time Complexity: Olog(n) # Space Complexity: O(1) - def add(key, value) + def add(key, value = nil) new_node = TreeNode.new(key, value) - - if @root == nil + if @root.nil? @root = new_node else - current_node = @root - previouse_node = @root - - while current_node != nil - previouse_node = current_node - if key < current_node.key - current_node = current_node.left - else - current_node = current_node.right - end - - if key < previouse_node.key - previouse_node.left = new_node - else - previouse_node.right = new_node - end - end + add_helper(@root, new_node) + end + end + def add_helper(parent, new_node) + if parent.nil? return new_node end + + if new_node.key <= parent.key + # If left is nil, add new node to left, if not continue to evaluate. + parent.left.nil? ? parent.left = new_node : add_helper(parent.left, new_node) + else + parent.right.nil? ? parent.right = new_node : add_helper(parent.right, new_node) + end end # Time Complexity: O(n) # Space Complexity: O(1) def find(key) - def find_helper(key, current_node) - if current_node.nil? - return nil - elsif key == current_node.key - return current_node.value - elsif key < current_node.key - # look to the left - find_helper(key, current_node.left) - elsif key > current_node.key - # look to the right - find_helper(key, current_node.right) - end - end - find_helper(key, @root) end - # Time Complexity: O(n) + def find_helper(key, current_node) + if current_node.nil? + return nil + elsif key == current_node.key + return current_node.value + elsif key < current_node.key + # look to the left + find_helper(key, current_node.left) + elsif key > current_node.key + # look to the right + find_helper(key, current_node.right) + end + end + + # Time Complexity: O(n) # Space Complexity: O(1) def inorder(current_node = @root, answer = []) - return [] if current_node.nil? + return answer if current_node.nil? if current_node inorder(current_node.left, answer) - answer.push({key: current_node.key, value: current_node.value}) - inorder(current_node.right) + answer.push({ key: current_node.key, value: current_node.value }) + inorder(current_node.right, answer) end return answer @@ -84,11 +79,11 @@ def inorder(current_node = @root, answer = []) # Time Complexity: O(n) # Space Complexity: O(1) def preorder(current_node = @root, answer = []) - return [] if current_node.nil? + return answer if current_node.nil? - answer.push({key: current_node.key, value: current_node.value}) + answer.push({ key: current_node.key, value: current_node.value }) + preorder(current_node.left, answer) preorder(current_node.right, answer) - preorder(current_node.left) return answer end @@ -96,12 +91,11 @@ def preorder(current_node = @root, answer = []) # Time Complexity: O(n) # Space Complexity: O(1) def postorder(current_node = @root, answer = []) - return [] if current_node.nil? + return answer if current_node.nil? postorder(current_node.left, answer) - postorder(current_node.right) - - answer.push({key: current_node.key, value: current_node.value}) + postorder(current_node.right, answer) + answer.push({ key: current_node.key, value: current_node.value }) return answer end @@ -119,14 +113,16 @@ def height(current_node = @root) else return right_height + 1 end - end # Optional Method # Time Complexity: # Space Complexity: def bfs - raise NotImplementedError + end + + def bfs_helper(current_node, answer) + return answer if current_node.nil? end # Useful for printing diff --git a/test/tree_test.rb b/test/tree_test.rb index 60f5981..49ed2bf 100644 --- a/test/tree_test.rb +++ b/test/tree_test.rb @@ -1,10 +1,9 @@ -require_relative 'test_helper' - +require_relative "test_helper" Minitest::Reporters.use! Minitest::Reporters::SpecReporter.new describe Tree do - let (:tree) {Tree.new} + let (:tree) { Tree.new } let (:tree_with_nodes) { tree.add(5, "Peter") @@ -37,23 +36,21 @@ 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"}] + 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"}] + 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 @@ -63,9 +60,9 @@ 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"}] + 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 @@ -75,9 +72,9 @@ 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"}] + 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