Merge pull request kodecocodes#689 from KeithMorning/orign_master

Fix some issues in Kth Largest Element && Selection Sampling article

Author: kelvinlauKL

Binary Search Tree/README.markdown

@@ -268,7 +268,7 @@ If there are no more nodes to look at -- when `left` or `right` is nil -- then w
 Searching is a recursive process, but you can also implement it with a simple loop instead:
 
 ```swift
-  public func search(value: T) -> BinarySearchTree? {
+  public func search(_ value: T) -> BinarySearchTree? {
     var node: BinarySearchTree? = self
     while let n = node {
       if value < n.value {

Kth Largest Element/README.markdown

@@ -40,7 +40,7 @@ Now, all we must do is take the value at index `a.count - k`:
 a[a.count - k] = a[8 - 4] = a[4] = 9
 ```
 
-Of course, if you were looking for the k-th *smallest* element, you'd use `a[k]`.
+Of course, if you were looking for the k-th *smallest* element, you'd use `a[k-1]`.
 
 ## A faster solution
 
@@ -84,29 +84,29 @@ The index of pivot `9` is 4, and that's exactly the *k* we're looking for. We're
 The following function implements these ideas:
 
 ```swift
-public func randomizedSelect<T: Comparable>(array: [T], order k: Int) -> T {
+public func randomizedSelect<T: Comparable>(_ array: [T], order k: Int) -> T {
   var a = array
 
-  func randomPivot<T: Comparable>(inout a: [T], _ low: Int, _ high: Int) -> T {
+  func randomPivot<T: Comparable>(_ a: inout [T], _ low: Int, _ high: Int) -> T {
     let pivotIndex = random(min: low, max: high)
-    swap(&a, pivotIndex, high)
+    a.swapAt(pivotIndex, high)
     return a[high]
   }
 
-  func randomizedPartition<T: Comparable>(inout a: [T], _ low: Int, _ high: Int) -> Int {
+  func randomizedPartition<T: Comparable>(_ a: inout [T], _ low: Int, _ high: Int) -> Int {
     let pivot = randomPivot(&a, low, high)
     var i = low
     for j in low..<high {
       if a[j] <= pivot {
-        swap(&a, i, j)
+        a.swapAt(i, j)
         i += 1
       }
     }
-    swap(&a, i, high)
+    a.swapAt(i, high)
     return i
   }
 
-  func randomizedSelect<T: Comparable>(inout a: [T], _ low: Int, _ high: Int, _ k: Int) -> T {
+  func randomizedSelect<T: Comparable>(_ a: inout [T], _ low: Int, _ high: Int, _ k: Int) -> T {
     if low < high {
       let p = randomizedPartition(&a, low, high)
       if k == p {

Selection Sampling/README.markdown

@@ -193,7 +193,7 @@ print(output.count)
 
 The performance of this second algorithm is **O(n)** as it may require a pass through the entire input array.
 
-> **Note:** If `k > n/2`, then it's more efficient to do it the other way around and choose `k` items to remove.
+> **Note:** If `k > n/2`, then it's more efficient to do it the other way around and choose `a.count - k` items to remove.
 
 Based on code from Algorithm Alley, Dr. Dobb's Magazine, October 1993.