【转】三种快速排序算法的实现（递归算法、非递归算法、三路划分快速排序）

QUICKSORT(A, l, r)

if l < r

   then q = PARTION(A, l, r)

        QUICKSORT(A, l, p-1)

        QUICKSORT(A, p+1, r)

 

int partition(double* a, int left, int right)  
{  
    double x = a[right];  
    int i = left-1, j = right;  
    for (;;)  
    {  
        while(a[++i] < x) { }  
        while(a[--j] > x) { if(j==left) break;}  
        if(i < j)   
            swap(a[i], a[j]);  
        else break;  
    }  
    swap(a[i],a[right]);  
    return i;  
}  
  
void quickSort1(double* a, int left, int right)  
{  
    if (left<right)  
    {  
        int p = partition(a, left, right);  
  
        quickSort1(a, left, p-1);  
        quickSort1(a, p+1, right);  
    }  
}  

void quickSort2(double* a, int left, int right)  
{  
    stack<int> t;  
    if(left<right)  
    {  
        int p = partition(a, left, right);  
  
        if (p-1>left)  
        {  
            t.push(left);  
            t.push(p-1);  
        }  
        if (p+1<right)  
        {  
            t.push(p+1);  
            t.push(right);  
        }  
  
        while(!t.empty())  
        {  
            int r = t.top();  
            t.pop();  
            int l = t.top();  
            t.pop();  
  
            p = partition(a, l, r);  
  
            if (p-1>l)  
            {  
                t.push(l);  
                t.push(p-1);  
            }  
            if (p+1<r)  
            {  
                t.push(p+1);  
                t.push(r);  
            }  
  
        }  
    }  
} 

void quickSort3Way(double a[], int left, int right)  
{  
    if(left < right)  
    {  
        double x = a[right];  
        int i = left-1, j = right, p = left-1, q = right;  
        for (;;)  
        {  
            while (a[++i] < x) {}  
            while (a[--j] > x) {if(j==left) break;}  
            if(i < j)  
            {  
                swap(a[i], a[j]);  
                if (a[i] == x) {p++; swap(a[p], a[i]);}  
                if (a[j] == x) {q--; swap(a[q], a[j]);}  
            }  
            else break;  
        }  
        swap(a[i], a[right]); j = i-1; i=i+1;  
        for (int k=left; k<=p; k++, j--) swap(a[k], a[j]);  
        for (int k=right-1; k>=q; k--, i++) swap(a[i], a[k]);  
  
        quickSort3Way(a, left, j);  
        quickSort3Way(a, i, right);  
    }  
}

#include <iostream>
#include <stack>
#include <ctime>
using namespace std;

// 产生（a,b）范围内的num个随机数
double* CreateRand(double a, double b, int num)
{
    double *c;
    c = new double[num];
    srand((unsigned int)time(NULL));
    for (int i=0; i<num; i++)
        c[i] = (b-a)*(double)rand()/RAND_MAX + a;
    return c;
}

// 两路划分，获取中轴，轴左边数小于轴，轴右边数大于轴
double partition(double* a, int left, int right)
{
    ...
}

// 1.递归快速排序，利用两路划分
void quickSort1(double* a, int left, int right)
{
    ...
}

// 2.非递归快速排序，手动利用栈来存储每次分块快排的起始点，栈非空时循环获取中轴入栈
void quickSort2(double* a, int left, int right)
{
    ...
}

// 3.利用三路划分实现递归快速排序
void quickSort3Way(double a[], int left, int right)
{
    ...
}

void main()
{
    double *a, *b, *c;
    int k=10000000;
    time_t start,end;

    a = CreateRand(0,1,k);
    b = CreateRand(0,1,k);
    c = CreateRand(0,1,k);

    start = clock();
    quickSort1(a,0,k-1);
    end = clock();
    cout<<"1.recursive "<<1.0*(end-start)/CLOCKS_PER_SEC<<" seconds"<<endl;

    start = clock();
    quickSort2(b,0,k-1);
    end = clock();
    cout<<"2.non-recursive "<<1.0*(end-start)/CLOCKS_PER_SEC<<" seconds"<<endl;

    start = clock();
    quickSort3Way(c,0,k-1);
    end = clock();
    cout<<"3.3 way "<<1.0*(end-start)/CLOCKS_PER_SEC<<" seconds"<<endl;

    cout<<endl;
    system("pause");
}