Merge pull request kodecocodes#15 from nameghino/master

A basic implementation of an unbalanced binary search tree using enums

Author: hollance

Binary Search Tree/BinarySearchTree.swift

@@ -0,0 +1,44 @@
+import Foundation
+
+public enum BinarySearchTree<T: Comparable> {
+    indirect case Node(BinarySearchTree, T, BinarySearchTree)
+    case Leaf(T)
+    case Empty
+
+    public func insert(new: T) -> BinarySearchTree {
+        switch self {
+        case .Leaf(let value):
+            if new < value {
+                return .Node(.Leaf(new), value, .Empty)
+            } else {
+                return .Node(.Empty, value, .Leaf(new))
+            }
+        case .Empty:
+            return .Leaf(new)
+        case .Node(let left, let value, let right):
+            if new < value {
+                return .Node(left.insert(new), value, right)
+            } else {
+                return .Node(left, value, right.insert(new))
+            }
+        }
+    }
+
+    public var height: Int {
+        switch self {
+            case .Empty: return 0
+            case .Leaf(_): return 1
+            case .Node(let left, _, let right): return 1 + max(left.height, right.height)
+        }
+    }
+}
+
+extension BinarySearchTree: CustomDebugStringConvertible {
+    var debugDescription: String {
+        switch self {
+        case .Empty: return "<X>"
+        case .Leaf(let v): return "\(v)"
+        case .Node(let left, let value, let right): return "(\(left.debugDescription) <- \(value) -> \(right.debugDescription))"
+        }
+    }
+}

Binary Search Tree/README.markdown

@@ -0,0 +1,52 @@
+# Heap
+
+Written for the Swift Algorithm Club by [Nicolas Ameghino](http://www.github.com/nameghino).
+
+## Intro
+
+A binary search tree is a special kind of binary tree (a tree in which a node only has two children) that performs insertions in a special way such that the tree is always sorted.
+
+## "Always sorted" property
+
+When performing an insertion, the tree will check the value of the *key* for a node and compare it to the *key* for the soon-to-be-inserted value. It will go down the tree until there's an empty leaf following the rule that if the new value is smaller than the existant one, it will be inserted to the left of the existant node. Otherwise, it will be to the right of it.
+
+Let's look at an example:
+
+```
+    (7)
+   /   \
+ (2)   (10)
+ /  \
+(1) (5)
+```
+
+Say we want to insert the value 9:
+
+We'd start at the root of the tree (the node with the value 7, in this case), and compare it to the new value (9 for now).
+We see that `9 > 7`, so we go down the *right* branch of that node. Here, we recurse on the *right* node, and peform the same procedure: check against the key, but this time `9 < 10`, so we go down the *left* branch.
+We've now arrived to a point in which there are no more values to compare with, so the value 9 is inserted at that ___location, going first right and then left from the root, to have a tree that now looks like this:
+
+```
+     (7)
+   /     \
+ (2)     (10)
+ /  \    /
+(1) (5) (9)
+```
+
+By following this simple rule, we keep the tree sorted in a way that, whenever we query it, we can quickly check if a value is in the tree or get such value.
+
+## Deletion
+
+TBD
+
+## Disadvantages
+
+If the tree is not *balanced*, that is, one branch is significantly longer than the other, then queries would suffer performance issues, having to check more values on one branch than it would if the tree were optimally balanced.
+Balanced trees guarantee that the longest branch of the tree will be at most 1 node longer than the rest, otherwise the tree will balance itself on insertion.
+
+Another issue arises from the insertion of increasing or decreasing values, in which the tree would be massively unbalanced with just one long branch, and all children nodes branching in the same direction.
+
+## See also
+
+[Binary Search Tree on Wikipedia](https://en.wikipedia.org/wiki/Binary_search_tree)

README.markdown

@@ -41,6 +41,7 @@ If you're new to algorithms and data structures, here are a few good ones to sta
 - Binary Tree
 - Merge Sort
 - [Boyer-Moore](Boyer-Moore/) string search
+- [Binary Search Tree](Binary Search Tree/)
 
 ## The algorithms
 
@@ -106,7 +107,7 @@ Bad sorting algorithms (don't use these!):
 
 ## Data structures
 
-The choice of data structure for a particular task depends on a few things. 
+The choice of data structure for a particular task depends on a few things.
 
 First, there is the shape of your data and the kinds of operations that you'll need to perform on it. If you want to look up objects by a key you need some kind of dictionary; if your data is hierarchical in nature you want a tree structure of some sort; if your data is sequential you want a stack or queue.
 
@@ -136,7 +137,7 @@ Often just using the built-in `Array`, `Dictionary`, and `Set` types is sufficie
 
 - [Tree](Tree/). A general-purpose tree structure.
 - Binary Tree
-- Binary Search Tree (BST)
+- [Binary Search Tree (BST)](Binary Search Tree/). A binary tree with the special requirement that elements are inserted in a specific way, allowing for faster queries, like when using a [binary search](Binary Search/) algorithm.
 - AVL Tree
 - Red-Black Tree
 - Splay Tree
@@ -156,7 +157,7 @@ Often just using the built-in `Array`, `Dictionary`, and `Set` types is sufficie
 
 ### Hashing
 
-- [Hash Table](Hash Table/). Allows you to store and retrieve objects by a key. This is how the dictionary type is usually implemented. 
+- [Hash Table](Hash Table/). Allows you to store and retrieve objects by a key. This is how the dictionary type is usually implemented.
 - Hash Functions
 
 ### Graphs