Spell mergesort as merge sort

Add a bottom-up implementation
Plus other small tweaks

Author: hollance

Merge Sort/MergeSort.playground/Contents.swift

@@ -0,0 +1,99 @@
+/* Top-down recursive version */
+
+func mergeSort(array: [Int]) -> [Int] {
+  guard array.count > 1 else { return array }
+  let middleIndex = array.count / 2
+  let leftArray = mergeSort(Array(array[0..<middleIndex]))
+  let rightArray = mergeSort(Array(array[middleIndex..<array.count]))
+  return merge(leftPile: leftArray, rightPile: rightArray)
+}
+
+func merge(leftPile leftPile: [Int], rightPile: [Int]) -> [Int] {
+  var leftIndex = 0
+  var rightIndex = 0
+  var orderedPile = [Int]()
+
+  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
+}
+
+let array = [2, 1, 5, 4, 9]
+let sortedArray = mergeSort(array)
+
+
+
+/* Bottom-up iterative version */
+
+func mergeSortBottomUp<T>(a: [T], _ isOrderedBefore: (T, T) -> Bool) -> [T] {
+  let n = a.count
+  var z = [a, a]   // the two working arrays
+  var d = 0        // z[d] is used for reading, z[1 - d] for writing
+  
+  var width = 1
+  while width < n {
+  
+    var i = 0
+    while i < n {
+
+      var j = i
+      var l = i
+      var r = i + width
+      
+      let lmax = min(l + width, n)
+      let rmax = min(r + width, n)
+      
+      while l < lmax && r < rmax {
+        if isOrderedBefore(z[d][l], z[d][r]) {
+          z[1 - d][j] = z[d][l]
+          l += 1
+        } else {
+          z[1 - d][j] = z[d][r]
+          r += 1
+        }
+        j += 1
+      }
+      while l < lmax {
+        z[1 - d][j] = z[d][l]
+        j += 1
+        l += 1
+      }
+      while r < rmax {
+        z[1 - d][j] = z[d][r]
+        j += 1
+        r += 1
+      }
+
+      i += width*2
+    }
+    
+    width *= 2   // in each step, the subarray to merge becomes larger
+    d = 1 - d    // swap active array
+  }
+  return z[d]
+}
+
+mergeSortBottomUp(array, <)

Mergesort/Mergesort.playground/contents.xcplayground renamed to Merge Sort/MergeSort.playground/contents.xcplayground

@@ -0,0 +1,108 @@
+//
+//  Mergesort.swift
+//  
+//
+//  Created by Kelvin Lau on 2016-02-03.
+//
+//
+
+func mergeSort(array: [Int]) -> [Int] {
+  guard array.count > 1 else { return array }
+  let middleIndex = array.count / 2
+  let leftArray = mergeSort(Array(array[0..<middleIndex]))
+  let rightArray = mergeSort(Array(array[middleIndex..<array.count]))
+  return merge(leftPile: leftArray, rightPile: rightArray)
+}
+
+func merge(leftPile leftPile: [Int], rightPile: [Int]) -> [Int] {
+  var leftIndex = 0
+  var rightIndex = 0
+  var orderedPile = [Int]()
+
+  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
+}
+
+/*
+  This is an iterative bottom-up implementation. Instead of recursively splitting
+  up the array into smaller sublists, it immediately starts merging the individual
+  array elements.
+
+  As the algorithm works its way up, it no longer merges individual elements but
+  larger and larger subarrays, until eventually the entire array is merged and
+  sorted.
+
+  To avoid allocating many temporary array objects, it uses double-buffering with
+  just two arrays.
+*/
+func mergeSortBottomUp<T>(a: [T], _ isOrderedBefore: (T, T) -> Bool) -> [T] {
+  let n = a.count
+  var z = [a, a]   // the two working arrays
+  var d = 0        // z[d] is used for reading, z[1 - d] for writing
+  
+  var width = 1
+  while width < n {
+    
+    var i = 0
+    while i < n {
+      
+      var j = i
+      var l = i
+      var r = i + width
+      
+      let lmax = min(l + width, n)
+      let rmax = min(r + width, n)
+      
+      while l < lmax && r < rmax {
+        if isOrderedBefore(z[d][l], z[d][r]) {
+          z[1 - d][j] = z[d][l]
+          l += 1
+        } else {
+          z[1 - d][j] = z[d][r]
+          r += 1
+        }
+        j += 1
+      }
+      while l < lmax {
+        z[1 - d][j] = z[d][l]
+        j += 1
+        l += 1
+      }
+      while r < rmax {
+        z[1 - d][j] = z[d][r]
+        j += 1
+        r += 1
+      }
+      
+      i += width*2
+    }
+    
+    width *= 2   // in each step, the subarray to merge becomes larger
+    d = 1 - d    // swap active array
+  }
+  return z[d]
+}