From 58fbe7801a90829899f4e6026af608454351392f Mon Sep 17 00:00:00 2001
From: Alexandria McCarthy <alexandria.mccarthy77@gmail.com>
Date: Thu, 22 Aug 2019 16:29:09 -0700
Subject: [PATCH 1/6] wrote add and find methods to make tests pass

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

diff --git a/lib/tree.rb b/lib/tree.rb
index c0d4b51..0a3f910 100644
--- a/lib/tree.rb
+++ b/lib/tree.rb
@@ -2,59 +2,81 @@ 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:
+  # Space Complexity:
   def add(key, value)
-    raise NotImplementedError
+    new_tree_node = TreeNode.new(key, value)
+
+    # if @root.nil?
+      @root = new_tree_node
+    # else
+    #   current = @root
+
+    #   while !current.left.value.nil? || !current.right.value.nil?
+
+    #   end
+    # end 
   end
 
-  # Time Complexity: 
-  # Space Complexity: 
+  # Time Complexity:
+  # Space Complexity:
   def find(key)
-    raise NotImplementedError
+    return nil if @root.nil?
+
+    current = @root
+    until current.key == key
+      if key > current.key
+        current = current.right
+      else 
+        current = current.left
+      end 
+    end 
+
+    return current.value
   end
 
-  # Time Complexity: 
-  # Space Complexity: 
+  # Time Complexity:
+  # Space Complexity:
   def inorder
     raise NotImplementedError
   end
 
-  # Time Complexity: 
-  # Space Complexity: 
+  # Time Complexity:
+  # Space Complexity:
   def preorder
     raise NotImplementedError
   end
 
-  # Time Complexity: 
-  # Space Complexity: 
+  # Time Complexity:
+  # Space Complexity:
   def postorder
     raise NotImplementedError
   end
 
-  # Time Complexity: 
-  # Space Complexity: 
+  # Time Complexity:
+  # Space Complexity:
   def height
     raise NotImplementedError
   end
 
   # Optional Method
-  # Time Complexity: 
-  # Space Complexity: 
+  # Time Complexity:
+  # Space Complexity:
   def bfs
     raise NotImplementedError
   end

From 0d4e1eb6b8c333eb562d17bc9357fc45c7fb673e Mon Sep 17 00:00:00 2001
From: Alexandria McCarthy <alexandria.mccarthy77@gmail.com>
Date: Mon, 2 Sep 2019 11:06:35 -0700
Subject: [PATCH 2/6] wrote add and find methods to make tests pass

---
 lib/tree.rb | 57 ++++++++++++++++++++++++++++++++++-------------------
 1 file changed, 37 insertions(+), 20 deletions(-)

diff --git a/lib/tree.rb b/lib/tree.rb
index 0a3f910..8159c62 100644
--- a/lib/tree.rb
+++ b/lib/tree.rb
@@ -17,55 +17,72 @@ def initialize
     @root = nil
   end
 
-  # Time Complexity:
-  # Space Complexity:
+  # Time Complexity: O(n) where n is the height of the tree
+  #                   or O(log n) if the tree is balanced
+  # Space Complexity: O(1)
   def add(key, value)
     new_tree_node = TreeNode.new(key, value)
 
-    # if @root.nil?
+    if @root.nil?
       @root = new_tree_node
-    # else
-    #   current = @root
-
-    #   while !current.left.value.nil? || !current.right.value.nil?
-
-    #   end
-    # end 
+    else
+      current = @root
+      while current
+        if new_tree_node.key <= current.key
+          if !current.left
+            current.left = new_tree_node
+            return
+          else
+            current = current.left
+          end
+        else
+          if !current.right
+            current.right = new_tree_node
+            return
+          else
+            current = current.right
+          end
+        end
+      end
+    end
   end
 
-  # Time Complexity:
-  # Space Complexity:
+  # Time Complexity: O(log n) if tree is balanced, n is size of tree
+  #                   O(n) in worst case where n is also size of tree
+  # Space Complexity: O(1)
   def find(key)
     return nil if @root.nil?
 
     current = @root
-    until current.key == key
+    while current
       if key > current.key
         current = current.right
-      else 
+      elsif key < current.key
         current = current.left
-      end 
-    end 
+      else
+        return current.value
+      end
+    end
 
-    return current.value
+    return nil
   end
 
   # Time Complexity:
   # Space Complexity:
   def inorder
-    raise NotImplementedError
+    return [] if @root.nil?
   end
 
   # Time Complexity:
   # Space Complexity:
   def preorder
-    raise NotImplementedError
+    return [] if @root.nil?
   end
 
   # Time Complexity:
   # Space Complexity:
   def postorder
-    raise NotImplementedError
+    return [] if @root.nil?
   end
 
   # Time Complexity:

From 65724222b78822e1e246ef0f69cc843729ed6a60 Mon Sep 17 00:00:00 2001
From: Alexandria McCarthy <alexandria.mccarthy77@gmail.com>
Date: Mon, 2 Sep 2019 11:16:32 -0700
Subject: [PATCH 3/6] wrote inorder method to make tests pass

---
 lib/tree.rb | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/lib/tree.rb b/lib/tree.rb
index 8159c62..99de46a 100644
--- a/lib/tree.rb
+++ b/lib/tree.rb
@@ -70,7 +70,21 @@ def find(key)
   # Time Complexity:
   # Space Complexity:
   def inorder
+    array = []
     return [] if @root.nil?
+    current = @root
+
+    return inorder_helper(current, array)
+  end
+
+  def inorder_helper(current, array)
+    if !current
+      return array
+    else
+      inorder_helper(current.left, array)
+      array << {:key => current.key, :value => current.value}
+      inorder_helper(current.right, array)
+    end
   end
 
   # Time Complexity:

From 8cf639b94d03533e22ac8651112477c93745934d Mon Sep 17 00:00:00 2001
From: Alexandria McCarthy <alexandria.mccarthy77@gmail.com>
Date: Mon, 2 Sep 2019 11:20:43 -0700
Subject: [PATCH 4/6] wrote preorder method to make tests pass

---
 lib/tree.rb | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/lib/tree.rb b/lib/tree.rb
index 99de46a..8cf71df 100644
--- a/lib/tree.rb
+++ b/lib/tree.rb
@@ -90,7 +90,21 @@ def inorder_helper(current, array)
   # Time Complexity:
   # Space Complexity:
   def preorder
+    array = []
     return [] if @root.nil?
+    current = @root
+
+    return preorder_helper(current, array)
+  end
+
+  def preorder_helper(current, array)
+    if !current
+      return array
+    else
+      array << {:key => current.key, :value => current.value}
+      preorder_helper(current.left, array)
+      preorder_helper(current.right, array)
+    end
   end
 
   # Time Complexity:

From 56a905c1f6ec2ee2cb17a521fe7f8010807ee4d2 Mon Sep 17 00:00:00 2001
From: Alexandria McCarthy <alexandria.mccarthy77@gmail.com>
Date: Mon, 2 Sep 2019 11:23:46 -0700
Subject: [PATCH 5/6] wrote postorder method to make tests pass

---
 lib/tree.rb | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/lib/tree.rb b/lib/tree.rb
index 8cf71df..7e33726 100644
--- a/lib/tree.rb
+++ b/lib/tree.rb
@@ -110,7 +110,21 @@ def preorder_helper(current, array)
   # Time Complexity:
   # Space Complexity:
   def postorder
+    array = []
     return [] if @root.nil?
+    current = @root
+
+    return postorder_helper(current, array)
+  end
+
+  def postorder_helper(current, array)
+    if !current
+      return array
+    else
+      postorder_helper(current.left, array)
+      postorder_helper(current.right, array)
+      array << {:key => current.key, :value => current.value}
+    end
   end
 
   # Time Complexity:

From 8598a33152a12c50959155c5df10a21dd6b20adf Mon Sep 17 00:00:00 2001
From: Alexandria McCarthy <alexandria.mccarthy77@gmail.com>
Date: Mon, 2 Sep 2019 12:11:07 -0700
Subject: [PATCH 6/6] wrote height function'

---
 lib/tree.rb       | 60 ++++++++++++++++++++++++++++++-----------------
 test/tree_test.rb | 33 ++++++++++++--------------
 2 files changed, 53 insertions(+), 40 deletions(-)

diff --git a/lib/tree.rb b/lib/tree.rb
index 7e33726..7fcea83 100644
--- a/lib/tree.rb
+++ b/lib/tree.rb
@@ -67,77 +67,93 @@ def find(key)
     return nil
   end
 
-  # Time Complexity:
-  # Space Complexity:
+  # Time Complexity: O(n) where n is the height of the tree
+  # Space Complexity: O(n) where n is the height of the tree
+  #                   potentially O(n^2) with the arrays?
   def inorder
     array = []
     return [] if @root.nil?
     current = @root
 
-    return inorder_helper(current, array)
+    return inorder_recursive(current, array)
   end
 
-  def inorder_helper(current, array)
+  def inorder_recursive(current, array)
     if !current
       return array
     else
-      inorder_helper(current.left, array)
+      inorder_recursive(current.left, array)
       array << {:key => current.key, :value => current.value}
-      inorder_helper(current.right, array)
+      inorder_recursive(current.right, array)
     end
   end
 
-  # Time Complexity:
-  # Space Complexity:
+  # Time Complexity: O(n) where n is the height of the tree
+  # Space Complexity: O(n) where n is the height of the tree
   def preorder
     array = []
     return [] if @root.nil?
     current = @root
 
-    return preorder_helper(current, array)
+    return preorder_recursive(current, array)
   end
 
-  def preorder_helper(current, array)
+  def preorder_recursive(current, array)
     if !current
       return array
     else
       array << {:key => current.key, :value => current.value}
-      preorder_helper(current.left, array)
-      preorder_helper(current.right, array)
+      preorder_recursive(current.left, array)
+      preorder_recursive(current.right, array)
     end
   end
 
-  # Time Complexity:
-  # Space Complexity:
+  # Time Complexity: O(n) where n is the height of the tree
+  # Space Complexity: O(n) where n is the height of the tree
   def postorder
     array = []
     return [] if @root.nil?
     current = @root
 
-    return postorder_helper(current, array)
+    return postorder_recursive(current, array)
   end
 
-  def postorder_helper(current, array)
+  def postorder_recursive(current, array)
     if !current
       return array
     else
-      postorder_helper(current.left, array)
-      postorder_helper(current.right, array)
+      postorder_recursive(current.left, array)
+      postorder_recursive(current.right, array)
       array << {:key => current.key, :value => current.value}
     end
   end
 
-  # Time Complexity:
-  # Space Complexity:
+  # Time Complexity: O(n) where n is the size of the tree
+  # Space Complexity: O(n)
   def height
-    raise NotImplementedError
+    return 0 if @root.nil?
+    current = @root
+    height_recursive(current)
+  end
+
+  def height_recursive(current)
+    return 0 if current.nil?
+
+    left_side = height_recursive(current.left)
+    right_side = height_recursive(current.right)
+
+    if left_side < right_side
+      return (right_side + 1)
+    else
+      return (left_side + 1)
+    end
   end
 
   # Optional Method
   # Time Complexity:
   # Space Complexity:
   def bfs
-    raise NotImplementedError
+    return [] if @root.nil?
   end
 
   # Useful for printing
diff --git a/test/tree_test.rb b/test/tree_test.rb
index 8811f14..b4d8737 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
-end
\ No newline at end of file
+end