快速排序(Quick Sort)

维基百科：http://zh.wikipedia.org/wiki/快速排序

算法思想：

快速排序也是分治法的一个应用，在一个给定的序列中，选取一个主元pivot，通过“分区操作”partition把一个序列分成两个子序列，一个子序列的所有元素小于等于主元，另一个子序列中的所有元素大于等于主元，然后递归的对两个子序列进行快速排序。快速排序最主要的部分就是partitiion函数，由于partition函数有很多不同实现，因而快速排序有很多版本，本文简单的讨论几种。

1、实现（1）

下面给出的实现就是根据算法导论中的伪代码来的

#include <cstdlib>
#include <iostream>

using namespace std;

template<class T>
void quickSort(T* a, int low, int high)
{
    if(low < high)
    {
        int r = partition(a,low,high);
        quickSort(a,low,r-1);
        quickSort(a,r+1,high);
    }
}

//交换两个元素 
template<class T>
void exchange(T& a, T& b)
{
    T temp(a);
    a = b;
    b = temp;
}
/*
以a[high]为主元pivot 
*/
template<class T>
int partition(T* a, int low, int high)
{
    int i = low - 1;    //小于等于主元的元素段的尾指针 
    T x = a[high];      //主元 
    for(int j=low; j<high; j++)
    {
        if(a[j] <= x)
        {
            i++;
            exchange(a[i],a[j]);
        }
    }
    exchange(a[i+1],a[high]);//把主元交换到合适位置 
    return i + 1;       //返回主元所在位置 
}

int main(int argc, char *argv[])
{
    int n;
    int* a = NULL;
    
    while(cin>>n && n > 0)
    {
        a = new int[n];
        for(int i=0; i<n; i++)
        {
            cin>>a[i];
        }
        quickSort(a,0,n-1);
        for(int i=0; i<n; i++)
        {
            cout<<a[i]<<" ";
        }
        cout<<endl<<endl;
        delete [] a;
    }
    
    system("PAUSE");
    return EXIT_SUCCESS;
}

2、实现(2)

算法导论课后思考题给出的另一种划分Hoare划分

// 这个实现效率较低，不断在交换元素 
template<class T>
int Hoare_Partition(T* a, int p, int r)
{
    T x = a[p];
    int i = p;
    int j = r;
    while(true)
    {
        while(a[j] > x)//从右向左找小于等于x的元素 
            j--;
        while(a[i] < x)//从左向右找大于等于x的元素 
            i++;
        if(i < j)
            exchange(a[i],a[j]);//交换 
        else
            return j;
    }
}

3、实现(3)

这个实现和上面的实现(2)差不多

template<class T>
void partition3(T* a, int p, int r)
{
    T x = a[p];//以a[p]为主元 
    int i = p;
    int j= r + 1;
    while(true)
    {
        while(a[++i] <= x && i < r);//从左向右找大于x的元素 
        while(a[--j] > x);//从右向左找小于等于x的元素 
        if(i > j)
            break;
        swap(a[i],a[j]);        
    }
    a[p] = a[j]；
    a[j] = x; 
    return j;
}

4、随机化快速排序

有时候可能出现不平衡的划分，例如最上面的划分函数，我们选取最右元素a[high]为主元，极端情况下就，每次划分得到的两个序列长度分别为n-1和一个长度为0的序列（两序列由主元分隔）。此时递推公式为T(n) =  T(n-1)+ O(n)  => T(n) = O(n^2)。我们可以随机选取一个主元把它交换到位置a[hign]，这样可以大大降低最坏情况出现的概率，一个随机化快速排序实现如下。

template<class T>
int randomized_partition(T* a, int p, int r)
{
    //rand()函数在cstdlib中
    int i = rand()%(r - p + 1) + p;//产生[p,r]之间的一个随机整数
    swap(a[i],a[r]);                //交换，把主元a[r]置于末尾
    return partition(a,p,r); 
     
}

template<class T>
void randomized_quickSort(T* a, int low, int high)
{
    if(low < high)
    {
        int r = randomized_partition(a,low,high);
        randomized_quickSort(a,low,r-1);
        randomized_quickSort(a,r+1,high);
    }
}

5、复杂度分析

算法平均时间复杂度为O(nlgn)，最坏情况下的时间复杂度为O( n^2)。最坏i情况出现在序列有序或基本有序的时候，此时快速排序算法蜕变为冒泡排序。

一般来说，最坏情况出现的可能性还是比较小的，快速排序可以说是最快的比较排序算法。

待编辑

参考资料：

[1]算法导论（第2版）

[2]王晓东 计算机算法设计与分析（第3版）