快速排序是最常用的排序方法。
    时间复杂度： O(nLog^n)
    快速排序也采用的分支的方法，但是没有像归并排序那样彻底分割
    步骤

    1. 从数组中间选择一项作为主元
    2. 创建两个指针，左边一个纸箱数组第一个项，右边指向最后一个项，移动左边指针直到找到一个比主元大的项，接着，移动右指针直到找一个一个比主元小的项，然后交换他们，重复此步骤。直到左指针超过了右指针。这个过程将使得比主元小的元素都在左边， 大的都在右边。这一步叫做划分操作
    3. 接着，算法对划分后的小数组重复 1 、2 步骤，直至数组完全排序

    JavaScript

    1. const arr = [4,77,2,5,33,4,2,7,9,4,666,333,2,555,66,4,234]
    3. function partition (arr, left, right) {
    4.   var pivot = arr[Math.floor((left + right) / 2)]
    5.   let i = left
    6.   let j = right
    7.   console.log('pivot', pivot, i, j)
    8.   while (i <= j) {
    9.     while (arr[i] < pivot) {
    10.       i++
    11.     }
    12.     while (arr[j] > pivot) {
    13.       j--
    14.     }
    15.     if (i <= j) {
    16.       swap(arr, i, j)
    17.       i++
    18.       j--
    19.     }
    20.   }
    21.   return i
    22. }
    23. function quick(arr, left, right) {
    24.   let index = 0
    25.   if (arr.length > 1) {
    26.     index = partition(arr, left, right)
    27.     if (left < index - 1) {
    28.       quick(arr,left,index - 1)
    29.     }
    30.     if (index < right) {
    31.       quick(arr,index,right)
    32.     }
    33.   }
    34.   return arr
    35. }
    37. function swap(arr, i, j) {
    38.   let temp = arr[i]
    39.   arr[i] = arr[j]
    40.   arr[j] = temp
    41. }
    44. console.log(quick(arr, 0, arr.length - 1));

    Swift

    1.     func patition( arr:inout Array<Int>, left: Int, right: Int) -> Int {
    2.         let pivot = arr[(left + right) / 2]
    3.         var i = left
    4.         var j = right
    5.         while i <= j {
    6.             while arr[i] < pivot {
    7.                 i = i + 1
    8.             }
    10.             while arr[j] > pivot {
    11.                 j = j - 1
    12.             }
    13.             if i <= j {
    14.                 arr.swapAt(i, j)
    15.                 i = i + 1
    16.                 j = j - 1
    17.             }
    18.         }
    19.         return i
    20.     }
    22.     func quick(arr: inout Array<Int>, left: Int, right: Int) -> Array<Int> {
    23.         if arr.count == 1 {
    24.             return arr
    25.         }
    26.         var index = 0
    27.         if arr.count > 0 {
    28.             index = patition(arr: &arr, left: left, right: right)
    29.             if left < index - 1 {
    30.             let _ = quick(arr: &arr, left: left, right: index - 1)
    31.             }
    32.             if index < right {
    33.               let _ =  quick(arr: &arr, left: index, right: right)
    34.             }
    35.         }
    36.         return arr
    37.     }