added mergesort code

Author: kelvinlauKL

Mergesort/README.markdown

@@ -34,4 +34,62 @@ Given `[2]` `[1]` `[5]` `[4]` `[9]`, the first pass will result in `[1, 2]` and
 
 The next pass will merge `[1, 2]` and `[4, 5]` together. This results in `[1, 2, 4, 5]`, with the `[9]` left out again since it's the odd one out. 
 
-Since you're left with 2 piles, `[9]` finally gets it's chance to merge, resulting in the sorted array `[1, 2, 4, 5, 9]`. 
+Since you're left with 2 piles, `[9]` finally gets it's chance to merge, resulting in the sorted array `[1, 2, 4, 5, 9]`. 
+
+In code, it looks like this:
+
+```
+let array = [2, 1, 5, 4, 9]
+
+func mergeSort(array: [Int]) -> [Int] {
+
+  // base case - if the unsortedArray has less than 2 elements - aka 1 element, simply return, no need to split further
+  if array.count < 2 { return array }
+  let middleIndex = array.count / 2
+
+  // recursively split the left side of the array
+  let leftArray = mergeSort(Array(array[0..<middleIndex]))
+
+  // recursively split the right side of the array
+  let rightArray = mergeSort(Array(array[middleIndex..<array.count]))
+
+  // at this point, you should have n piles of arrays with a single element. Time to merge
+  return merge(leftPile: leftArray, rightPile: rightArray)
+}
+
+func merge(leftPile leftPile: [Int], rightPile: [Int]) -> [Int] {
+  var leftIndex = 0
+  var rightIndex = 0
+
+  // orderedPile will be the result of the merge
+  var orderedPile = [Int]()
+
+  // insert
+  while leftIndex < leftPile.count && rightIndex < rightPile.count {
+    if leftPile[leftIndex] < rightPile[rightIndex] {
+      orderedPile.append(leftPile[leftIndex])
+      leftIndex += 1
+    } else if leftPile[leftIndex] > rightPile[rightIndex] {
+      orderedPile.append(rightPile[rightIndex])
+      rightIndex += 1
+    } else {
+      orderedPile.append(leftPile[leftIndex])
+      leftIndex += 1
+      orderedPile.append(rightPile[rightIndex])
+      rightIndex += 1
+    }
+  }
+
+  while leftIndex < leftPile.count {
+    orderedPile.append(leftPile[leftIndex])
+    leftIndex += 1
+  }
+
+  while rightIndex < rightPile.count {
+    orderedPile.append(rightPile[rightIndex])
+    rightIndex += 1
+  }
+
+  return orderedPile
+}
+```