diff --git a/lib/tree.rb b/lib/tree.rb
index c0d4b51..6817fc1 100644
--- a/lib/tree.rb
+++ b/lib/tree.rb
@@ -1,13 +1,13 @@
 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
@@ -15,50 +15,163 @@ class Tree
   def initialize
     @root = nil
   end
-
-  # Time Complexity: 
-  # Space Complexity: 
+  
+  # Time Complexity: O(log n)
+  # Space Complexity: O(n)
   def add(key, value)
-    raise NotImplementedError
+    
+    current = @root 
+    temp = TreeNode.new(key, value) 
+    
+    if @root == nil 
+      @root = temp
+      return
+      
+    else
+      add_helper(@root, temp)
+    end
   end
-
-  # Time Complexity: 
-  # Space Complexity: 
+  
+  def add_helper(current_node, temp)
+    if current_node == nil
+      return temp
+    end
+    
+    if temp.key < current_node.key 
+      current_node.left = add_helper(current_node.left, temp)
+    else
+      current_node.right = add_helper(current_node.right, temp)
+    end
+    return current_node
+  end
+  
+  # Time Complexity: O(log n)
+  # Space Complexity: O(n)
   def find(key)
-    raise NotImplementedError
+    current = @root
+    if current == nil
+      return nil
+    elsif current.key == key
+      return current.value
+    else
+      find_helper(current, key)
+    end
   end
-
-  # Time Complexity: 
-  # Space Complexity: 
+  
+  def find_helper (current, key) 
+    if current.key == key
+      return current.value
+    elsif current.key > key && current.left != nil 
+      find_helper(current.left, key)
+    elsif current.key > key
+      return nil
+    elsif current.key < key && current.right != nil
+      find_helper(current.right, key)
+    elsif current.key < key
+      return nil
+    end
+  end
+  
+  # Time Complexity: O(n)
+  # Space Complexity: O(n)
   def inorder
-    raise NotImplementedError
+    if @root == nil
+      return []
+    end
+    inorder_helper(@root, [])
   end
-
-  # Time Complexity: 
-  # Space Complexity: 
+  
+  def inorder_helper(current_node, list)
+    
+    if current_node == nil
+      return list
+    end
+    
+    inorder_helper(current_node.left, list)
+    list.push({key: current_node.key, value: current_node.value})
+    inorder_helper(current_node.right, list)
+    return list
+  end
+  
+  # Time Complexity: O(n)
+  # Space Complexity: O(n)
   def preorder
-    raise NotImplementedError
+    if @root == nil
+      return []
+    else
+      return preorder_helper(@root, [])
+    end
   end
-
-  # Time Complexity: 
-  # Space Complexity: 
+  
+  def preorder_helper(current_node, list)
+    if current_node == nil
+      return list
+    end
+    
+    list.push({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: O(n)
+  # Space Complexity: O(n)
   def postorder
-    raise NotImplementedError
+    if @root == nil
+      return []
+    else
+      return postorder_helper(@root, [])
+    end
   end
-
-  # Time Complexity: 
-  # Space Complexity: 
+  
+  def postorder_helper(current_node, list)
+    if current_node == nil
+      return list
+    end
+    
+    postorder_helper(current_node.left, list)
+    postorder_helper(current_node.right, list)
+    list.push({key: current_node.key, value: current_node.value})
+    
+    return list
+  end
+  
+  # Time Complexity: O(n)
+  # Space Complexity: O(n)
   def height
-    raise NotImplementedError
+    if @root == nil
+      return 0
+    elsif @root.left == nil && @root.right == nil
+      return 1
+    end
+    
+    return height_helper(@root)
+    
   end
-
+  
+  def height_helper(current_node)
+    
+    if current_node == nil
+      return 0
+    end
+    
+    left = height_helper(current_node.left)
+    right = height_helper(current_node.right)
+    if left > right
+      return left + 1
+    else
+      return right + 1
+    end
+  end
+  
   # Optional Method
   # Time Complexity: 
   # Space Complexity: 
   def bfs
     raise NotImplementedError
   end
-
+  
   # Useful for printing
   def to_s
     return "#{self.inorder}"
diff --git a/test/test_helper.rb b/test/test_helper.rb
index 5ba31a3..5060ac9 100644
--- a/test/test_helper.rb
+++ b/test/test_helper.rb
@@ -1,10 +1,11 @@
   
-require "minitest"
-require "minitest/autorun"
-require "minitest/reporters"
-require "minitest/skip_dsl"
-
-
-Minitest::Reporters.use! Minitest::Reporters::SpecReporter.new
-
-require_relative "../lib/tree"
+  require "minitest"
+  require "minitest/autorun"
+  require "minitest/reporters"
+  require "minitest/skip_dsl"
+  
+  
+  Minitest::Reporters.use! Minitest::Reporters::SpecReporter.new
+  
+  require_relative "../lib/tree"
+  
\ No newline at end of file
diff --git a/test/tree_test.rb b/test/tree_test.rb
index 0823caa..7013da6 100644
--- a/test/tree_test.rb
+++ b/test/tree_test.rb
@@ -2,134 +2,158 @@
 
 describe Tree do
   let (:tree) {Tree.new}
-
+  
   let (:tree_with_nodes) {
+  tree.add(5, "Peter")
+  tree.add(3, "Paul")
+  tree.add(1, "Mary")
+  tree.add(10, "Karla")
+  tree.add(15, "Ada")
+  tree.add(25, "Kari")
+  tree
+}
+
+describe "add and find" do 
+  it "add & find values" do
     tree.add(5, "Peter")
+    expect(tree.find(5)).must_equal "Peter"
+    
+    tree.add(15, "Ada")
+    expect(tree.find(15)).must_equal "Ada"
+    
     tree.add(3, "Paul")
+    expect(tree.find(3)).must_equal "Paul"
+  end
+  
+  it "can't find anything when the tree is empty" do
+    expect(tree.find(50)).must_be_nil
+  end
+  
+  it "for troubleshooting it traces the structure of the tree" do
+    tree.add(5, "Peter")
+    expect(tree.find(5)).must_equal "Peter"
+    
+    tree.add(3, "Paul")
+    expect(tree.find(3)).must_equal "Paul"
+    expect(tree.root.left.key).must_equal 3
+    
     tree.add(1, "Mary")
+    expect(tree.find(1)).must_equal "Mary"
+    expect(tree.root.left.left.key).must_equal 1
+    
     tree.add(10, "Karla")
+    expect(tree.find(10)).must_equal "Karla"
+    expect(tree.root.right.key).must_equal 10
+    
     tree.add(15, "Ada")
+    expect(tree.find(15)).must_equal "Ada"
+    expect(tree.root.right.right.key).must_equal 15
+    
     tree.add(25, "Kari")
-    tree
-  }
-
-  describe "add and find" do 
-    it "add & find values" do
-      tree.add(5, "Peter")
-      expect(tree.find(5)).must_equal "Peter"
-
-      tree.add(15, "Ada")
-      expect(tree.find(15)).must_equal "Ada"
-
-      tree.add(3, "Paul")
-      expect(tree.find(3)).must_equal "Paul"
-    end
-
-    it "can't find anything when the tree is empty" do
-      expect(tree.find(50)).must_be_nil
-    end
+    expect(tree.find(25)).must_equal "Kari"
+    expect(tree.root.right.right.right.key).must_equal 25
   end
+end
 
-  describe "inorder" do
-    it "will give an empty array for an empty tree" do
-      expect(tree.inorder).must_equal []
-    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"}]
-    end
+describe "inorder" do
+  it "will give an empty array for an empty tree" do
+    expect(tree.inorder).must_equal []
   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"}]
-    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"}]
   end
+end
 
-  describe "postorder" do
-    it "will give an empty array for an empty tree" do
-      expect(tree.postorder).must_equal []
-    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"}]
+  end
+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"}]
-    end
+describe "postorder" do
+  it "will give an empty array for an empty tree" do
+    expect(tree.postorder).must_equal []
+  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"}]
   end
+end
 
-  describe "breadth first search" do
-    it "will give an empty array for an empty tree" do
-      expect(tree.bfs).must_equal []
-    end
+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"}]
+  end
+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"}]
-    end
+describe "height" do 
+  it "will return 0 if tree is empty" do 
+    expect(tree.height()).must_equal 0
+  end
+  
+  it "will return the nuber of nodes in the longest path" do
+    expect(tree_with_nodes.height).must_equal 4
+    tree_with_nodes.add(60, "sam")
+    tree_with_nodes.add(58, "penny")
+    tree_with_nodes.add(65, "sam")
+    expect(tree_with_nodes.height).must_equal 6
   end
   
-  describe "height" do 
-    it "will return 0 if tree is empty" do 
-      expect(tree.height()).must_equal 0
-    end
+  it "will give the correct height of a binary search tree" do
+    tree_with_nodes.add(30, "Tatiana")
+    expect(tree_with_nodes.height).must_equal 5
+  end
+end
 
-    it "will return the nuber of nodes in the longest path" do
-      expect(tree_with_nodes.height).must_equal 4
-      tree_with_nodes.add(60, "sam")
-      tree_with_nodes.add(58, "penny")
-      tree_with_nodes.add(65, "sam")
-      expect(tree_with_nodes.height).must_equal 6
-    end
+xdescribe "delete" do
+  it "can delete a note in the tree" do
+    # Arrange & Assert
+    expect(tree_with_nodes.find(15)).must_equal "Ada"
+    
+    # Act
+    tree_with_nodes.delete(15)
     
-    it "will give the correct height of a binary search tree" do
-      tree_with_nodes.add(30, "Tatiana")
-      expect(tree_with_nodes.height).must_equal 5
-    end
+    # Assert
+    expect(tree_with_nodes.find(15)).must_be_nil
   end
-
-  describe "delete" do
-    it "can delete a note in the tree" do
-      # Arrange & Assert
-      expect(tree_with_nodes.find(15)).must_equal "Ada"
-
-      # Act
-      tree_with_nodes.delete(15)
-
-      # Assert
-      expect(tree_with_nodes.find(15)).must_be_nil
-    end
-
-    it "will return nil if the node is not in the tree when it's deleted" do
-      # Arrange & Act
-      answer = tree_with_nodes.delete(47)
-
-      # Assert
-      expect(answer).must_be_nil
-      expect(tree_with_nodes.find(47)).must_be_nil
-    end
-
-    it "can delete the root of a big tree" do
-      # Arrange
-      tree_with_nodes.add(8, "Phil")
-      tree_with_nodes.add(18, "Sarah")
-
-      # Act
-      answer = tree_with_nodes.delete(5)
-
-      # Assert
-      expect(tree_with_nodes.find(5)).must_be_nil
-      expect(tree_with_nodes.find(3)).wont_be_nil
-    end
+  
+  it "will return nil if the node is not in the tree when it's deleted" do
+    # Arrange & Act
+    answer = tree_with_nodes.delete(47)
+    
+    # Assert
+    expect(answer).must_be_nil
+    expect(tree_with_nodes.find(47)).must_be_nil
   end
+  
+  it "can delete the root of a big tree" do
+    # Arrange
+    tree_with_nodes.add(8, "Phil")
+    tree_with_nodes.add(18, "Sarah")
+    
+    # Act
+    answer = tree_with_nodes.delete(5)
+    
+    # Assert
+    expect(tree_with_nodes.find(5)).must_be_nil
+    expect(tree_with_nodes.find(3)).wont_be_nil
+  end
+end
 end