各种基本排序算法的比较

09-排序1 排序 (25分)

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

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

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

输入格式:

输入第一行给出正整数N（≤10
​5
​​ ），随后一行给出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

#include<iostream>
using namespace std;

void swap(long long *a,long long *b) {
	long long tmp=*a;
	*a=*b;
	*b=tmp;
}
//选择排序
void  SelectionSort(long long num[],long long N) {
	long long min=num[0],t;
	for(int i=0; i<N-1; i++) {
		t=i;min=num[i];
		for(int j=i; j<N; j++) {
			if(min>num[j]) {
				min=num[j];
				t=j;
			}
		}
		swap(&num[i],&num[t]);
	}
}
//冒泡排序
void BubbleSort(long long num[],long long N){
	for(int i=N-1;i>=1;i--){
		for(int j=0;j<=i-1;j++){
			if(num[j]>num[j+1])
				swap(&num[j],&num[j+1]);
		}
	}
} 
//插入排序
void InsertSort(long long num[],long long N){
	int tmp,j;
	for(int i=1;i<N;i++){
		tmp=num[i];
		for(j=i;j>0&&num[j-1]>=tmp;j--){
			num[j]=num[j-1];
		}
		num[j]=tmp;
	}
} 
//希尔排序
void ShellSort(long long num[],long long N){
	int tmp,D,Si; 
	int Sedgewick[]={929,505,209,109,41,19,5,1,0};
	for(Si=0;Sedgewick[Si]>=N;Si++);
	for(int i=Sedgewick[Si];i>=1;i=Sedgewick[++Si]){
		for(int j=i;j<N;j++){
			tmp=num[j];
			for(D=j;D>=i&&num[D-i]>tmp;D-=i){
				num[D]=num[D-i];
			}
			num[D]=tmp;
		}
	}
}
/*-------------------堆排序------------------*/
void PercDown(long long num[],int N,int p){
	int Parent,Child;
	
	long long t=num[p];
	for(Parent=p;Parent*2+1<N;Parent=Child){
		Child=Parent*2+1;
		if(Child!=N-1&&num[Child]<num[Child+1])
			Child++;
		if(num[Child]<=t)break;
		else num[Parent]=num[Child];
		
	}
	num[Parent]=t;
}

void HeapSort(long long num[],int N){
	
	for(int i=(N-2)/2;i>=0;i--){
		PercDown(num,N,i);
	}
	for(int i=N-1;i>=1;i--){
		swap(&num[0],&num[i]);
		PercDown(num,i,0);
	}
}
/*------------------堆排序结束-------------------*/ 

/*------------------归并排序递归算法---------------------*/
void Merge(long long A[],long long TmpA[],int L,int R,int RightEnd){
	int LeftEnd=R-1;
	int Tmp=L;
	int NumElements=RightEnd-L+1;
	while(L<=LeftEnd&&R<=RightEnd){
		if(A[L]<=A[R])TmpA[Tmp++]=A[L++];
		else TmpA[Tmp++]=A[R++];
	}
	while(L<=LeftEnd)
		TmpA[Tmp++]=A[L++];
	while(R<=RightEnd)
		TmpA[Tmp++]=A[R++];
	for(int i=0;i<NumElements;i++,RightEnd--){
		A[RightEnd]=TmpA[RightEnd];
	}
} 
/*分而治之使用递归实现*/
void MSort(long long  A[],long long TmpA[],int L,int RightEnd){
	int Center;
	if(L<RightEnd){
		Center=(L+RightEnd)/2;
		MSort(A,TmpA,L,Center);
		MSort(A,TmpA,Center+1,RightEnd);
		Merge(A,TmpA,L,Center+1,RightEnd);
	}
} 
/*归并排序递归实现的接口*/
void MergeSort(long long A[],int N){
	long long *TmpA;
	TmpA=(long long *)malloc(N*sizeof(long long));
	if(TmpA!=NULL){
		MSort(A,TmpA,0,N-1);
		free(TmpA);
	}else{
		printf("空间不足");
	}
}
/*-------------------归并排序递归算法结束-----------------*/

/*-------------------归并排序非递归算法实现---------------*/
void Merge1(long long A[],long long TmpA[],int L,int R,int RightEnd){
	int LeftEnd=R-1;
	int Tmp=L;
	int NumElements=RightEnd-L+1;
	while(L<=LeftEnd&&R<=RightEnd){
		if(A[L]<=A[R])TmpA[Tmp++]=A[L++];
		else TmpA[Tmp++]=A[R++];
	}
	while(L<=LeftEnd)
		TmpA[Tmp++]=A[L++];
	while(R<=RightEnd)
		TmpA[Tmp++]=A[R++];
} 

void Merge_pass(long long A[],long long TmpA[],int N,int length){
	int i,j;
	for(i=0;i<=N-2*length;i+=2*length)
		Merge1(A,TmpA,i,i+length,i+2*length-1);
	if(i+length<N)Merge1(A,TmpA,i,i+length,N-1);
	else 
		for(j=i;j<N;j++)TmpA[j]=A[j]; 
} 

void MergeSort1(long long A[],int N){
	long long* TmpA=(long long*)malloc(N*sizeof(long long));
	int length=1;
	if(TmpA!=NULL){
		while(length<N){
			Merge_pass(A,TmpA,N,length);
			length*=2;
			Merge_pass(TmpA,A,N,length);
			length*=2; 
		}
		free(TmpA);
	}else{
		printf("空间不足!");
	}
}


/*-------------------归并排序非递归算法结束---------------*/ 
int main() {
	long long N;
	scanf("%lld",&N); 
	long long number[N];
	for(long long i=0;i<N;i++){
		scanf("%lld",&number[i]);
	}
//	SelectionSort(number,N);
//	BubbleSort(number,N);
//	ShellSort(number,N);
//	InsertSort(number,N);
//	HeapSort(number,N); 
	MergeSort1(number,N);
	for(long long i=0;i<N;i++){
		if(i!=0)printf(" ");
		printf("%lld",number[i]);
	}
	
}