快速排序的三种实现方法

基本原理：
通过一趟排序将待排元素分割成独立的两部分，其中一部分的元素都比另一部分小，则分别对这两部分进行排序，最后达到整体有序。

实现一：递归算法

void quicksort(int a[],int s,int t)
{
int low,high,tmp;
low=s;
high=t;
if(low<high)
{
tmp=a[low];
while(low<high)
{
while(low<high&&a[high]>=tmp)
high--;
a[low]=a[high];
while(low<high&&a[low]<=tmp)
low++;
a[high]=a[low];
}
a[low]=tmp;
quicksort(a,s,low-1);
quicksort(a,low+1,t);
}
}

实现二：非递归算法
手动利用栈来存储每次分块快排的起始点和结束点，栈非空时循环获取要排序的区间。

int partition(int a[],int s,int t)
{
int low,high,tmp;
low=s;
high=t;
if(low<high)
{
tmp=a[low];
while(low<high)
{
while(low<high&&a[high]>=tmp)
high--;
a[low]=a[high];
while(low<high&&a[low]<=tmp)
low++;
a[high]=a[low];
}
a[low]=tmp;
}
return low;
}

void quicksort1(int a[],int s,int t)
{
stack<int>m;
int p=partition(a,s,t);
if(p-1>s)
{
m.push(s);
m.push(p-1);
}
if(p+1<t)
{
m.push(p+1);
m.push(t);
}
while(!m.empty())
{
int r=m.top(); //上界
m.pop();
int l=m.top(); //下界
m.pop();
p=partition(a,l,r);
if(p-1>l)
{
m.push(l);
m.push(p-1);
}
if(p+1<r)
{
m.push(p+1);
m.push(r);
}
}
}

实现三：三路划分快速排序
二路划分一次排序后结果数组分为：小于等于元素的数，该元素，大于等于元素的数；

而三路划分一次排序结束后结果数组分为：小于元素的数，等于元素的数（一个或多个），大于元素的数。

具体实现：从首部开始遍历时把遇到的与比较元素相同的数都移到最开始的位置；从尾部向前遍历时把遇到相同的数都移到末尾位置；然后和首部相同的数和尾部相同的数都移到数组中部来。递归遍历首部的小数和尾部的大数。



void swap(int *a,int *b)
{
int tmp;
tmp=*a;
*a=*b;
*b=tmp;
}
void quicksort2(int a[],int s,int t)
{

if(s<t)
{
int tmp=a[t];
int i=s-1,j=t; //记录三次划分后分割的位置s——i,i——j,j——t
int p=s-1,q=t; //用来从前从后遍历
while(1)
{
while(a[++i]<tmp){} //从前开始找到第一个大于等于x的元素
while(a[--j]>tmp) //从后开始找到第一个小于等于x的元素
{
if(j==s)
break;
}
if(i<j)
{
swap(a[i],a[j]);
if(a[i]==tmp) //把相等的元素移到最开始
{
p++;
swap(a[p],a[i]);
}
if(a[j]==tmp) //把相等的元素移到最末尾
{
q--;
swap(a[q],a[j]);
}
}
else break;
}
swap(a[i],a[t]); //设置第i位
j=i-1; //设置开始位置，j从i-1向前复制，i从i+1向后复制
i=i+1;
for(int k=s;k<=p;k++,j--)
swap(a[k],a[j]);
for(k=t-1;k>=q;k--,i++)
swap(a[i],a[k]);

quicksort(a,s,j);
quicksort(a,i,t);
}
}