高速排序算法C＋＋实现

Posted 2020-09-23 lytwajue

//quick sort
//STL中也有现成的高速排序算法。内部实现採用了下面技巧
//1）枢轴的选择採取三数取中的方式
//2）后半段採取循环的方式实现
//3）高速排序与插入排序结合
#include<vector>
#include<iostream>
#include<algorithm>

using namespace std;

//这一版本号是最简单实现版本号。对于高速排序的优化主要有下面几个方面：
//1）枢轴的选择。若枢轴选取不全适。比方，若每次递归时，两个子区间中的一个为空，则高速排序将退化为冒泡排序
//关于枢轴的选择有多种：取最后一个元素、取第一个元素、三数取中、九数取中、随机值等
//2）还有一方面是对迭代过程的优化。降低交换次数，降低递归深度等；
template<class type>
int partion1(vector<type>& vec,int start,int end)
{//高速排序的核心部分
	//取最后一个作为枢轴和第一个作为枢轴程序相似，下面是取最后一个元素作为枢轴
	int key=vec[end];
	int fast,slow;
	fast=slow=start;

	//用两个指针的移动实现
	for(;fast<end;++fast)
	{
		if(vec[fast]<key)
		{
			if(fast!=slow)
			{
				int tmp=vec[slow];
				vec[slow]=vec[fast];
				vec[fast]=tmp;
			}
			slow++;
		}
	}
	int tmp=vec[slow];
	vec[slow]=vec[end];
	vec[end]=tmp;
	return slow;
}

//三数取中
template<class type>
int midNumber(type a,type b,type c)
{
	int big1=max(a,b);
	int big2=max(a,c);
	int big3=max(b,c);

	return min(big1,min(big2,big3));
}

template<class type>
int partion2(vector<type>& vec,int start,int end)
{
	//3数取中和9数取中的方式，保证了一定随机性，下面是3数取中的方式
	int key=midNumber(vec[start],vec[(start+end)/2],vec[end]);

	int midNumPos=0;
	if(key==vec[start])
		midNumPos=start;
	else if(key==vec[end])
		midNumPos=end;
	else
		midNumPos=(start+end)/2;

	vec[midNumPos]=vec[end];
	vec[end]=key;

	//如今採用一种和上一种方案不同的交换方式
	while(start<end)
	{//枢轴的位置一直在改变
		while(start<end && vec[start]<=key)
			start++;

		int tmp=vec[start];
		vec[start]=vec[end];
		vec[end]=tmp;

		while(start<end && vec[end]>=key)
			end--;

		tmp=vec[start];
		vec[start]=vec[end];
		vec[end]=tmp;
	}

	return start;
}

template<class type>
int partion3(vector<type>& vec,int start,int end)
{//取随机数的方法
	int keyNumPos=start+rand()%(end-start);
	int tmp=vec[keyNumPos];
	vec[keyNumPos]=vec[end];
	vec[end]=tmp;

	int key=vec[end];
	while(start<end)
	{//枢轴的位置一直在改变
		while(start<end && vec[start]<=key)
			start++;

		tmp=vec[start];
		vec[start]=vec[end];
		vec[end]=tmp;

		while(start<end && vec[end]>=key)
			end--;

		tmp=vec[start];
		vec[start]=vec[end];
		vec[end]=tmp;
	}
	return start;
}
//以上是三种对枢轴的优化方法。无非就是避免高速排序恶化
//下面是避免不必要的交换过程
template<class type>
int partion4(vector<type>& vec,int start,int end)
{//取随机数的方法
	int keyNumPos=start+rand()%(end-start);
	int tmp=vec[keyNumPos];
	vec[keyNumPos]=vec[end];
	vec[end]=tmp;

	int key=vec[end];
	while(start<end)
	{//观察可知，交换的过程中，总有一个数是key，所以当须要赋key值时能够直接跳过，于是能够降低赋值操作
		while(start<end && vec[start]<=key)
			start++;

		vec[end]=vec[start];//end以start覆盖

		while(start<end && vec[end]>=key)
			end--;

		vec[start]=vec[end];//start以end覆盖
	}
	vec[start]=key;
	return start;
}


template<class type>
void qSort1(vector<type>& vec,int start,int end)
{
	if(start>=end)return;
	int index=partion4(vec,start,end);//key
	qSort1(vec,start,index-1);
	qSort1(vec,index+1,end);
}

//递归过程须要出栈入栈，成本较高，并且可能栈溢出。假设可能的话最好以循环方式取代递归
template<class type>
void qSort2(vector<type>& vec,int start,int end)
{
	if(start>=end)return;
	
	int index;//key
	while(start<end)
	{//后半段的递归过程以循环取代。相当于减小了递归深度
		index=partion4(vec,start,end);//key
		qSort2(vec,start,index-1);
		start=index+1;
	}
}


//当处理的数据量比較小时，插入排序的成本可能比高速排序成本更低，所以考虑在数据量较小时採用插入排序

/*template<class type>
void qSort3(vector<type>& vec,int start,int end)
{
	if(start>=end)return;
	
	int index;//key
	if(end-start>VALUE)
	{	
		while(start<end)
		{//后半段的递归过程以循环取代，相当于减小了递归深度
			index=partion4(vec,start,end);//key
			qSort3(vec,start,index-1);
			start=index+1;
		}
	}
	else
	{
		insertSort(vec,start,end);
	}
}*/

template<class type>
void quickSort(vector<type>& vec)
{
	int length=vec.size();
	qSort2(vec,0,length-1);
}

int main()
{
	int a[10]={1,5,9,0,6,3,2,7,8,4};
	vector<int> vec(a,a+10);

	quickSort(vec);

	for(int i=0;i<vec.size();++i)
		cout<<vec[i]<<"  ";
	cout<<endl;
	return 0;
}