From 00eb5fc6643ea9698038ebf521cfe8a6d81103fb Mon Sep 17 00:00:00 2001
From: dnguye2 <dnguyen1093@gmail.com>
Date: Mon, 7 Sep 2020 20:44:18 -0700
Subject: [PATCH 1/2] all Tree class methods completed

---
 lib/tree.rb | 99 ++++++++++++++++++++++++++++++++++++++++-------------
 1 file changed, 75 insertions(+), 24 deletions(-)

diff --git a/lib/tree.rb b/lib/tree.rb
index c0d4b51..b4c53a6 100644
--- a/lib/tree.rb
+++ b/lib/tree.rb
@@ -2,54 +2,105 @@ class TreeNode
   attr_reader :key, :value
   attr_accessor :left, :right
 
-   def initialize(key, val)
-    @key = key
-    @value = val
-    @left = nil
-    @right = nil
-   end
-end
-
-class Tree
-  attr_reader :root
-  def initialize
-    @root = nil
+    def initialize(key, val)
+      @key = key
+      @value = val
+      @left = nil
+      @right = nil
+    end
   end
+  
+  class Tree
+    attr_reader :root
+    def initialize
+      @root = nil
+    end
+    
+    # Time Complexity: 
+    # Space Complexity: 
+    def add(key, value)
+      if @root.nil?
+        @root = TreeNode.new(key, value)
+      else
+        self.add_helper(@root, key, value)
+      end
+    end
 
+    def add_helper(node, new_key, new_value)
+      if new_key <= node.key
+        node.left.nil? ? node.left = TreeNode.new(new_key, new_value) : add_helper(node.left, new_key, new_value)
+      else
+        node.right.nil? ? node.right = TreeNode.new(new_key, new_value) : add_helper(node.right, new_key, new_value)
+      end
+    end
+    
   # Time Complexity: 
   # Space Complexity: 
-  def add(key, value)
-    raise NotImplementedError
-  end
+  def find(key, node=@root)
+    return nil if @root.nil?
 
-  # Time Complexity: 
-  # Space Complexity: 
-  def find(key)
-    raise NotImplementedError
+    if key < node.key
+      find(key, node.left)
+    elsif key > node.key
+      find(key, node.right)
+    else
+      return node.value
+    end
   end
 
+
   # Time Complexity: 
   # Space Complexity: 
   def inorder
-    raise NotImplementedError
+    return inorder_helper(@root, [])
+  end
+
+  def inorder_helper(node, array)
+    return array if node.nil?
+
+    inorder_helper(node.left, array)
+    array << {:key=>node.key, :value=>node.value}
+    inorder_helper(node.right, array)
+
+    return array
   end
 
   # Time Complexity: 
   # Space Complexity: 
   def preorder
-    raise NotImplementedError
+    return preorder_helper(@root, [])
+  end
+
+  def preorder_helper(node, array)
+    return [] if node.nil?
+
+    array << {:key=>node.key, :value=>node.value}
+    preorder_helper(node.left, array)
+    preorder_helper(node.right, array)
+
+    return array
   end
 
   # Time Complexity: 
   # Space Complexity: 
   def postorder
-    raise NotImplementedError
+    return postorder_helper(@root, [])
+  end
+
+  def postorder_helper(node, array)
+    return [] if node.nil?
+
+    postorder_helper(node.left, array)
+    postorder_helper(node.right, array)
+    array << {:key=>node.key, :value=>node.value}
+
+    return array
   end
 
   # Time Complexity: 
   # Space Complexity: 
-  def height
-    raise NotImplementedError
+  def height(node=@root)
+    node.nil? ? 0 : (1 + [height(node.right), height(node.left)].max)
   end
 
   # Optional Method

From eb8ee8871bb791bef13dafd08d8813715508775b Mon Sep 17 00:00:00 2001
From: dnguye2 <dnguyen1093@gmail.com>
Date: Wed, 9 Sep 2020 01:00:48 -0700
Subject: [PATCH 2/2] time and space complexities added

---
 lib/tree.rb | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/lib/tree.rb b/lib/tree.rb
index b4c53a6..6a1bef2 100644
--- a/lib/tree.rb
+++ b/lib/tree.rb
@@ -16,8 +16,8 @@ def initialize
       @root = nil
     end
     
-    # Time Complexity: 
-    # Space Complexity: 
+  # Time Complexity: worst case unbalanced-O(n), bal-O(log n)
+  # Space Complexity: worst case-O(n), bal-O(log n)
     def add(key, value)
       if @root.nil?
         @root = TreeNode.new(key, value)
@@ -34,8 +34,8 @@ def add_helper(node, new_key, new_value)
       end
     end
     
-  # Time Complexity: 
-  # Space Complexity: 
+  # Time Complexity: unbal-O(n), bal-O(log n)
+  # Space Complexity: unbal-O(n), bal-O(log n)
   def find(key, node=@root)
     return nil if @root.nil?
 
@@ -49,8 +49,8 @@ def find(key, node=@root)
   end
 
 
-  # Time Complexity: 
-  # Space Complexity: 
+  # Time Complexity: O(n)
+  # Space Complexity: O(n)
   def inorder
     return inorder_helper(@root, [])
   end
@@ -65,8 +65,8 @@ def inorder_helper(node, array)
     return array
   end
 
-  # Time Complexity: 
-  # Space Complexity: 
+  # Time Complexity: O(n)
+  # Space Complexity: O(n)
   def preorder
     return preorder_helper(@root, [])
   end
@@ -81,8 +81,8 @@ def preorder_helper(node, array)
     return array
   end
 
-  # Time Complexity: 
-  # Space Complexity: 
+  # Time Complexity: O(n)
+  # Space Complexity: O(n)
   def postorder
     return postorder_helper(@root, [])
   end
@@ -97,8 +97,8 @@ def postorder_helper(node, array)
     return array
   end
 
-  # Time Complexity: 
-  # Space Complexity: 
+  # Time Complexity: O(n)
+  # Space Complexity: O(1)
   def height(node=@root)
     node.nil? ? 0 : (1 + [height(node.right), height(node.left)].max)
   end