PAT 数据结构 07-排序1. 排序(25) 8种排序的比较

给定N个（长整型范围内的）整数，要求输出从小到大排序后的结果。

本题旨在测试各种不同的排序算法在各种数据情况下的表现。各组测试数据特点如下：

• 数据0：只有1个元素；
• 数据1：11个不相同的整数，测试基本正确性；
• 数据2：10³个随机整数；
• 数据3：10⁴个随机整数；
• 数据4：10⁵个随机整数；
• 数据5：10⁵个顺序整数；
• 数据6：10⁵个逆序整数；
• 数据7：10⁵个基本有序的整数；
• 数据8：10⁵个随机正整数，每个数字不超过1000。

输入格式：

输入第一行给出正整数N（<= 10⁵），随后一行给出N个（长整型范围内的）整数，其间以空格分隔。

输出格式：

在一行中输出从小到大排序后的结果，数字间以1个空格分隔，行末不得有多余空格。

输入样例：

11
4 981 10 -17 0 -20 29 50 8 43 -5

输出样例：

-20 -17 -5 0 4 8 10 29 43 50 981
/*2015.7.13cyq*/
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

//选择排序O（N2），case0~8（ms）：1，1，2，39，后面100K个int的5个case超时
void selectSort(vector<int> &a,int begin,int end){
	for(int i=begin;i<end;i++){
		int min=i;
		for(int j=i+1;j<=end;j++){
			if(a[j]<a[min])
				min=j;
		}
		swap(a[i],a[min]);
	}
}
//冒泡排序O（N2）,case0~8（ms）：1，1，2，124(比选择排序差），后面100K个int的5个case超时
void bubbleSort(vector<int> &a,int begin,int end){
	int n=end-begin+1;
	for(int i=0;i<n-1;i++)
		for(int j=begin;j<end-i;j++){
			if(a[j]>a[j+1])
				swap(a[j],a[j+1]);
		}
}
//直接插入排序,case0~8（ms）：1，1，2，21，1656，38，超时，53，1653
void insertSort(vector<int> &a,int begin,int end){
	int tmp;
	for(int i=begin+1;i<=end;i++){
		tmp=a[i];
		int j=i-1;
		while(j>=begin&&a[j]>tmp){
			a[j+1]=a[j];
			j--;
		}
		a[j+1]=tmp;
	}
}
//希尔排序，将序号相差increment的记录组成子序列，在子序列内部直接插入排序，让整个序列基本有序
//逐渐减小increment,最后一次增量为1，退化为对基本有序数组进行直接插入排序
//case0~8（ms）：1，1，2，6，48，40，41，40，40
void shellSort(vector<int> &a,int begin,int end){
	int i,j,tmp;
	int n=end-begin+1;
	int increment=n;
	do{
		increment=increment/3+1;//increment为1时就是普通的直接插入排序
		for(i=begin+increment;i<=end;i++){
			tmp=a[i];
			j=i-increment;
			while(j>=begin&&a[j]>tmp){
				a[j+increment]=a[j];
				j=j-increment;
			}
			a[j+increment]=tmp;
		}
	}while(increment>1);
}
//堆排序，建立大根堆，排序时每次都把堆顶元素换到最后，调整大根堆
//具体注释可见我的另一篇博客PAT 数据结构 04-树9. Path in a Heap (25)
//case0~8（ms）：1，1，1，6，47，44，44，44，40
void adjustDown(vector<int> &a,int root,int n){
	a[0]=a[root];
	for(int i=2*root;i<=n;i*=2){
		if(i<n&&a[i]<a[i+1])
			i++;
		if(a[0]>=a[i])
			break;
		else{
			a[root]=a[i];
			root=i;
		}
	}
	a[root]=a[0];
}
void buildMaxHeap(vector<int> &a,int n){
	for(int i=n/2;i>0;i--)
		adjustDown(a,i,n);
}
void heapSort(vector<int> &a,int end){//begin固定为1，便于编码
	buildMaxHeap(a,end);
	for(int i=end;i>1;i--){
		swap(a[i],a[1]);
		adjustDown(a,1,i-1);
	}
}
//归并排序，每2个，每4个，每8个...进行归并，此处我用迭代写法
//case0~8（ms）：1，1，2，6，52，48，46，46，44
void merge(vector<int> &a,int begin1,int end1,int begin2,int end2){//合并两个有序序列
	int n=end2-begin1+1;
	vector<int> b(n);
	int i1=begin1;
	int i2=begin2;
	int i=0;
	while(i1<=end1&&i2<=end2){
		if(a[i1]<=a[i2])  //此处=号保证排序的稳定性
			b[i++]=a[i1++];
		else
			b[i++]=a[i2++];
	}
	if(i1<=end1)
		while(i<n)
			b[i++]=a[i1++];
	if(i2<=end2)
		while(i<n)
			b[i++]=a[i2++];
	i=begin1;
	int j=0;
	while(j<n)
		a[i++]=b[j++];
}
void mergePerCount(vector<int> &a,int begin,int end,int count){//目标是每count个为一组
	int i=begin;
	while(i<=end){
		if(i+count-1<=end){//两个子数组加起来够count个
			merge(a,i,i+count/2-1,i+count/2,i+count-1);
		}else{
			if(i+count/2<=end)//存在两个子数组，后一个残缺
				merge(a,i,i+count/2-1,i+count/2,end);
		}
		i=i+count;
	}
}
void mergeSort(vector<int> &a,int begin,int end){
	int count=1;
	int n=end-begin+1;
	while(count<n){
		count=count*2;
		mergePerCount(a,begin,end,count);
	}
}
//普通快速排序，piovt太小或者太大会导致性能很差
//case0~8（ms）：1，1，超时，超时，超时，超时，超时，2222，超时
int partition1(vector<int> &a,int begin,int end){
	int pivot=a[begin];
	while(begin<end){
		while(begin<end&&a[end]>pivot)
			end--;
		a[begin]=a[end];
		while(begin<end&&a[begin]<pivot)
			begin++;
		a[end]=a[begin];
	}
	a[begin]=pivot;
	return begin;
}
void quickSort1(vector<int> &a,int begin,int end){
	if(begin<end){
			int pivotpos=partition1(a,begin,end);
			quickSort1(a,begin,pivotpos-1);
			quickSort1(a,pivotpos+1,end);
	}
}
//快速排序和直接插入排序混合
//case0~8（ms）：1，1，2，11，超时，39，39，76，超时
int partition2(vector<int> &a,int begin,int end){
	//3数取中
	int mid=begin+(end-begin)/2;
	if(a[begin]>a[end])
		swap(a[begin],a[end]);
	if(a[mid]>a[end])
		swap(a[mid],a[end]);
	if(a[mid]>a[begin])
		swap(a[mid],a[begin]);
	int pivot=a[begin];
	while(begin<end){
		while(begin<end&&a[end]>pivot)
			end--;
		a[begin]=a[end];
		while(begin<end&&a[begin]<pivot)
			begin++;
		a[end]=a[begin];
	}
	a[begin]=pivot;
	return begin;
}
void quickSort2(vector<int> &a,int begin,int end){
	if(begin<end){
		if(end-begin<5000)
			insertSort(a,begin,end);
		else{
			int pivotpos=partition2(a,begin,end);
			quickSort2(a,begin,pivotpos-1);
			quickSort2(a,pivotpos+1,end);
		}
	}
}
int main(){
	int N;
	cin>>N;
	vector<int> a(N+1);
	for(int i=1;i<N+1;i++)  //从1开始是为了便于堆排的层序编码
		cin>>a[i];
	//selectSort(a,1,N);
	//bubbleSort(a,1,N);
	//insertSort(a,1,N);
	//shellSort(a,1,N);
	//heapSort(a,N);
	//mergeSort(a,1,N);
	//quickSort1(a,1,N);
	//quickSort2(a,1,N);
	sort(a.begin()+1,a.end());
	cout<<a[1];
	for(int i=2;i<N+1;i++)
		cout<<" "<<a[i];
	return 0;
}

测试结果：

选择排序：O（n2）；
冒泡排序：O（n2），顺序最好O(n)，逆序最差n2/2，考虑到交换次数多，略差于选择排序；
直接插入排序：O（n2），顺序最好O(n)，逆序最差n2/2，平均n2/4，好于选择和冒泡，在简单排序中性能最好；
希尔排序：O(n3/2)，相当于先粗调，再精调的直接插入排序。
堆排序：O(nlogn)，初始建堆次数较多，不适合排序个数较少的情况。
归并排序：O(nlogn)，使用迭代写法，空间复杂度为O(n)。
快速排序：O(nlogn)，最差O（n2），这是因为最好情况递归树深度为logn，最坏情况递归树深度为n。pivot的选取非常重要，太大或者太小会导致性能恶化。
可在选取pivot，序列较短时使用直接插入排序，迭代代替递归等方面进行优化。
STL sort：快排、直插、堆排（防止递归树太深）混合。

改进算法中，对于100K以内的数据，希尔排序、堆排序、归并排序与STL sort的性能较接近，快速排序需要优化才能发挥出它的力量。