From 61a95f5a50fbe047b0e401ef1742252bfefc5792 Mon Sep 17 00:00:00 2001
From: Antonia <antonianomamiukor@gmail.com>
Date: Thu, 3 Sep 2020 09:23:11 -0700
Subject: [PATCH] tests finally passing

---
 lib/tree.rb | 97 +++++++++++++++++++++++++++++++++++++++++++----------
 1 file changed, 79 insertions(+), 18 deletions(-)

diff --git a/lib/tree.rb b/lib/tree.rb
index c0d4b51..3722a48 100644
--- a/lib/tree.rb
+++ b/lib/tree.rb
@@ -16,40 +16,101 @@ def initialize
     @root = nil
   end
 
-  # Time Complexity: 
-  # Space Complexity: 
+  # Time Complexity: O(log n)
+  # Space Complexity: O(1)
+  def add_recursive(node, key, value)
+    return TreeNode.new(key, value) if node.nil?
+    if key < node.key
+      node.left = add_recursive(node.left, key, value)
+    else
+      node.right = add_recursive(node.right, key, value)
+    end
+    return node
+  end
+
   def add(key, value)
-    raise NotImplementedError
+    @root = add_recursive(@root, key, value)
+  end
+
+  # Time Complexity: O(log n)
+  # Space Complexity: O(1)
+  def find_recursive(node, key)
+    return node.value if node.key == key
+    
+    if key <= node.key
+      node.left = find_recursive(node.left, key)
+    else
+      node.right  = find_recursive(node.right, key)
+    end
   end
 
-  # Time Complexity: 
-  # Space Complexity: 
   def find(key)
-    raise NotImplementedError
+    current = @root
+    return nil if !current
+
+    return find_recursive(root, key)
+  end
+
+  # Time Complexity: O(n)
+  # Space Complexity: O(n)
+  def inorder_recursive(node, list)
+    return list if node.nil?
+    
+    inorder_recursive(node.left, list)
+    list << {key: node.key, value: node.value}
+    inorder_recursive(node.right, list)
   end
 
-  # Time Complexity: 
-  # Space Complexity: 
   def inorder
-    raise NotImplementedError
+    return inorder_recursive(@root, [])
+  end
+
+  # Time Complexity: O(n)
+  # Space Complexity: O(n)
+  def preorder_recursive(node, list)
+    return list if node.nil?
+
+    list << {key: node.key, value: node.value}
+    preorder_recursive(node.left, list)
+    preorder_recursive(node.right, list)
   end
 
-  # Time Complexity: 
-  # Space Complexity: 
   def preorder
-    raise NotImplementedError
+    return preorder_recursive(@root, [])
   end
 
-  # Time Complexity: 
-  # Space Complexity: 
+  # Time Complexity: O(n)
+  # Space Complexity: O(n)
+  def postorder_recursive(node, list)
+    return list if node.nil?
+
+    postorder_recursive(node.left, list)
+    postorder_recursive(node.right, list)
+    list << {key: node.key, value: node.value}
+  end
   def postorder
-    raise NotImplementedError
+    return postorder_recursive(@root, [])
+  end
+
+  # Time Complexity: O(n)
+  # Space Complexity: O(n
+  def height_recursive(node)
+    return 0 if node.nil?
+
+    left = height_recursive(node.left)
+    right = height_recursive(node.right)
+
+    if left > right
+     height = left
+    else
+      height = right
+    end
+    height += 1
+    return height
   end
 
-  # Time Complexity: 
-  # Space Complexity: 
   def height
-    raise NotImplementedError
+    return height_recursive(@root)
   end
 
   # Optional Method