Earth - Alice B.

lib/tree.rb

@@ -2,12 +2,12 @@ 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
@@ -16,51 +16,114 @@ def initialize
     @root = nil
   end
 
-  # Time Complexity: 
-  # Space Complexity: 
+  # Time Complexity: O(log n)
+  # Space Complexity: O(1)
   def add(key, value)
-    raise NotImplementedError
+    @root = add_helper(@root, key, value)
+  end
+
+  def add_helper(root, key, value)
+    if root.nil?
+      root = TreeNode.new(key, value)
+      return root
+    end
+
+    if root.key > key
+      root.left = add_helper(root.left, key, value)
+    else
+      root.right = add_helper(root.right, key, value)
+    end
+
+    root
   end
 
-  # Time Complexity: 
-  # Space Complexity: 
+  # Time Complexity: O(log n)
+  # Space Complexity: O(log n)
   def find(key)
-    raise NotImplementedError
+    find_helper(@root, key)
   end
 
-  # Time Complexity: 
-  # Space Complexity: 
+  def find_helper(node, key)
+    return nil if node.nil?
+
+    if node.key == key
+      node.value
+    elsif node.key < key
+      find_helper(node.right, key)
+    else
+      find_helper(node.left, key)
+    end
+  end
+
+  # Time Complexity: O(n)
+  # Space Complexity: O(n)
   def inorder
-    raise NotImplementedError
+    result = []
+    inorder_helper(@root, result)
+    result
+  end
+
+  def inorder_helper(node, result)
+    return if node.nil?
+
+    inorder_helper(node.left, result)
+    result.push({ key: node.key, value: node.value })
+    inorder_helper(node.right, result)
   end
 
-  # Time Complexity: 
-  # Space Complexity: 
+  # Time Complexity: O(n)
+  # Space Complexity: O(n)
   def preorder
-    raise NotImplementedError
+    result = []
+    preorder_helper(@root, result)
+    result
   end
 
-  # Time Complexity: 
-  # Space Complexity: 
+  def preorder_helper(node, result)
+    return if node.nil?
+
+    result.push({ key: node.key, value: node.value })
+    preorder_helper(node.left, result)
+    preorder_helper(node.right, result)
+  end
+
+  # Time Complexity: O(n)
+  # Space Complexity: O(n)
   def postorder
-    raise NotImplementedError
+    result = []
+    postorder_helper(@root, result)
+    result
+  end
+
+  def postorder_helper(node, result)
+    return if node.nil?
+
+    postorder_helper(node.left, result)
+    postorder_helper(node.right, result)
+    result.push({ key: node.key, value: node.value })
   end
 
-  # Time Complexity: 
-  # Space Complexity: 
+  # Time Complexity: O(n)
+  # Space Complexity: O(n)
   def height
-    raise NotImplementedError
+    height_helper(@root, 0)
+  end
+
+  def height_helper(node, steps)
+    return steps if node.nil?
+
+    [height_helper(node.left, steps + 1), height_helper(node.right, steps + 1)].max
   end
 
   # Optional Method
-  # Time Complexity: 
-  # Space Complexity: 
+  # Time Complexity:
+  # Space Complexity:
   def bfs
-    raise NotImplementedError
+    return [] if @root.nil?
   end
 
   # Useful for printing
   def to_s
-    return "#{self.inorder}"
+    inorder.to_s
   end
 end