Merge pull request kodecocodes#281 from divyenduz/migrate_bucket_sort

Bucket sort migration to swift 3

Author: kelvinlauKL

.travis.yml

@@ -16,7 +16,7 @@ script:
 - xcodebuild test -project ./Bloom\ Filter/Tests/Tests.xcodeproj -scheme Tests
 # - xcodebuild test -project ./Bounded\ Priority\ Queue/Tests/Tests.xcodeproj -scheme Tests
 # - xcodebuild test -project ./Breadth-First\ Search/Tests/Tests.xcodeproj -scheme Tests
-# - xcodebuild test -project ./Bucket\ Sort/Tests/Tests.xcodeproj -scheme Tests
+- xcodebuild test -project ./Bucket\ Sort/Tests/Tests.xcodeproj -scheme Tests
 - xcodebuild test -project ./B-Tree/Tests/Tests.xcodeproj -scheme Tests
 # - xcodebuild test -project ./Counting\ Sort/Tests/Tests.xcodeproj -scheme Tests
 # - xcodebuild test -project ./Depth-First\ Search/Tests/Tests.xcodeproj -scheme Tests

Bucket Sort/BucketSort.playground/Contents.swift

@@ -20,9 +20,6 @@
 //
 //
 
-
-
-
 //////////////////////////////////////
 // MARK: Extensions
 //////////////////////////////////////
@@ -38,8 +35,8 @@ extension Int: IntConvertible, Sortable {
 //////////////////////////////////////
 
 let input = [1, 2, 4, 6, 10]
-let buckets = [Bucket<Int>(capacity: 15), Bucket<Int>(capacity: 15), Bucket<Int>(capacity: 15)]
+var buckets = [Bucket<Int>(capacity: 15), Bucket<Int>(capacity: 15), Bucket<Int>(capacity: 15)]
 
-let sortedElements = bucketSort(input, distributor: RangeDistributor(), sorter: InsertionSorter(), buckets: buckets)
+let sortedElements = bucketSort(elements: input, distributor: RangeDistributor(), sorter: InsertionSorter(), buckets: &buckets)
 
 print(sortedElements)

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

@@ -27,16 +27,15 @@ import Foundation
 //////////////////////////////////////
 
 
-public func bucketSort<T: Sortable>(elements: [T], distributor: Distributor, sorter: Sorter, buckets: [Bucket<T>]) -> [T] {
-  var bucketsCopy = buckets
+public func bucketSort<T: Sortable>(elements: [T], distributor: Distributor, sorter: Sorter, buckets: inout [Bucket<T>]) -> [T] {
   for elem in elements {
-    distributor.distribute(elem, buckets: &bucketsCopy)
+    distributor.distribute(element: elem, buckets: &buckets)
   }
 
   var results = [T]()
 
   for bucket in buckets {
-    results += bucket.sort(sorter)
+    results += bucket.sort(algorithm: sorter)
   }
 
   return results
@@ -48,7 +47,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>])
 }
 
 /*
@@ -70,12 +69,12 @@ public struct RangeDistributor: Distributor {
 
   public init() {}
 
-  public func distribute<T: Sortable>(element: T, inout buckets: [Bucket<T>]) {
+  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(element)
+    buckets[bucketIndex].add(item: element)
   }
 }
 
@@ -139,6 +138,6 @@ public struct Bucket<T:Sortable> {
   }
 
   public func sort(algorithm: Sorter) -> [T] {
-    return algorithm.sort(elements)
+    return algorithm.sort(items: elements)
   }
 }

Bucket Sort/BucketSort.swift

@@ -21,6 +21,30 @@
 //
 
 import Foundation
+// FIXME: comparison operators with optionals were removed from the Swift Standard Libary.
+// Consider refactoring the code to use the non-optional operators.
+fileprivate func < <T : Comparable>(lhs: T?, rhs: T?) -> Bool {
+  switch (lhs, rhs) {
+  case let (l?, r?):
+    return l < r
+  case (nil, _?):
+    return true
+  default:
+    return false
+  }
+}
+
+// FIXME: comparison operators with optionals were removed from the Swift Standard Libary.
+// Consider refactoring the code to use the non-optional operators.
+fileprivate func >= <T : Comparable>(lhs: T?, rhs: T?) -> Bool {
+  switch (lhs, rhs) {
+  case let (l?, r?):
+    return l >= r
+  default:
+    return !(lhs < rhs)
+  }
+}
+
 
 //////////////////////////////////////
 // MARK: Main algorithm
@@ -39,7 +63,7 @@ import Foundation
     - Returns: A new array with sorted elements
  */
 
-public func bucketSort<T: Sortable>(elements: [T], distributor: Distributor, sorter: Sorter, buckets: [Bucket<T>]) -> [T] {
+public func bucketSort<T: Sortable>(_ elements: [T], distributor: Distributor, sorter: Sorter, buckets: [Bucket<T>]) -> [T] {
     precondition(allPositiveNumbers(elements))
     precondition(enoughSpaceInBuckets(buckets, elements: elements))
 
@@ -57,12 +81,12 @@ public func bucketSort<T: Sortable>(elements: [T], distributor: Distributor, sor
     return results
 }
 
-private func allPositiveNumbers<T: Sortable>(array: [T]) -> Bool {
+private func allPositiveNumbers<T: Sortable>(_ array: [T]) -> Bool {
     return array.filter { $0.toInt() >= 0 }.count > 0
 }
 
-private func enoughSpaceInBuckets<T: Sortable>(buckets: [Bucket<T>], elements: [T]) -> Bool {
-    let maximumValue = elements.maxElement()?.toInt()
+private func enoughSpaceInBuckets<T: Sortable>(_ buckets: [Bucket<T>], elements: [T]) -> Bool {
+    let maximumValue = elements.max()?.toInt()
     let totalCapacity = buckets.count * (buckets.first?.capacity)!
 
     return totalCapacity >= maximumValue
@@ -74,7 +98,7 @@ private func enoughSpaceInBuckets<T: Sortable>(buckets: [Bucket<T>], elements: [
 
 
 public protocol Distributor {
-    func distribute<T: Sortable>(element: T, inout buckets: [Bucket<T>])
+    func distribute<T: Sortable>(_ element: T, buckets: inout [Bucket<T>])
 }
 
 /*
@@ -96,7 +120,7 @@ public struct RangeDistributor: Distributor {
 
     public init() {}
 
-    public func distribute<T: Sortable>(element: T, inout buckets: [Bucket<T>]) {
+    public func distribute<T: Sortable>(_ element: T, buckets: inout [Bucket<T>]) {
         let value = element.toInt()
         let bucketCapacity = buckets.first!.capacity
 
@@ -121,14 +145,14 @@ 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] {
+    public func sort<T: Sortable>(_ items: [T]) -> [T] {
         var results = items
         for i in 0 ..< results.count {
             var j = i
@@ -158,13 +182,13 @@ public struct Bucket<T:Sortable> {
         elements = [T]()
     }
 
-    public mutating func add(item: T) {
+    public mutating func add(_ item: T) {
         if elements.count < capacity {
             elements.append(item)
         }
     }
 
-    public func sort(algorithm: Sorter) -> [T] {
+    public func sort(_ algorithm: Sorter) -> [T] {
         return algorithm.sort(elements)
     }
 }

Bucket Sort/README.markdown

@@ -9,16 +9,16 @@ Bucket Sort, also known as Bin Sort, is a distributed sorting algorithm, which s
 See the algorithm in action [here](https://www.cs.usfca.edu/~galles/visualization/BucketSort.html) and [here](http://www.algostructure.com/sorting/bucketsort.php).
 
 The performance for execution time is:  
-  
+
 | Case  | Performance |
 |:-------------: |:---------------:|
 | Worst       |  O(n^2) |
 | Best      | 	Omega(n + k)        |
-|  Average | 	Theta(n + k)       | 
-  
+|  Average | 	Theta(n + k)       |
+
 Where **n** = the number of elements and **k** is the number of buckets.
 
-In the *best case*, the algorithm distributes the elements uniformily between buckets, a few elements are placed on each bucket and sorting the buckets is **O(1)**. Rearranging the elements is one more run through the initial list.  
+In the *best case*, the algorithm distributes the elements uniformly between buckets, a few elements are placed on each bucket and sorting the buckets is **O(1)**. Rearranging the elements is one more run through the initial list.  
 
 In the *worst case*, the elements are sent all to the same bucket, making the process take **O(n^2)**.
 
@@ -63,11 +63,11 @@ So the buckets are:
 Now we need to choose a distribution function.  
 
 `bucketNumber = (elementValue / totalNumberOfBuckets) + 1`  
-   
+
 Such that by applying that function we distribute all the elements in the buckets.  
 
 In our example it is like the following:  
-  
+
 1. Apply the distribution function to `2`. `bucketNumber = (2 / 10) + 1 = 1`
 2. Apply the distribution function to `56`. `bucketNumber = (56 / 10) + 1 = 6`
 3. Apply the distribution function to `4`. `bucketNumber = (4 / 10) + 1 = 1`
@@ -91,12 +91,12 @@ Our buckets will be filled now:
 
 We can choose to insert the elements in every bucket in order, or sort every bucket after distributing all the elements.  
 
-### Put the elements back in the list 
+### Put the elements back in the list
 
 Finally we go through all the buckets and put the elements back in the list:  
-  
+
   `[2,  4,  26,  55,  56,  77,  98]`  
-  
+
 
 ## Swift implementation
 
@@ -109,9 +109,9 @@ Here is a diagram that shows the functions, data structures and protocols for ou
 `bucketSort()` is a generic function that can apply the algorithm to any element of type `T`, as long as `T` is `Sortable`.
 
 ```swift
-public func bucketSort<T:Sortable>(elements: [T], 
-                                distributor: Distributor, 
-                                     sorter: Sorter, 
+public func bucketSort<T:Sortable>(elements: [T],
+                                distributor: Distributor,
+                                     sorter: Sorter,
                                     buckets: [Bucket<T>]) -> [T] {
 	precondition(allPositiveNumbers(elements))
 	precondition(enoughSpaceInBuckets(buckets, elements: elements))
@@ -201,11 +201,11 @@ public struct InsertionSorter: Sorter {
 		for i in 0 ..< results.count {
 			var j = i
 			while ( j > 0 && results[j-1] > results[j]) {
-			
+
 				let auxiliar = results[j-1]
 				results[j-1] = results[j]
 				results[j] = auxiliar
-			
+
 				j -= 1
 			}
 		}
@@ -236,7 +236,7 @@ public struct RangeDistributor: Distributor {
 	 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)
 	}

Bucket Sort/Tests/Tests.swift

@@ -25,7 +25,7 @@ class TestTests: XCTestCase {
 
         largeArray = [Int]()
         for _ in 0..<total {
-            largeArray!.append( random() % maximum )
+            largeArray!.append( Int(arc4random_uniform( UInt32( maximum ) ) ) )
         }
 
         sparsedArray = [Int]()
@@ -57,9 +57,9 @@ class TestTests: XCTestCase {
 
     // MARK: Private functions
 
-    private func performBucketSort(elements: [Int], totalBuckets: Int) -> [Int] {
+    fileprivate func performBucketSort(_ elements: [Int], totalBuckets: Int) -> [Int] {
 
-        let value = (elements.maxElement()?.toInt())! + 1
+        let value = (elements.max()?.toInt())! + 1
         let capacityRequired = Int( ceil( Double(value) / Double(totalBuckets) ) )
 
         var buckets = [Bucket<Int>]()
@@ -71,7 +71,7 @@ class TestTests: XCTestCase {
         return results
     }
 
-    func isSorted(array: [Int]) -> Bool {
+    func isSorted(_ array: [Int]) -> Bool {
 
         var index = 0
         var sorted = true

Bucket Sort/Tests/Tests.xcodeproj/project.pbxproj

@@ -88,6 +88,7 @@
 				TargetAttributes = {
 					7B2BBC7F1C779D720067B71D = {
 						CreatedOnToolsVersion = 7.2;
+						LastSwiftMigration = 0810;
 					};
 				};
 			};
@@ -222,6 +223,7 @@
 				PRODUCT_BUNDLE_IDENTIFIER = swift.algorithm.club.Tests;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				SWIFT_OPTIMIZATION_LEVEL = "-Onone";
+				SWIFT_VERSION = 3.0;
 			};
 			name = Debug;
 		};
@@ -234,6 +236,7 @@
 				LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/../Frameworks @loader_path/../Frameworks";
 				PRODUCT_BUNDLE_IDENTIFIER = swift.algorithm.club.Tests;
 				PRODUCT_NAME = "$(TARGET_NAME)";
+				SWIFT_VERSION = 3.0;
 			};
 			name = Release;
 		};