Small tweaks to the text

Author: hollance

Bucket Sort/BucketSort.swift

@@ -28,7 +28,7 @@ import Foundation
 
 
 /**
-    Perform buckets srot algorithm on the given input elements.
+    Performs bucket sort algorithm on the given input elements.
     [Bucket Sort Algorithm Reference](https://en.wikipedia.org/wiki/Bucket_sort)
 
     - Parameter elements:     Array of Sortable elements

Bucket Sort/README.markdown

@@ -1,15 +1,13 @@
 # Bucket Sort
 
-[Bucket Sort or Bin Sort](https://en.wikipedia.org/wiki/Bucket_sort) is a distributed sorting algorithm, which sort elements from an array by performing these steps:  
+Bucket Sort, also known as Bin Sort, is a distributed sorting algorithm, which sort elements from an array by performing these steps:  
 
 1) Distribute the elements into buckets or bins.  
 2) Sort each bucket individually.  
-3) Merge the buckets in order to produce a sort array as results.  
-
+3) Merge the buckets in order to produce a sorted array as the result.
 
 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 |
@@ -18,11 +16,11 @@ The performance for execution time is:
 | Best      | 	Omega(n + k)        |
 |  Average | 	Theta(n + k)       | 
 
-Where **n** = #elements and **k** = #buckets  
+Where **n** = the number of elements and **k** is the number of buckets.
 
-On 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.  
-On the **worst case** the elements are sent all to the same bucket, making the process takes *O(n^2)*.  
+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 *worst case*, the elements are sent all to the same bucket, making the process take **O(n^2)**.
 
 ## Pseudocode
 
@@ -39,22 +37,22 @@ A [pseudocode](https://en.wikipedia.org/wiki/Bucket_sort#Pseudocode) of the algo
 
 ## Graphically explained
 
-###Distribute elements in buckets  
+1) Distribute elements in buckets:
 
 ![distribution step](https://upload.wikimedia.org/wikipedia/commons/6/61/Bucket_sort_1.png)
 
-###Sorting inside every bucket and merging  
+2) Sorting inside every bucket and merging:
 
 ![sorting each bucket and merge](https://upload.wikimedia.org/wikipedia/commons/3/39/Bucket_sort_2.png)
 
-##An example
+## An example
 
 ### Input  
 
-Suppose we have the following list of elements:  `[2, 56, 4, 77, 26, 98, 55]`.  
-And we define 10 buckets will be used. To determine the capacity of each bucket we need to know the `maximum element value`, in this case `98`.  
+Suppose we have the following list of elements: `[2, 56, 4, 77, 26, 98, 55]`. Let's use 10 buckets. To determine the capacity of each bucket we need to know the *maximum element value*, in this case `98`.  
 
 So the buckets are:    
+
 * `bucket 1`: from 0 to 9
 * `bucket 2`: from 10 to 19
 * `bucket 3`: from 20 to 29
@@ -64,10 +62,11 @@ So the buckets are:
 
 Now we need to choose a distribution function.  
 
-`bucketNumber = ( elementValue / totalNumberOfBuckets) + 1`  
+`bucketNumber = (elementValue / totalNumberOfBuckets) + 1`  
 
-Such that applying that function we distribute all the elements in the buckets.  
-In our example it is like following:  
+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`
@@ -99,155 +98,162 @@ Finally we go through all the buckets and put the elements back in the list:
   `[2,  4,  26,  55,  56,  77,  98]`  
 
 
+## Swift implementation
 
-##Swift implementation
+Here is a diagram that shows the functions, data structures and protocols for our bucker sort implementation:
 
-###Classes
+![classes](Docs/BucketSort.png)
 
-![classes](https://github.com/barbaramartina/swift-algorithm-club/blob/BucketSort/Bucket%20Sort/Docs/BucketSort.png)
+#### Main function
 
-###Code
+`bucketSort()` is a generic function that can apply the algorithm to any element of type `T`, as long as `T` is `Sortable`.
 
-Bucket Sort implementation use the following functions, data structures and protocols:
+```swift
+public func bucketSort<T:Sortable>(elements: [T], 
+                                distributor: Distributor, 
+                                     sorter: Sorter, 
+                                    buckets: [Bucket<T>]) -> [T] {
+	precondition(allPositiveNumbers(elements))
+	precondition(enoughSpaceInBuckets(buckets, elements: elements))
 
-####Main function
+	var bucketsCopy = buckets
+	for elem in elements {
+		distributor.distribute(elem, buckets: &bucketsCopy)
+	}
 
-`bucketSort` is a generic function that can apply the algorithm to any element of type T, as long as T is Sortable.
+	var results = [T]()
 
-    public func bucketSort<T:Sortable>(elements: [T], distributor: Distributor,sorter: Sorter, buckets: [Bucket<T>]) -> [T] {
-        precondition(allPositiveNumbers(elements))
-        precondition(enoughSpaceInBuckets(buckets, elements: elements))
-    
-        var bucketsCopy = buckets
-        for elem in elements {
-            distributor.distribute(elem, buckets: &bucketsCopy)
-         }
-    
-        var results = [T]()
-    
-       for bucket in bucketsCopy {
-            results += bucket.sort(sorter)
-        }
-    
-        return results
-     }
+	for bucket in bucketsCopy {
+		results += bucket.sort(sorter)
+	}
 
+	return results
+}
+```
 
-####Bucket
+#### 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)
-            }
-         }
-    
-         public func sort(algorithm: Sorter) -> [T] {
-            return algorithm.sort(elements)
-         }
-    }
+```swift
+public struct Bucket<T:Sortable> {
+	var elements: [T]
+	let capacity: Int
 
-####Sortable
+	public init(capacity: Int) {
+		self.capacity = capacity
+		elements = [T]()
+	}
 
-    public protocol Sortable: IntConvertible, Comparable {
-    }
+	public mutating func add(item: T) {
+		if (elements.count < capacity) {
+			elements.append(item)
+		}
+	}
 
-####IntConvertible
+	public func sort(algorithm: Sorter) -> [T] {
+		return algorithm.sort(elements)
+	}
+}
+```
 
-The algorithm is designed to sort integers, so all the elements to be sorted should be mapped to an integer value.
+#### Sortable
+
+```swift
+public protocol Sortable: IntConvertible, Comparable {
+}
+```
 
-    public protocol IntConvertible {
-        func toInt() -> Int
-    }
+#### IntConvertible
+
+The algorithm is designed to sort integers, so all the elements to be sorted should be mapped to an integer value.
 
+```swift
+public protocol IntConvertible {
+	func toInt() -> Int
+}
+```
 
-####Sorter
+#### Sorter
 
-    public protocol Sorter {
-        func sort<T:Sortable>(items: [T]) -> [T]
-    }
+```swift
+public protocol Sorter {
+	func sort<T:Sortable>(items: [T]) -> [T]
+}
+```
 
-####Distributor
+#### Distributor
 
-    public protocol Distributor {
-        func distribute<T:Sortable>(element: T, inout buckets: [Bucket<T>])
-    }
+```swift
+public protocol Distributor {
+	func distribute<T:Sortable>(element: T, inout buckets: [Bucket<T>])
+}
+```
 
 ### Custom Sorter and Distributor
 
 The current implementation make use of the following implementations for *Sorter* and *Distributor*.  
 
 *Sorter*  
 
-    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-1] > results[j]) {
-                
-                    let auxiliar = results[j-1]
-                    results[j-1] = results[j]
-                    results[j] = auxiliar
-                
-                    j -= 1
-                }
-            }
-            return results
-        }
-    }
+```swift
+public struct InsertionSorter: Sorter {
+	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-1] > results[j]) {
+			
+				let auxiliar = results[j-1]
+				results[j-1] = results[j]
+				results[j] = auxiliar
+			
+				j -= 1
+			}
+		}
+		return results
+	}
+}
+```
 
 *Distributor*  
 
-    /*
-    * An example of a simple distribution function that send every elements to
-    * the bucket representing the range in which it fits.An
-    *
-    * If the range of values to sort is 0..<49 i.e, there could be 5 buckets of capacity = 10
-    * So every element will be classified by the ranges:
-    *
-    * -  0 ..< 10
-    * - 10 ..< 20
-    * - 20 ..< 30
-    * - 30 ..< 40
-    * - 40 ..< 50
-    *
-    * 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)
-        }
-    }
+```swift
+/*
+ * An example of a simple distribution function that send every elements to
+ * the bucket representing the range in which it fits.
+ *
+ * If the range of values to sort is 0..<49 i.e, there could be 5 buckets of capacity = 10
+ * So every element will be classified by the ranges:
+ *
+ * -  0 ..< 10
+ * - 10 ..< 20
+ * - 20 ..< 30
+ * - 30 ..< 40
+ * - 40 ..< 50
+ *
+ * By following the formula: element / capacity = #ofBucket
+ */
+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)
+	}
+}
+```
 
 ### Make your own version
 
 By reusing this code and implementing your own *Sorter* and *Distributor* you can experiment with different versions.
 
 ## Other variations of Bucket Sort
 
-The following are some of the variation to the General Bucket Sort implemented here:
+The following are some of the variation to the general [Bucket Sort](https://en.wikipedia.org/wiki/Bucket_sort) implemented here:
 
 - [Proxmap Sort](https://en.wikipedia.org/wiki/Bucket_sort#ProxmapSort)
 - [Histogram Sort](https://en.wikipedia.org/wiki/Bucket_sort#Histogram_sort)
 - [Postman Sort](https://en.wikipedia.org/wiki/Bucket_sort#Postman.27s_sort)
 - [Shuffle Sort](https://en.wikipedia.org/wiki/Bucket_sort#Shuffle_sort)
 
+*Written for Swift Algorithm Club by Barbara Rodeker. Images from Wikipedia.*

README.markdown

@@ -72,7 +72,7 @@ Fast sorts:
 
 Special-purpose sorts:
 
-- Bucket Sort
+- [Bucket Sort](Bucket Sort/) :construction:
 - [Counting Sort](Counting Sort/)
 - Radix Sort
 - [Topological Sort](Topological Sort/)