diff --git a/lib/tree.rb b/lib/tree.rb
index c0d4b51..f31a540 100644
--- a/lib/tree.rb
+++ b/lib/tree.rb
@@ -2,59 +2,164 @@ 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
+
+  def add(key, value)
+    if key == @key
+      return
+    elsif key < @key
+      left.nil? ? @left = TreeNode.new(key, value) : left.add(key, value)
+    elsif key > @key
+      right.nil? ? @right = TreeNode.new(key, value) : right.add(key, value)
+    end
+  end
+
+  def find(key)
+    if key == @key
+      return @value
+    elsif key < @key
+      left.nil? ? nil : left.find(key)
+    elsif key > @key
+      right.nil? ? nil : right.find(key)
+    end
+  end
+
+  def inorder(tree_array)
+    # if !left.nil?
+    if left
+      left.inorder(tree_array)
+    end
+
+    tree_array << { key: @key, value: @value }
+
+    # if !@right.nil?
+    if right
+      right.inorder(tree_array)
+    end
+  end
+
+  def preorder(tree_array)
+    tree_array << { key: @key, value: @value }
+
+    if left
+      left.preorder(tree_array)
+    end
+
+    if right
+      right.preorder(tree_array)
+    end
+  end
+
+  def postorder(tree_array)
+    if left
+      left.postorder(tree_array)
+    end
+
+    if right
+      right.postorder(tree_array)
+    end
+    tree_array << { key: @key, value: @value }
+  end
+
+  def height
+    left_height = 0
+    right_height = 0
+
+    # if !left.nil?
+    unless left.nil?
+      left_height = left.height + 1
+    end
+
+    unless right.nil?
+      right_height = right.height + 1
+    end
+
+    left_height >= right_height ? left_height : right_height
+  end
 end
 
 class Tree
   attr_reader :root
+
   def initialize
     @root = nil
   end
 
-  # Time Complexity: 
-  # Space Complexity: 
+  # Time Complexity: O(log n) if the tree is balanced, O(n) if it is unbalanced - where n is the number of nodes in the tree
+  # Space Complexity: O(log n) if the tree is balanced, O(n) if it is unbalanced - where n is the number of nodes in the tree
   def add(key, value)
-    raise NotImplementedError
+    # if root.nil?
+    if !root
+      @root = TreeNode.new(key, value)
+    else
+      root.add(key, value)
+    end
   end
 
-  # Time Complexity: 
-  # Space Complexity: 
+  # Time Complexity: O(log n) if the tree is balanced, O(n) if it is unbalanced - where n is the number of nodes in the tree
+  # Space Complexity: O(log n) if the tree is balanced, O(n) if it is unbalanced - where n is the number of nodes in the tree
   def find(key)
-    raise NotImplementedError
+    if root.nil?
+      return nil
+    else
+      root.find(key)
+    end
   end
 
-  # Time Complexity: 
-  # Space Complexity: 
+  # Time Complexity: O(n), n is the number of nodes in the tree
+  # Space Complexity: O(n), n is the number of nodes in the tree
   def inorder
-    raise NotImplementedError
+    tree_array = []
+    if root.nil?
+      return tree_array
+    else
+      root.inorder(tree_array)
+      return tree_array
+    end
   end
 
-  # Time Complexity: 
-  # Space Complexity: 
+  # Time Complexity: O(n), n is the number of nodes in the tree
+  # Space Complexity: O(n), n is the number of nodes in the tree
   def preorder
-    raise NotImplementedError
+    tree_array = []
+    if root.nil?
+      return tree_array
+    else
+      root.preorder(tree_array)
+      return tree_array
+    end
   end
 
-  # Time Complexity: 
-  # Space Complexity: 
+  # Time Complexity: O(n), n is the number of nodes in the tree
+  # Space Complexity: O(n), n is the number of nodes in the tree
   def postorder
-    raise NotImplementedError
+    tree_array = []
+    if root.nil?
+      return tree_array
+    else
+      root.postorder(tree_array)
+      return tree_array
+    end
   end
 
-  # Time Complexity: 
-  # Space Complexity: 
+  # Time Complexity: O(n), where n is the number of nodes in the tree
+  # Space Complexity: O(log n) if tree is balanced, O(n) if unbalanced
   def height
-    raise NotImplementedError
+    if root.nil?
+      return nil
+    else
+      return root.height
+    end
   end
 
   # Optional Method
-  # Time Complexity: 
-  # Space Complexity: 
+  # Time Complexity:
+  # Space Complexity:
   def bfs
     raise NotImplementedError
   end
@@ -64,3 +169,15 @@ def to_s
     return "#{self.inorder}"
   end
 end
+
+tree = Tree.new
+tree.add(5, "Peter")
+tree.add(3, "Paul")
+tree.add(1, "Mary")
+tree.add(10, "Karla")
+tree.add(15, "Ada")
+tree.add(25, "Kari")
+
+# puts tree.to_s
+
+# puts tree.height
diff --git a/test/tree_test.rb b/test/tree_test.rb
index 8811f14..2f6a040 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,28 @@
     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
+
+  describe "height" do
+    it "will return 0 for a tree with 1 node" do
+      tree
+      tree.add(5, "Peter")
+
+      expect(tree.height).must_equal 0
+    end
+
+    it "will return the height of the tree" do
+      tree
+      tree.add(10, "Karla")
+      tree.add(5, "Peter")
+      tree.add(15, "Ada")
+      tree.add(25, "Kari")
+
+      expect(tree.height).must_equal 2
     end
   end
 
@@ -75,9 +91,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