排序算法之快速排序

1）基本思想

快速排序的基本思想是在数组中选择一个枢纽元素，然后分别从数组的开始和结束位置处开始遍历数组，将比枢纽元素小的都移到枢纽元素的左边，将比枢纽元素大的元素都移到它的右边，然后递归对枢纽元素前面的元素和后面的元素进行排序。即：

这里的一个关键地方是如何选取枢纽元，有三种选择：

a. 选取数组的第一个元素 这种策略就是比较懒惰的将得到的数组的第一个元素作为枢纽元，如果数组元素是随机排列的，这是可行的。但如果数组是预排序或反序的，那么这将造成数组几乎所有的元素都落在S1或者S2中，这样一来，最终的时间复杂度将达到O(N^2)。

b. 利用随机数生成器产生随机枢纽元 一般来讲除非运气比较差会导致随机产生的枢纽元导致a中的结果，否则还是比较安全的。但是随机数生成器的使用成本还是很高的，它会抵消节省下来的平均运行时间。

c.  三数中值法 这种方式分别取出数组元素的第一个元素，中间的元素和最后一个元素进行排序并将中值作为枢纽元，最终的结果是三者中最小的元素放在了数组的起始位置，最大的元素放到了数组的最后的位置，三者中的中值放在了中间位置上。

这里选择c中的方法来选取枢纽元，并将枢纽元移至数组的倒数第二个位置，从数组的第二个位置和数组的倒数第三个位置开始遍历数组，设为位置i和j，当i处的元素大于等于枢纽元时停止，当j位置的元素小于等于枢纽元时停止，如果i < j, 交换两位置处的元素，然后i和j继续相向遍历，直到两个位置指向同一位置或交错时，此时，交换i处的元素和枢纽元。这样的结果就是枢纽元前面的元素都比它小或者等于它，枢纽元后面的元素都比它大或者相等。

采用c中方案的一个好处就是i和j不会有越界风险，因为数组的第一个元素比枢纽元小，所以j不会越界，又因为倒数第二个位置是枢纽元，i停在大于等于枢纽元的位置，所以i也不会越界。

需要注意的地方是，在遍历到等于枢纽元的位置时，不管i或者j这里都采用停止而非继续向前的策略，这里简单的做一个反例：对于一个全部相同的数组来说，如果i和j在A[i] = A[j]时不交换继续向前，那么必须有一个方法防止i或者j越界，并且最终枢纽元还是被交换到i最后到过的位置，即倒数第二个位置，最终导致两个极不均衡的数组，时间复杂度为O(n^2)。而如果在相等处采取交换的策略，那么最终得到的是几乎均等的数组，排序的复杂度为O(NlogN)，i和j会交错，所以不用担心越界风险。

2）算法实现 

#include "stdafx.h"
#include <iostream>
using namespace std;

const int cutOff = 3;

void swap(int* a, int* b)
{
    int temp = *a;
    *a = *b;
    *b = temp;
}

int Media3(int A[], int left, int right)
{
    int center = (left + right)/2;
    if(A[left] > A[center])
    {
        swap(&A[left], &A[center]);
    }
    if(A[left] > A[right])
    {
        swap(&A[left], &A[right]);
    }
    if(A[center] > A[right])
    {
        swap(&A[center], &A[right]);
    }
    swap(&A[center], &A[right-1]);

    return A[right-1];
}

void insertSort(int A[], int left, int right)
{
    for(int i = left + 1; i <= right; i ++)
    {
        int temp = A[i];
        int j = i;
        for(; j > 0; j --)
        {
            if(A[j-1] > temp)
            {
                A[j] = A[j-1];
            }
            else
                break;
        }
        A[j] = temp;
    }
}

void qSort(int A[], int left, int right)
{
    int pivot = Media3(A, left, right);
    int i = left;
    int j = right - 1;
    if(left + cutOff <= right)
    {
        for(;;)
        {
            while(A[++i] < pivot) { }
            while(A[--j] > pivot) { }
            if(i < j)
            {
                swap(&A[i], &A[j]);
            }
            else
            {
                break;
            }
        }
        swap(&A[i], &A[right-1]);
        qSort(A, left, i - 1);
        qSort(A, i + 1, right);
    }
    else
    {
        insertSort(A, left, right);
    }
}

void print(int A[], int n)
{
    for(int i = 0; i < n; i ++)
    {
        cout<<A[i]<<" ";
    }
    cout<<endl;
}

void quickSort(int A[], int n)
{
    qSort(A, 0, n-1);
    print(A, n);
}

int _tmain(int argc, _TCHAR* argv[])
{
    int A[] = {8, 1, 4, 9, 0, 3, 5, 2, 7, 6};
    print(A, 10);
    quickSort(A, 10);

    system("pause");

    return 0;
}

3）时间复杂度分析

对于N=5~20，采取插入排序更快，因为不需要递归的成本。

最坏情况下，枢纽元是最小元素，那么：

T(N) = T(N-1) + cN

T(N-1) = T(N-2) + c(N-1)

...

T(2) = T(1) + c*1

=>　　T(N) = T(1) + c(1+2+...+N) = O(N^2)

最好情况下，枢纽元刚好是数组的中值，那么数组刚好被分为两个均等的数组：

T(N) = 2T(N/2) + c*N

T(N)/N = T(N/2)/N/2  + c

...

T(2)/2 = T(1)/1 + c

T(N)/N = T(1)/1 + c*logN

所以，T(N) = N + c*N*logN = O(NlogN).

平均情况下，假设元素大小是等可能的，那么T(i) = (1/N)(T(1) + T(2) + ... + T(N-1))，那么：

T(N) = T(i) + T(N-i-1) + c*N = (2/N)(T(0) + T(1) + T(2) + ... + T(N-1)) + c*N.

令 sumN = T(1) + T(2) + ... + T(N-1)，则：

NT(N) = 2(T(0) + T(1) + T(2) + ... + T(N-1))+ c*(N^2)

(N-1)T(N-1) = 2(T(0) + T(1) + T(2) + ... + T(N-2)) + c*((N-1)^2)

所以，NT(N) - (N-1)T(N-1) = 2*T(N-1) + 2cN - c

...

T(N) = O(NlogN).