Updated Bucket Sort to Swift 3.0

Author: KBryan

Bucket Sort/BucketSort.playground/Sources/BucketSort.swift

@@ -28,18 +28,18 @@ import Foundation
 
 
 public func bucketSort<T: Sortable>(elements: [T], distributor: Distributor, sorter: Sorter, buckets: [Bucket<T>]) -> [T] {
-  var bucketsCopy = buckets
-  for elem in elements {
-    distributor.distribute(elem, buckets: &bucketsCopy)
-  }
-
-  var results = [T]()
-
-  for bucket in buckets {
-    results += bucket.sort(sorter)
-  }
-
-  return results
+    var bucketsCopy = buckets
+    for elem in elements {
+        distributor.distribute(element: elem, buckets: &bucketsCopy)
+    }
+    
+    var results = [T]()
+    
+    for bucket in buckets {
+        results += bucket.sort(algorithm: sorter)
+    }
+    
+    return results
 }
 
 //////////////////////////////////////
@@ -48,7 +48,7 @@ public func bucketSort<T: Sortable>(elements: [T], distributor: Distributor, sor
 
 
 public protocol Distributor {
-  func distribute<T: Sortable>(element: T, inout buckets: [Bucket<T>])
+    func distribute<T: Sortable>(element: T, buckets: inout [Bucket<T>])
 }
 
 /*
@@ -67,24 +67,24 @@ public protocol Distributor {
  * By following the formula: element / capacity = #ofBucket
  */
 public struct RangeDistributor: Distributor {
-
-  public init() {}
-
-  public func distribute<T: Sortable>(element: T, inout buckets: [Bucket<T>]) {
-    let value = element.toInt()
-    let bucketCapacity = buckets.first!.capacity
-
-    let bucketIndex = value / bucketCapacity
-    buckets[bucketIndex].add(element)
-  }
+    
+    public init() {}
+    
+    public func distribute<T: Sortable>(element: T, buckets: inout [Bucket<T>]) {
+        let value = element.toInt()
+        let bucketCapacity = buckets.first!.capacity
+        
+        let bucketIndex = value / bucketCapacity
+        buckets[bucketIndex].add(item: element)
+    }
 }
 
 //////////////////////////////////////
 // MARK: Sortable
 //////////////////////////////////////
 
 public protocol IntConvertible {
-  func toInt() -> Int
+    func toInt() -> Int
 }
 
 public protocol Sortable: IntConvertible, Comparable {
@@ -95,50 +95,50 @@ public protocol Sortable: IntConvertible, Comparable {
 //////////////////////////////////////
 
 public protocol Sorter {
-  func sort<T: Sortable>(items: [T]) -> [T]
+    func sort<T: Sortable>(items: [T]) -> [T]
 }
 
 public struct InsertionSorter: Sorter {
-
-  public init() {}
-
-  public func sort<T: Sortable>(items: [T]) -> [T] {
-    var results = items
-    for i in 0 ..< results.count {
-      var j = i
-      while j > 0 && results[j-i] > results[j] {
-
-        let auxiliar = results[i]
-        results[i] = results[j]
-        results[j] = auxiliar
-
-        j -= 1
-      }
+    
+    public init() {}
+    
+    public func sort<T: Sortable>(items: [T]) -> [T] {
+        var results = items
+        for i in 0 ..< results.count {
+            var j = i
+            while j > 0 && results[j-i] > results[j] {
+                
+                let auxiliar = results[i]
+                results[i] = results[j]
+                results[j] = auxiliar
+                
+                j -= 1
+            }
+        }
+        return results
     }
-    return results
-  }
 }
 
 //////////////////////////////////////
 // MARK: Bucket
 //////////////////////////////////////
 
 public struct Bucket<T:Sortable> {
-  var elements: [T]
-  let capacity: Int
-
-  public init(capacity: Int) {
-    self.capacity = capacity
-    elements = [T]()
-  }
-
-  public mutating func add(item: T) {
-    if elements.count < capacity {
-      elements.append(item)
+    var elements: [T]
+    let capacity: Int
+    
+    public init(capacity: Int) {
+        self.capacity = capacity
+        elements = [T]()
+    }
+    
+    public mutating func add(item: T) {
+        if elements.count < capacity {
+            elements.append(item)
+        }
+    }
+    
+    public func sort(algorithm: Sorter) -> [T] {
+        return algorithm.sort(items: elements)
     }
-  }
-
-  public func sort(algorithm: Sorter) -> [T] {
-    return algorithm.sort(elements)
-  }
 }