快速排序由C. A. R. Hoare在1962年提出。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列

基本步骤

三数取中

在快排的过程中，每一次我们要取一个元素作为枢纽值，以这个数字来将序列划分为两部分。在此我们采用三数取中法，也就是取左端、中间、右端三个数，然后进行排序，将中间数作为枢纽值。

1024555-20170108124741566-1283178705.png

根据枢纽值进行分割

1024555-20170108162758159-793891242.png 1024555-20170108162855675-777137351.png

代码实现

OC:

// 交换数组元素
- (void)swap:(NSMutableArray *)arr from:(int)a to:(int)b{
 
//    arr[a] = @([arr[a] intValue]+[arr[b] intValue]);
//    arr[b] = @([arr[a] intValue]-[arr[b] intValue]);
//    arr[a] = @([arr[a] intValue]-[arr[b] intValue]);
    NSNumber *temp = arr[a];
    arr[a] = arr[b];
    arr[b] = temp;
}
/**
 * 处理枢纽值
 */
- (void)dealPivot:(NSMutableArray *)arr left:(int)left right:(int)right{
    int mid = (left + right) / 2;
    if (arr[left] > arr[mid]) {
        [self swap:arr from:left to:mid];
    }
    if (arr[left] > arr[right]) {
        [self swap:arr from:left to:right];
    }
    if (arr[right] < arr[mid]) {
        [self swap:arr from:right to:mid];
        
    }
    [self swap:arr from:right-1 to:mid];
}

- (void)QuickSort:(NSMutableArray *)arr left:(int)left right:(int)right{
    if (left < right) {
        //获取枢纽值，并将其放在当前待处理序列末尾
        [self dealPivot:arr left:left right:right];
        //枢纽值被放在序列末尾
        int pivot = right - 1;
        //左指针
        int i = left;
        //右指针
        int j = right - 1;
        while (true) {
            while (arr[++i] < arr[pivot]) {
              
            }
            while (j > left && arr[--j] > arr[pivot]) {
            }
            if (i < j) {
                [self swap:arr from:i to:j];
            } else {
                break;
            }
        }
        if (i < right) {
            [self swap:arr from:i to:right-1];
            
        }
        [self QuickSort:arr left:left right:i-1];
        [self QuickSort:arr left:i+1 right:right];
        
    }

}

swift：

func swap(arr:inout Array<Int>,a:Int,b:Int) {
//        arr[a] = arr[a]+arr[b];
//        arr[b] = arr[a]-arr[b];
//        arr[a] = arr[a]-arr[b];
        let temp = arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }

 func dealPivot(arr:inout [Int],left:Int,right:Int){
        
        let mid:Int = (left + right) / 2;
        if arr[left] > arr[mid] {
            self.swap(arr: &arr, a: left, b: mid)
        }
        if arr[left] > arr[right] {
            swap(arr: &arr, a: left, b: right)
        }
        if (arr[right] < arr[mid]) {
            swap(arr: &arr, a: right, b: mid)
            
            
        }
        swap(arr: &arr, a: right-1, b: mid)
        
    }
    func QuickSort(arr:inout [Int],left:Int,right:Int){
        if (left < right) {
            //获取枢纽值，并将其放在当前待处理序列末尾
            dealPivot(arr: &arr, left: left, right: right)
            
            //枢纽值被放在序列末尾
            let pivot = right - 1;
            //左指针
            var i = left;
            //右指针
            var j = right - 1;
            while (true) {
                
                repeat{
                     i=i+1
                }while arr[i] < arr[pivot]
                
                repeat{
                    j=j-1
                }while j > left && arr[j] > arr[pivot]
                
                if i < j {
                    swap(arr: &arr, a: i, b: j)
                    
                } else {
                    break;
                }
            }
            if i < right {
                swap(arr: &arr, a: i, b: right-1)
            }
            QuickSort(arr: &arr, left: left, right: i-1)
            QuickSort(arr: &arr, left: i+1, right: right)
            
        }
    }

总结

快速排序是一种交换类的排序，它同样是分治法的经典体现。在一趟排序中将待排序的序列分割成两组，其中一部分记录的关键字均小于另一部分。然后分别对这两组继续进行排序，以使整个序列有序。在分割的过程中，枢纽值的选择至关重要，本文采取了三位取中法，可以很大程度上避免分组"一边倒"的情况。快速排序平均时间复杂度也为O(nlogn)级。