Water@Hanh Solo - Tree practices

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

lib/tree.rb

@@ -2,61 +2,127 @@ 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
+    # we have access to @root-instance variable of class tree because the below methods are class methods
     @root = nil
   end
 
-  # Time Complexity: 
-  # Space Complexity: 
-  def add(key, value)
-    raise NotImplementedError
+  # Time Complexity: Olog(n)
+  # Space Complexity: O(1)
+  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
   end
 
-  # Time Complexity: 
-  # Space Complexity: 
+  # Time Complexity: O(n)
+  # Space Complexity: O(1)
   def find(key)
-    raise NotImplementedError
+    find_helper(key, @root)
   end
 
-  # Time Complexity: 
-  # Space Complexity: 
-  def inorder
-    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
 
-  # Time Complexity: 
-  # Space Complexity: 
-  def preorder
-    raise NotImplementedError
+  # Time Complexity: O(n)
+  # Space Complexity: O(1)
+  def inorder(current_node = @root, answer = [])
+    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)
+    end
+
+    return answer
   end
 
-  # Time Complexity: 
-  # Space Complexity: 
-  def postorder
-    raise NotImplementedError
+  # Time Complexity: O(n)
+  # Space Complexity: O(1)
+  def preorder(current_node = @root, answer = [])
+    return answer if current_node.nil?
+
+    answer.push({ key: current_node.key, value: current_node.value })
+    preorder(current_node.left, answer)
+    preorder(current_node.right, answer)
+
+    return answer
   end
 
-  # Time Complexity: 
-  # Space Complexity: 
-  def height
-    raise NotImplementedError
+  # Time Complexity: O(n)
+  # Space Complexity: O(1)
+  def postorder(current_node = @root, answer = [])
+    return answer if current_node.nil?
+
+    postorder(current_node.left, answer)
+    postorder(current_node.right, answer)
+    answer.push({ key: current_node.key, value: current_node.value })
+
+    return answer
+  end
+
+  # 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
+
+  def bfs_helper(current_node, answer)
+    return answer if current_node.nil?
   end
 
   # Useful for printing

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