快速排序

思路

像合并排序一样，快速排序是基于分支模式的：

• 分解：数组A[n]被划分两个字数组A[0..q-1]和A[q+1..n],使得对于数组A[0..q-1]中的元素都小于A[q], A[q+1..n]中的元素都大于等于A[q]。此时A[q]就得排好序。
• 解决：通过递归调用快速排序，对字数组A[0..q-1]和A[q+1..n]进行排序
• 合并：因为两个字数组已经是就地排好序的了，整个数组已经排好序了。

参考代码

按照以上模式可以写出程序：

void quickSort(int A[], int beg, int end)
{
    if (A == NULL || beg > end)
        return;
    int part = getPartition(A, beg, end);
    quickSort(A, beg, part-1);
    quickSort(A, part+1, end);
}

关键是找出划分元素的位置函数getPartition，程序如下：其中一次运行过程，如下：

int getPartition(int *a, int beg, int end)
{
    if (beg <= end)
    {
        int part = beg;
        for(int i = beg+1; i <= end; ++i)
        {
            if(a[i] <= a[beg])
            {
                swap(a[part+1], a[i]);
                ++part;
            }
        }
        swap(a[beg], a[part]);
        return part;
    }
}

图示

      

最后，数组的最后一个元素找到了自己最终的位置上，把左右分成了两个相对独立的数组。

通过图示可以看出规律：

测试

#include <iostream>
using namespace std;
int getPartition(int *a, int beg, int end)
{
    if (beg <= end)
    {
        int part = beg;
        for(int i = beg+1; i <= end; ++i)
        {
            if(a[i] <= a[beg])
            {
                swap(a[part+1], a[i]);
                ++part;
            }
        }
        swap(a[beg], a[part]);
        return part;
    }
}

void quickSort(int *a, int beg, int end)
{
    if (a == NULL || beg >= end)
        return;
    int part = getPartition(a, beg, end);
    quickSort(a, beg, part-1);
    quickSort(a, part+1, end);
}

void tranverse(int *a, int len)
{
    for(int i = 0; i < len; ++i)
    {
        cout << a[i] << " ";
    }
    cout << endl;
}
int main()
{
    int a[] = {3, 9, 0, 1, 3, 2, 2, 7};
    int len =  sizeof(a) / sizeof(int);
    tranverse(a, len);
    quickSort(a, 0, len-1);
    tranverse(a, len);
}

性能

时间复杂度：就平均性能而言，快速排序是目前被认为是最好的一种内部排序方法。通常认为快速排序在平均情况下的时间复杂度为O(nlogn)。若初始记录序列按关键字有序或基本有序，快速排序将蜕化为冒泡排序，其时间复杂度为O(n²)。

空间复杂度：最坏情况下，若每趟排序之后，枢轴位置均偏向子序列的一端（有序），栈的最大深度为n。如果在一趟划分之后比较分割所得两部分的长度，且先对长度短的子序列中的记录进行快速排序，则栈的最大深度可降为O(logn)。

性能改善：在区间选取随机数，把该数放在应在的位置，可以有效避免最坏情况。如下

RANDOMIZED-PARTITION(A,p,r)
   i = RANDOM(p,r)
   exchange A[r] <->A[j]
   return PARTITION(A,p,r)

稳定性

不稳定