Merge branch 'master' of https://github.com/hollance/swift-algorithm-club into Select-Minimum-Maximum

Author: Chris Pilcher

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)

Kth Largest Element/README.markdown

@@ -0,0 +1,35 @@
+# k-th Largest Element Problem
+
+You're given an integer array `a`. Write an algorithm that finds the kth largest element in the array.
+
+The following solution is semi-naive. Its time complexity is O(n log n) since it first sorts the array, and uses an additional O(n) space. Better solutions using heaps exist that run in O(n) time.
+
+```swift
+func kthLargest(a: [Int], k: Int) -> Int? {
+    let len = a.count
+
+    if (k <= 0 || k > len || len < 1) { return nil }
+
+    let sorted = a.sort()
+
+    return sorted[len - k]
+}
+```
+
+The `kthLargest()` function takes two parameters: the array `a` with consisting of integers, and `k`, in order to find the kth largest element. It returns the kth largest element.
+
+Let's take a look at an example and run through the algorithm to see how it works. Given `k = 4` and the array:
+
+```swift
+[ 7, 92, 23, 9, -1, 0, 11, 6 ]
+```
+
+Initially there's no direct way to find the kth largest element, but after sorting the array it's rather straightforward. Here's the sorted array:
+
+```swift
+[ -1, 0, 6, 7, 9, 11, 23, 92 ]
+```
+
+Now, all we must do is take the kth largest value, which is located at: `a[a.count - k] = a[8 - 4] = a[4] = 9`
+
+*Written by Daniel Speiser*

Kth Largest Element/kthLargest.playground/Contents.swift

@@ -0,0 +1,25 @@
+/*
+* Returns the k-th largest value inside of an array a.
+* This is an O(n log n) solution since we sort the array.
+*/
+func kthLargest(a: [Int], k: Int) -> Int? {
+    let len = a.count
+    
+    if (k <= 0 || k > len || len < 1) { return nil }
+    
+    let sorted = a.sort()
+    
+    return sorted[len - k]
+}
+
+let a = [5, 1, 3, 2, 7, 6, 4]
+
+kthLargest(a, k: 0)
+kthLargest(a, k: 1)
+kthLargest(a, k: 2)
+kthLargest(a, k: 3)
+kthLargest(a, k: 4)
+kthLargest(a, k: 5)
+kthLargest(a, k: 6)
+kthLargest(a, k: 7)
+kthLargest(a, k: 8)

Kth Largest Element/kthLargest.playground/contents.xcplayground

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<playground version='5.0' target-platform='osx'>
+    <timeline fileName='timeline.xctimeline'/>
+</playground>

Kth Largest Element/kthLargest.playground/timeline.xctimeline

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Timeline
+   version = "3.0">
+   <TimelineItems>
+   </TimelineItems>
+</Timeline>

Kth Largest Element/kthLargest.swift

@@ -0,0 +1,13 @@
+/*
+* Returns the k-th largest value inside of an array a.
+* This is an O(n log n) solution since we sort the array.
+*/
+func kthLargest(a: [Int], k: Int) -> Int? {
+    let len = a.count
+    
+    if (k <= 0 || k > len || len < 1) { return nil }
+    
+    let sorted = a.sort()
+    
+    return sorted[len - k]
+}

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
 
@@ -50,7 +51,7 @@ If you're new to algorithms and data structures, here are a few good ones to sta
 - [Binary Search](Binary Search/). Quickly find elements in a sorted array.
 - [Count Occurrences](Count Occurrences/). Count how often a value appears in an array.
 - [Select Minimum / Maximum](Select Minimum Maximum). Find the minimum/maximum value in an array.
-- Select k-th Largest Element
+- [k-th Largest Element](Kth Largest Element/). Find the kth largest element in an array.
 - Selection Sampling
 - Union-Find
 
@@ -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