From c72dda7aeeb046fd3ec504052231cd9bb11535a0 Mon Sep 17 00:00:00 2001
From: Erika Dawn <erika@Erikas-MacBook-Pro.local>
Date: Wed, 26 Feb 2020 21:17:15 -0800
Subject: [PATCH 1/8] From work comp

---
 lib/tree.rb | 210 ++++++++++++++++++++++++++++++++++++----------------
 1 file changed, 148 insertions(+), 62 deletions(-)

diff --git a/lib/tree.rb b/lib/tree.rb
index c0d4b51..44e56dd 100644
--- a/lib/tree.rb
+++ b/lib/tree.rb
@@ -1,66 +1,152 @@
-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
+  class TreeNode
+    attr_reader :key, :value
+    attr_accessor :left, :right
+  
+     def initialize(key, val)
+      @key = key
+      @value = val
+      @left = nil
+      @right = nil
+     end
   end
-
-  # Time Complexity: 
-  # Space Complexity: 
-  def add(key, value)
-    raise NotImplementedError
+  
+  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
+          current = @root
+          while true
+              if key < current.key
+                  if !current.left.nil?
+                      current = current.left
+                  else
+                      current.left = TreeNode.new(key,value)
+                  end
+              else
+                  if !@current.right.nil?
+                      current = current.right
+                  else
+                      current.right = TreeNode.new(key,value)
+                  end
+              end
+          end
+      end
+    end
+  
+    # Time Complexity: Because it's recursive I want to say O log(n)
+    # Space Complexity: O log (n) if it's balanced, and I guess O(n) if it isn't
+    def find(key)
+      find_helper(@root, key)
+    end
+  
+    def find_helper(current_node, key)
+      return nil if current_node.nil?
+      return current_node.value if current_node.key == key
+  
+      if key < current_node.key
+          return find_helper(current_node.left, key)
+      elsif
+          key > current_node.key
+          return find_helper(current_node.right, key)
+      end
   end
-
-  # Time Complexity: 
-  # Space Complexity: 
-  def find(key)
-    raise NotImplementedError
+  
+  
+    # Time Complexity: I think time and space are both O(n)?
+    # Space Complexity: 
+    def inorder
+      return inorder_helper(@root, [])
+    end
+  
+    def inorder_helper(current_node, list)
+      return list if current_node.nil?
+  
+      inorder_helper(current_node.left, list)
+      list << {key: current_node.key, value: current_node.value}
+      inorder_helper(current_node.right, list)
+  
+      return list
+    end
+  
+    # Time Complexity: I feel like both are O(n) since each item has to be traversed, even if it's recursively?
+    # Space Complexity: 
+    def preorder
+      return preorder_helper(@root, [])
+    end
+  
+    def preorder_helper(current_node, list)
+      return list if current_node.nil?
+  
+      list << {key: current_node.key, value: current_node.value}
+  
+      preorder_helper(current_node.left, list)
+      preorder_helper(current_node.right, list)
+  
+      return list
+    end
+  
+    # Time Complexity: Same as above, O(n)?
+    # Space Complexity: 
+    def postorder
+      return postorder_helper(@root, [])
+    end
+  
+    def postorder_helper(current_node, list)
+      return list if current_node.nil?
+  
+      preorder_helper(current_node.left, list)
+      preorder_helper(current_node.right, list)
+  
+      list << {key: current_node.key, value: current_node.value}
+  
+      return list
+  
+    end
+  
+    # Time Complexity: I'm not sure about time and space here. I think O(n)
+    # Space Complexity: 
+    def height
+      return height_helper(@root, height = 0)
+    end
+  
+    def height_helper(current_node, height)
+      return height if current_node.nil?
+  
+      height += 1
+      left_height = height_helper(current_node.left, height)
+      right_height = height_helper(current_node.right, height)
+  
+      if left_height > right_height
+          return left_height
+      else 
+          return right_height
+      end
   end
-
-  # Time Complexity: 
-  # Space Complexity: 
-  def inorder
-    raise NotImplementedError
+    # Optional Method
+    # Time Complexity: 
+    # Space Complexity: 
+    def bfs
+      raise NotImplementedError
+    end
+  
+    # Useful for printing
+    def to_s
+      return "#{self.inorder}"
+    end
   end
-
-  # Time Complexity: 
-  # Space Complexity: 
-  def preorder
-    raise NotImplementedError
-  end
-
-  # Time Complexity: 
-  # Space Complexity: 
-  def postorder
-    raise NotImplementedError
-  end
-
-  # Time Complexity: 
-  # Space Complexity: 
-  def height
-    raise NotImplementedError
-  end
-
-  # Optional Method
-  # Time Complexity: 
-  # Space Complexity: 
-  def bfs
-    raise NotImplementedError
-  end
-
-  # Useful for printing
-  def to_s
-    return "#{self.inorder}"
-  end
-end
+  
+  
+  Erika Maust <erika.maust@gmail.com>
+  9:13 PM (1 minute ago)
+  to erika.maust
+  
+  
+  
\ No newline at end of file

From e00ae259d6f63220c89821cad03d2384653c0585 Mon Sep 17 00:00:00 2001
From: Erika Maust <jamjar@Erikas-MacBook-Pro.local>
Date: Fri, 31 Jul 2020 14:01:33 -0700
Subject: [PATCH 2/8] add and find implemented

---
 lib/tree.rb | 103 +++++++++++++++++++++++++++++++++++-----------------
 1 file changed, 69 insertions(+), 34 deletions(-)

diff --git a/lib/tree.rb b/lib/tree.rb
index c0d4b51..c5734d8 100644
--- a/lib/tree.rb
+++ b/lib/tree.rb
@@ -16,51 +16,86 @@ def initialize
     @root = nil
   end
 
-  # Time Complexity: 
-  # Space Complexity: 
+  # Time Complexity: O(log n)
+  # Space Complexity: O(1)
   def add(key, value)
-    raise NotImplementedError
+    
+    if @root.nil?
+      return @root = TreeNode.new(key, value)
+    end
+
+    curr = @root
+
+    until curr.nil?
+      prev_node = curr
+      if key <= curr.key
+        curr = curr.left
+      else
+        curr = curr.right
+      end
+    end
+
+    if key <= prev_node.key
+      prev_node.left = TreeNode.new(key, value)
+    else
+      prev_node.right = TreeNode.new(key, value)
+    end
+
+
   end
 
+
   # Time Complexity: 
   # Space Complexity: 
   def find(key)
-    raise NotImplementedError
-  end
+    
+    curr = @root
+    
+    while !curr.nil?
+      return curr.value if curr.key == key
 
-  # Time Complexity: 
-  # Space Complexity: 
-  def inorder
-    raise NotImplementedError
-  end
+      if key < curr.key
+        curr = curr.left
+      else
+        curr = curr.right
+      end
+    end
 
-  # Time Complexity: 
-  # Space Complexity: 
-  def preorder
-    raise NotImplementedError
   end
 
-  # Time Complexity: 
-  # Space Complexity: 
-  def postorder
-    raise NotImplementedError
-  end
+#   # Time Complexity: 
+#   # Space Complexity: 
+#   def inorder
+#     raise NotImplementedError
+#   end
 
-  # Time Complexity: 
-  # Space Complexity: 
-  def height
-    raise NotImplementedError
-  end
+#   # Time Complexity: 
+#   # Space Complexity: 
+#   def preorder
+#     raise NotImplementedError
+#   end
 
-  # Optional Method
-  # Time Complexity: 
-  # Space Complexity: 
-  def bfs
-    raise NotImplementedError
-  end
+#   # Time Complexity: 
+#   # Space Complexity: 
+#   def postorder
+#     raise NotImplementedError
+#   end
 
-  # Useful for printing
-  def to_s
-    return "#{self.inorder}"
-  end
+#   # Time Complexity: 
+#   # Space Complexity: 
+#   def height
+#     raise NotImplementedError
+#   end
+
+#   # Optional Method
+#   # Time Complexity: 
+#   # Space Complexity: 
+#   def bfs
+#     raise NotImplementedError
+#   end
+
+#   # Useful for printing
+#   def to_s
+#     return "#{self.inorder}"
+#   end
 end

From d5cdd1b86dc7ef935374c6ad582165a0c92c7115 Mon Sep 17 00:00:00 2001
From: Erika Maust <jamjar@Erikas-MacBook-Pro.local>
Date: Thu, 6 Aug 2020 17:51:52 -0700
Subject: [PATCH 3/8] In, pre, post implemented

---
 lib/tree.rb | 70 ++++++++++++++++++++++++++++++++++++++++++++---------
 1 file changed, 59 insertions(+), 11 deletions(-)

diff --git a/lib/tree.rb b/lib/tree.rb
index c5734d8..d2a0d74 100644
--- a/lib/tree.rb
+++ b/lib/tree.rb
@@ -8,6 +8,44 @@ def initialize(key, val)
     @left = nil
     @right = nil
    end
+
+  def inorder
+
+    inorder_array = []
+
+    inorder_array += @left.inorder unless @left.nil?
+    inorder_array << { key: @key, value: @value }
+    inorder_array += @right.inorder unless @right.nil?
+    
+    return inorder_array
+
+  end
+
+  def preorder
+
+    preorder_array = []
+
+    preorder_array << { key: @key, value: @value }
+    preorder_array += @left.preorder unless left.nil?
+    preorder_array += @right.preorder unless right.nil?
+    
+
+    return preorder_array
+
+  end
+
+  def postorder
+
+    postorder_array = []
+
+    postorder_array += @left.postorder unless left.nil?
+    postorder_array += @right.postorder unless right.nil?
+    postorder_array << { key: @key, value: @value }
+
+    return postorder_array
+    
+  end
+
 end
 
 class Tree
@@ -45,8 +83,8 @@ def add(key, value)
   end
 
 
-  # Time Complexity: 
-  # Space Complexity: 
+  # Time Complexity: O (log n)
+  # Space Complexity: O(1)
   def find(key)
     
     curr = @root
@@ -65,21 +103,31 @@ def find(key)
 
 #   # Time Complexity: 
 #   # Space Complexity: 
-#   def inorder
-#     raise NotImplementedError
-#   end
+  def inorder
+    
+    return [] if @root.nil?
+    return @root.inorder
+
+  end
+  
 
 #   # Time Complexity: 
 #   # Space Complexity: 
-#   def preorder
-#     raise NotImplementedError
-#   end
+  def preorder
+    
+    return [] if @root.nil?
+    return @root.preorder
+
+  end
 
 #   # Time Complexity: 
 #   # Space Complexity: 
-#   def postorder
-#     raise NotImplementedError
-#   end
+  def postorder
+    
+    return [] if @root.nil?
+    return @root.postorder
+
+  end
 
 #   # Time Complexity: 
 #   # Space Complexity: 

From 34ec8e80d4d10fdb2663c6fe8811601a9099f880 Mon Sep 17 00:00:00 2001
From: Erika Maust <jamjar@Erikas-MacBook-Pro.local>
Date: Thu, 13 Aug 2020 13:16:44 -0700
Subject: [PATCH 4/8] Fixed add/find - recursive

---
 lib/pract.rb      |  0
 lib/tree.rb       | 85 +++++++++++++++++++++++++----------------------
 test/tree_test.rb | 16 +++++----
 3 files changed, 55 insertions(+), 46 deletions(-)
 create mode 100644 lib/pract.rb

diff --git a/lib/pract.rb b/lib/pract.rb
new file mode 100644
index 0000000..e69de29
diff --git a/lib/tree.rb b/lib/tree.rb
index d2a0d74..16fb375 100644
--- a/lib/tree.rb
+++ b/lib/tree.rb
@@ -9,6 +9,33 @@ def initialize(key, val)
     @right = nil
    end
 
+   def add(key, value)
+
+
+      if key <= @key
+        return @left = TreeNode.new(key, value) if @left.nil?
+        @left.add(key, value)
+      else
+        return @right = TreeNode.new(key, value) if @right.nil?
+        @right.add(key, value)
+      end
+
+    end
+
+    def find(key)
+
+      return @value if @key == key
+
+      if key > @key
+        return nil if @right.nil?
+        @right.find(key)
+      else
+        return nil if @left.nil?
+        @left.find(key)
+      end
+
+    end
+
   def inorder
 
     inorder_array = []
@@ -61,24 +88,8 @@ def add(key, value)
     if @root.nil?
       return @root = TreeNode.new(key, value)
     end
-
-    curr = @root
-
-    until curr.nil?
-      prev_node = curr
-      if key <= curr.key
-        curr = curr.left
-      else
-        curr = curr.right
-      end
-    end
-
-    if key <= prev_node.key
-      prev_node.left = TreeNode.new(key, value)
-    else
-      prev_node.right = TreeNode.new(key, value)
-    end
-
+    
+    return @root.add(key, value)
 
   end
 
@@ -86,23 +97,14 @@ def add(key, value)
   # Time Complexity: O (log n)
   # Space Complexity: O(1)
   def find(key)
-    
-    curr = @root
-    
-    while !curr.nil?
-      return curr.value if curr.key == key
-
-      if key < curr.key
-        curr = curr.left
-      else
-        curr = curr.right
-      end
-    end
+  
+    return nil if @root.nil?
+    return @root.find(key)
 
   end
 
-#   # Time Complexity: 
-#   # Space Complexity: 
+#   # Time Complexity: O(n)
+#   # Space Complexity: O(n)
   def inorder
     
     return [] if @root.nil?
@@ -111,8 +113,8 @@ def inorder
   end
   
 
-#   # Time Complexity: 
-#   # Space Complexity: 
+#   # Time Complexity: O(n)
+#   # Space Complexity: O(n)
   def preorder
     
     return [] if @root.nil?
@@ -120,8 +122,8 @@ def preorder
 
   end
 
-#   # Time Complexity: 
-#   # Space Complexity: 
+#   # Time Complexity: O(n)
+#   # Space Complexity: O(n)
   def postorder
     
     return [] if @root.nil?
@@ -131,9 +133,14 @@ def postorder
 
 #   # Time Complexity: 
 #   # Space Complexity: 
-#   def height
-#     raise NotImplementedError
-#   end
+  def height
+      
+    current = @root
+
+    return -1 if current.nil?
+    return [left.height + 1, right.height + 1].max
+
+  end
 
 #   # Optional Method
 #   # Time Complexity: 
diff --git a/test/tree_test.rb b/test/tree_test.rb
index 0823caa..9a71c91 100644
--- a/test/tree_test.rb
+++ b/test/tree_test.rb
@@ -1,3 +1,5 @@
+require 'pry'
+
 require_relative "test_helper"
 
 describe Tree do
@@ -37,8 +39,8 @@
 
     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"}]
+        {:key=>5, :value=>"Peter"}, {:key=>10, :value=>"Karla"}, 
+        {:key=>15, :value=>"Ada"}, {:key=>25, :value=>"Kari"}]
     end
   end
 
@@ -67,19 +69,19 @@
     end
   end
 
-  describe "breadth first search" do
+  xdescribe "breadth first search" do
     it "will give an empty array for an empty tree" do
       expect(tree.bfs).must_equal []
     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"}]
+      {:key=>10, :value=>"Karla"}, {:key=>1, :value=>"Mary"}, 
+      {:key=>15, :value=>"Ada"}, {:key=>25, :value=>"Kari"}]
     end
   end
   
-  describe "height" do 
+  xdescribe "height" do 
     it "will return 0 if tree is empty" do 
       expect(tree.height()).must_equal 0
     end
@@ -98,7 +100,7 @@
     end
   end
 
-  describe "delete" do
+  xdescribe "delete" do
     it "can delete a note in the tree" do
       # Arrange & Assert
       expect(tree_with_nodes.find(15)).must_equal "Ada"

From 30d69ee0fc837b6cdecd716ec7d8f1913adc6332 Mon Sep 17 00:00:00 2001
From: Erika Maust <jamjar@Erikas-MacBook-Pro.local>
Date: Thu, 10 Sep 2020 13:26:05 -0700
Subject: [PATCH 5/8] Final code

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

diff --git a/lib/tree.rb b/lib/tree.rb
index 16fb375..613d295 100644
--- a/lib/tree.rb
+++ b/lib/tree.rb
@@ -73,6 +73,23 @@ def postorder
     
   end
 
+  def height
+
+    return 1 if @left.nil? && @right.nil?
+
+    if @left.nil?
+      @right.height + 1 
+    elsif @right.nil?
+      @left.height + 1
+    else
+      if @left.height >= @right.height
+        @left.height + 1 
+      else
+        @right.height + 1 
+      end
+    end
+
+  end
 end
 
 class Tree
@@ -135,10 +152,8 @@ def postorder
 #   # Space Complexity: 
   def height
       
-    current = @root
-
-    return -1 if current.nil?
-    return [left.height + 1, right.height + 1].max
+    return 0 if @root.nil?
+    return @root.height
 
   end
 
diff --git a/test/tree_test.rb b/test/tree_test.rb
index 9a71c91..c4bf710 100644
--- a/test/tree_test.rb
+++ b/test/tree_test.rb
@@ -81,7 +81,7 @@
     end
   end
   
-  xdescribe "height" do 
+  describe "height" do 
     it "will return 0 if tree is empty" do 
       expect(tree.height()).must_equal 0
     end

From ddc5b9604eb4ffeee127c47ca9b92f19d16ab22c Mon Sep 17 00:00:00 2001
From: Erika Maust <jamjar@Erikas-MacBook-Pro.local>
Date: Thu, 10 Sep 2020 13:50:49 -0700
Subject: [PATCH 6/8] Wacky merge indentation and comments removed

---
 lib/tree.rb | 279 +++++++++++++++++++++++++---------------------------
 1 file changed, 135 insertions(+), 144 deletions(-)

diff --git a/lib/tree.rb b/lib/tree.rb
index 5750b17..40ce1f5 100644
--- a/lib/tree.rb
+++ b/lib/tree.rb
@@ -170,157 +170,148 @@ def height
 #     return "#{self.inorder}"
 #   end
 end
-=======
-  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
+
+class TreeNode
+  attr_reader :key, :value
+  attr_accessor :left, :right
+
+    def initialize(key, val)
+    @key = key
+    @value = val
+    @left = nil
+    @right = nil
     end
+end
   
-    # Time Complexity: 
-    # Space Complexity: 
-    def add(key, value)
-      if @root.nil?
-          @root = TreeNode.new(key,value)
-      else
-          current = @root
-          while true
-              if key < current.key
-                  if !current.left.nil?
-                      current = current.left
-                  else
-                      current.left = TreeNode.new(key,value)
-                  end
-              else
-                  if !@current.right.nil?
-                      current = current.right
-                  else
-                      current.right = TreeNode.new(key,value)
-                  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
+      current = @root
+      while true
+          if key < current.key
+            if !current.left.nil?
+                current = current.left
+            else
+                current.left = TreeNode.new(key,value)
+            end
+          else
+            if !@current.right.nil?
+              current = current.right
+            else
+              current.right = TreeNode.new(key,value)
+            end
           end
       end
     end
-  
-    # Time Complexity: Because it's recursive I want to say O log(n)
-    # Space Complexity: O log (n) if it's balanced, and I guess O(n) if it isn't
-    def find(key)
-      find_helper(@root, key)
-    end
-  
-    def find_helper(current_node, key)
-      return nil if current_node.nil?
-      return current_node.value if current_node.key == key
-  
-      if key < current_node.key
-          return find_helper(current_node.left, key)
-      elsif
-          key > current_node.key
-          return find_helper(current_node.right, key)
-      end
   end
-  
-  
-    # Time Complexity: I think time and space are both O(n)?
-    # Space Complexity: 
-    def inorder
-      return inorder_helper(@root, [])
-    end
-  
-    def inorder_helper(current_node, list)
-      return list if current_node.nil?
-  
-      inorder_helper(current_node.left, list)
-      list << {key: current_node.key, value: current_node.value}
-      inorder_helper(current_node.right, list)
-  
-      return list
-    end
-  
-    # Time Complexity: I feel like both are O(n) since each item has to be traversed, even if it's recursively?
-    # Space Complexity: 
-    def preorder
-      return preorder_helper(@root, [])
-    end
-  
-    def preorder_helper(current_node, list)
-      return list if current_node.nil?
-  
-      list << {key: current_node.key, value: current_node.value}
-  
-      preorder_helper(current_node.left, list)
-      preorder_helper(current_node.right, list)
-  
-      return list
-    end
-  
-    # Time Complexity: Same as above, O(n)?
-    # Space Complexity: 
-    def postorder
-      return postorder_helper(@root, [])
-    end
-  
-    def postorder_helper(current_node, list)
-      return list if current_node.nil?
-  
-      preorder_helper(current_node.left, list)
-      preorder_helper(current_node.right, list)
-  
-      list << {key: current_node.key, value: current_node.value}
-  
-      return list
-  
-    end
-  
-    # Time Complexity: I'm not sure about time and space here. I think O(n)
-    # Space Complexity: 
-    def height
-      return height_helper(@root, height = 0)
-    end
-  
-    def height_helper(current_node, height)
-      return height if current_node.nil?
-  
-      height += 1
-      left_height = height_helper(current_node.left, height)
-      right_height = height_helper(current_node.right, height)
-  
-      if left_height > right_height
-          return left_height
-      else 
-          return right_height
-      end
+
+  # Time Complexity: Because it's recursive I want to say O log(n)
+  # Space Complexity: O log (n) if it's balanced, and I guess O(n) if it isn't
+  def find(key)
+    find_helper(@root, key)
   end
-    # Optional Method
-    # Time Complexity: 
-    # Space Complexity: 
-    def bfs
-      raise NotImplementedError
+
+  def find_helper(current_node, key)
+    return nil if current_node.nil?
+    return current_node.value if current_node.key == key
+
+    if key < current_node.key
+        return find_helper(current_node.left, key)
+    elsif
+        key > current_node.key
+        return find_helper(current_node.right, key)
     end
-  
-    # Useful for printing
-    def to_s
-      return "#{self.inorder}"
+end
+
+
+  # Time Complexity: I think time and space are both O(n)?
+  # Space Complexity: 
+  def inorder
+    return inorder_helper(@root, [])
+  end
+
+  def inorder_helper(current_node, list)
+    return list if current_node.nil?
+
+    inorder_helper(current_node.left, list)
+    list << {key: current_node.key, value: current_node.value}
+    inorder_helper(current_node.right, list)
+
+    return list
+  end
+
+  # Time Complexity: I feel like both are O(n) since each item has to be traversed, even if it's recursively?
+  # Space Complexity: 
+  def preorder
+    return preorder_helper(@root, [])
+  end
+
+  def preorder_helper(current_node, list)
+    return list if current_node.nil?
+
+    list << {key: current_node.key, value: current_node.value}
+
+    preorder_helper(current_node.left, list)
+    preorder_helper(current_node.right, list)
+
+    return list
+  end
+
+  # Time Complexity: Same as above, O(n)?
+  # Space Complexity: 
+  def postorder
+    return postorder_helper(@root, [])
+  end
+
+  def postorder_helper(current_node, list)
+    return list if current_node.nil?
+
+    preorder_helper(current_node.left, list)
+    preorder_helper(current_node.right, list)
+
+    list << {key: current_node.key, value: current_node.value}
+
+    return list
+
+  end
+
+  # Time Complexity: I'm not sure about time and space here. I think O(n)
+  # Space Complexity: 
+  def height
+    return height_helper(@root, height = 0)
+  end
+
+  def height_helper(current_node, height)
+    return height if current_node.nil?
+
+    height += 1
+    left_height = height_helper(current_node.left, height)
+    right_height = height_helper(current_node.right, height)
+
+    if left_height > right_height
+        return left_height
+    else 
+        return right_height
     end
+end
+  # Optional Method
+  # Time Complexity: 
+  # Space Complexity: 
+  def bfs
+    raise NotImplementedError
   end
-  
-  
-  Erika Maust <erika.maust@gmail.com>
-  9:13 PM (1 minute ago)
-  to erika.maust
-  
-  
-  
->>>>>>> c72dda7aeeb046fd3ec504052231cd9bb11535a0
+
+  # Useful for printing
+  def to_s
+    return "#{self.inorder}"
+  end
+end

From 7ca98a0032065e5f96b031ef566201b36c73b52a Mon Sep 17 00:00:00 2001
From: Erika Maust <jamjar@Erikas-MacBook-Pro.local>
Date: Thu, 10 Sep 2020 13:58:07 -0700
Subject: [PATCH 7/8] More merge comparisons removed

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

diff --git a/lib/tree.rb b/lib/tree.rb
index 40ce1f5..7894f80 100644
--- a/lib/tree.rb
+++ b/lib/tree.rb
@@ -1,4 +1,3 @@
-<<<<<<< HEAD
 class TreeNode
   attr_reader :key, :value
   attr_accessor :left, :right

From d989611e071a49e6ab4d3e2c445a416ebccd9cd6 Mon Sep 17 00:00:00 2001
From: Erika Maust <jamjar@Erikas-MacBook-Pro.local>
Date: Thu, 10 Sep 2020 14:01:51 -0700
Subject: [PATCH 8/8] Removed inexplicable second set of identical code

---
 lib/tree.rb | 146 ----------------------------------------------------
 1 file changed, 146 deletions(-)

diff --git a/lib/tree.rb b/lib/tree.rb
index 7894f80..8b53f17 100644
--- a/lib/tree.rb
+++ b/lib/tree.rb
@@ -11,7 +11,6 @@ def initialize(key, val)
 
    def add(key, value)
 
-
       if key <= @key
         return @left = TreeNode.new(key, value) if @left.nil?
         @left.add(key, value)
@@ -169,148 +168,3 @@ def height
 #     return "#{self.inorder}"
 #   end
 end
-
-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
-  end
-
-  # Time Complexity: 
-  # Space Complexity: 
-  def add(key, value)
-    if @root.nil?
-        @root = TreeNode.new(key,value)
-    else
-      current = @root
-      while true
-          if key < current.key
-            if !current.left.nil?
-                current = current.left
-            else
-                current.left = TreeNode.new(key,value)
-            end
-          else
-            if !@current.right.nil?
-              current = current.right
-            else
-              current.right = TreeNode.new(key,value)
-            end
-          end
-      end
-    end
-  end
-
-  # Time Complexity: Because it's recursive I want to say O log(n)
-  # Space Complexity: O log (n) if it's balanced, and I guess O(n) if it isn't
-  def find(key)
-    find_helper(@root, key)
-  end
-
-  def find_helper(current_node, key)
-    return nil if current_node.nil?
-    return current_node.value if current_node.key == key
-
-    if key < current_node.key
-        return find_helper(current_node.left, key)
-    elsif
-        key > current_node.key
-        return find_helper(current_node.right, key)
-    end
-end
-
-
-  # Time Complexity: I think time and space are both O(n)?
-  # Space Complexity: 
-  def inorder
-    return inorder_helper(@root, [])
-  end
-
-  def inorder_helper(current_node, list)
-    return list if current_node.nil?
-
-    inorder_helper(current_node.left, list)
-    list << {key: current_node.key, value: current_node.value}
-    inorder_helper(current_node.right, list)
-
-    return list
-  end
-
-  # Time Complexity: I feel like both are O(n) since each item has to be traversed, even if it's recursively?
-  # Space Complexity: 
-  def preorder
-    return preorder_helper(@root, [])
-  end
-
-  def preorder_helper(current_node, list)
-    return list if current_node.nil?
-
-    list << {key: current_node.key, value: current_node.value}
-
-    preorder_helper(current_node.left, list)
-    preorder_helper(current_node.right, list)
-
-    return list
-  end
-
-  # Time Complexity: Same as above, O(n)?
-  # Space Complexity: 
-  def postorder
-    return postorder_helper(@root, [])
-  end
-
-  def postorder_helper(current_node, list)
-    return list if current_node.nil?
-
-    preorder_helper(current_node.left, list)
-    preorder_helper(current_node.right, list)
-
-    list << {key: current_node.key, value: current_node.value}
-
-    return list
-
-  end
-
-  # Time Complexity: I'm not sure about time and space here. I think O(n)
-  # Space Complexity: 
-  def height
-    return height_helper(@root, height = 0)
-  end
-
-  def height_helper(current_node, height)
-    return height if current_node.nil?
-
-    height += 1
-    left_height = height_helper(current_node.left, height)
-    right_height = height_helper(current_node.right, height)
-
-    if left_height > right_height
-        return left_height
-    else 
-        return right_height
-    end
-end
-  # Optional Method
-  # Time Complexity: 
-  # Space Complexity: 
-  def bfs
-    raise NotImplementedError
-  end
-
-  # Useful for printing
-  def to_s
-    return "#{self.inorder}"
-  end
-end