快速排序

基本原理

递归实现如下过程：
取数组中一个数作为判断标准，将小于或等于这个数的放在这个数左边，大于这个数的放在这个数右边，然后对该数左右段子数组继续如上过程，直到子数组无法被划分。

分解：数组A[p..r]被划分为两个（可能为空）子数组A[p..q-1]和A[q+1..r]，使得A[p..q-1]中的每一个元素都小于等于A[q]，而A[q]也小于等于A[q+1..r]中的每个元素。其中，计算下标q也是划分过程的一部分
解决：通过递归调用快速排序，对子数组A[p..q-1]和A[q+1..r]进行排序
合并：因为子数组都是原址排序的，所以不需要合并操作：数组A[p..r]已经有序

伪代码

QUICKSORT伪代码：

QUICKSORT(A,p,r)
if(p<r)
    q=SPLIT(A,p,r)
    QUICKSORT(A,p,q-1)
    QUICKSORT(A,q+1,r)

SPLIT伪代码：

SPLIT(A,p,r)
    i=p-1
    x=A[r]
    for j=p to r-1
        if(A[j]<=x)
        then 
            i=i+1
            交换A[i]和A[j]
        end if
    end for
    交换A[i+1]和A[r]
    return i+1

时间复杂度和空间复杂度分析

时间复杂度：
最坏划分：O（n^2）
最好划分：O（nlgn）
平均划分：O（nlgn）

空间复杂度
快排在原数组上直接进行排序

C++实现代码

#include<iostream>
using namespace std;

int split(int *A, int p, int r){
    int i = p - 1;
    int x = A[r];
    for (int j = p; j < r; ++j){
        if (A[j] <= x){
            ++i;
            int temp = A[i];
            A[i] = A[j];
            A[j] = temp;
        }
    }
    A[r] = A[i + 1];
    A[i + 1] = x;
    return i + 1;
}

void quickSort(int *A, int p, int r){
    if (p < r){
        int q = split(A, p, r);
        quickSort(A, p, q - 1);
        quickSort(A, q + 1, r);
    }
}
int main()
{
    int A[] = { 1, 8, 4, 2, 7, 6, 3, 0, 5, 0 };
    quickSort(A, 0, 9);
    for (int i = 0; i < 10; ++i){
        cout << A[i] << " ";
    }
    cout << endl;
    return 0;
}