From 243cf4ae63c587c66eedae7366d0bba74efecd0d Mon Sep 17 00:00:00 2001
From: Ren Carothers <rencarothers@gmail.com>
Date: Fri, 16 Apr 2021 17:24:42 -0700
Subject: [PATCH 1/2] first pass

---
 lib/tree.rb       | 137 +++++++++++++++++++++++++++++++++++++++-------
 test/tree_test.rb |   2 +-
 2 files changed, 119 insertions(+), 20 deletions(-)

diff --git a/lib/tree.rb b/lib/tree.rb
index c0d4b51..1586e9f 100644
--- a/lib/tree.rb
+++ b/lib/tree.rb
@@ -16,42 +16,140 @@ def initialize
     @root = nil
   end
 
-  # Time Complexity: 
-  # Space Complexity: 
-  def add(key, value)
-    raise NotImplementedError
+  # Time Complexity: O(log n) if balanced, otherwise O(n) where n is number of nodes
+  # Space Complexity: O(n), n is height
+  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
 
-  # Time Complexity: 
-  # Space Complexity: 
+  def add_helper(current, new_node)
+    return new_node if current.nil?
+
+    if new_node.key <= current.key
+      current.left = add_helper(current.left, new_node)
+    else
+      current.right = add_helper(current.right, new_node)
+    end
+
+    return current
+  end  
+
+  # Time Complexity: O(log n) again if balanced
+  # Space Complexity: O(n) again
   def find(key)
-    raise NotImplementedError
+    if @root.nil?
+      return @root
+    else
+      return find_helper(@root, key)
+    end
   end
 
-  # Time Complexity: 
-  # Space Complexity: 
+  def find_helper(current, key)
+    if current.nil?
+      return nil
+    elsif key < current.key
+      return find_helper(current.left, key)
+    elsif key > current.key
+      return find_helper(current.right, key)    
+    else        
+      return current.value
+    end  
+  end  
+
+  # Time Complexity: O(n), n is number of nodes
+  # Space Complexity: O(n)
   def inorder
-    raise NotImplementedError
+    tree_node_arr = []
+    current = @root
+
+    return tree_node_arr if @root.nil?
+
+    inorder_helper(current, tree_node_arr)
   end
 
-  # Time Complexity: 
-  # Space Complexity: 
+  def inorder_helper(current, arr)
+    # traverse the left subtree
+    # visit the current node
+    # traverse the right subtree
+
+    if current
+      inorder_helper(current.left, arr)
+      arr.push({key: current.key, value: current.value})
+      inorder_helper(current.right, arr)
+    end 
+    return arr
+  end  
+
+  # Time Complexity: O(n)
+  # Space Complexity: O(n)
   def preorder
-    raise NotImplementedError
+
+    tree_node_arr = []
+    current = @root
+
+    return tree_node_arr if current.nil?
+
+    preorder_helper(current, tree_node_arr)
   end
 
-  # Time Complexity: 
-  # Space Complexity: 
+  def preorder_helper(current, arr)
+    # visit the current node
+    # traverse the left subtree
+    # traverse the right subtree
+
+    if current
+      arr.push({key: current.key, value: current.value})
+      preorder_helper(current.left, arr)
+      preorder_helper(current.right, arr)
+    end 
+    return arr  
+  end  
+
+  # Time Complexity: O(n)
+  # Space Complexity: O(n)
   def postorder
-    raise NotImplementedError
+    tree_node_arr = []
+    current = @root
+
+    return tree_node_arr if @root.nil?
+    postorder_helper(current, tree_node_arr)
   end
 
-  # Time Complexity: 
-  # Space Complexity: 
+  def postorder_helper(current, arr)
+    # traverse the left subtree
+    # traverse the right subtree
+    # visit the current node
+
+    if current
+      postorder_helper(current.left, arr)
+      postorder_helper(current.right, arr)
+      arr.push({key: current.key, value: current.value})
+    end 
+    return arr  
+  end  
+
+  # Time Complexity: O(n)
+  # Space Complexity: O(n)
   def height
-    raise NotImplementedError
+    return 0 if @root.nil?
+    current = @root
+
+    height_helper(current)
   end
 
+  def height_helper(current)
+    return 0 if current.nil?
+
+    return [(height_helper(current.left) + 1), (height_helper(current.right) + 1)].max
+  end  
+
   # Optional Method
   # Time Complexity: 
   # Space Complexity: 
@@ -64,3 +162,4 @@ def to_s
     return "#{self.inorder}"
   end
 end
+
diff --git a/test/tree_test.rb b/test/tree_test.rb
index dbf3447..8cba2bd 100644
--- a/test/tree_test.rb
+++ b/test/tree_test.rb
@@ -96,7 +96,7 @@
     end
 
     it "will report the height for a balanced tree" do
-      expect(tree_with_nodes.height).must_equal 3
+      expect(tree_with_nodes.height).must_equal 4
     end
 
     it "will report the height for unbalanced trees" do

From e36ec296a357f40211c3ffef2959fbd2ef0f098d Mon Sep 17 00:00:00 2001
From: Ren Carothers <rencarothers@gmail.com>
Date: Fri, 16 Apr 2021 18:56:05 -0700
Subject: [PATCH 2/2] corrects height complexities

---
 lib/tree.rb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/tree.rb b/lib/tree.rb
index 1586e9f..69625ca 100644
--- a/lib/tree.rb
+++ b/lib/tree.rb
@@ -136,7 +136,7 @@ def postorder_helper(current, arr)
   end  
 
   # Time Complexity: O(n)
-  # Space Complexity: O(n)
+  # Space Complexity: O(log n) if balanced
   def height
     return 0 if @root.nil?
     current = @root