7-12 排序 (25 分)（C语言版）

1：尝试用了七种排序：快速排序、选择排序、冒泡排序（超时）、插入排序、希尔排序、改进的希尔排序、归并排序。
2：只有冒泡排序超时，其他都能通过这道题。

给定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<stdio.h>
int a[100001];
int b[100001];
/*快速排序*/
int partition(int a[],int i,int j)
{
	int t=a[i];
	
	while(i<j){
		while(a[j]>=t && i<j)j--;
		if(i<j)a[i++]=a[j];
		while(a[i]<=t && i<j)i++;
		if(i<j)a[j--]=a[i];	 
	}
	
	a[i]=t;
	return i;
}
void QuickSort(int a[],int i,int j)
{
	int k;
	if(i<j){
		k=partition(a,i,j);//使用划分函数把序列分成两部分 
		QuickSort(a,i,k-1);//对前半部分递归排序 
		QuickSort(a,k+1,j);//对后半部分递归排序 
	}
}

/*选择排序*/
void SelectionSort(int a[],int n)
{
	int i,j;
	int minId;//每一轮中最小值的下标 
	int t;
	
	for(i=0;i<n-1;i++){
		minId=i;
		for(j=i+1;j<n;j++){
			if(a[j]<a[minId]){
				minId=j;
			}
		}
		
		t=a[i];
		a[i]=a[minId];
		a[minId]=t;
	}
}

/*冒泡排序*/
void BubbleSort(int a[],int n)
{
	int i,j;
	int t;
	
	for(i=0;i<n-1;i++){//外层循环n-1趟 
		for(j=0;j<n-1-i;j++){//第一次比较n-1次 
			if(a[j]>a[j+1]){//相邻进行比较，逆序则进行交换 
				t=a[j];
				a[j]=a[j+1];
				a[j+1]=t;
			}
		}
	}
}

/*插入排序*/
void InsertionSort(int a[],int n)
{
	int i,j;
	int t;
	
	for(i=1;i<n;i++){
		t=a[i];
		for(j=i-1;j>=0 && t<a[j];j=j-1){
			a[j+1]=a[j];
		}
		a[j+1]=t;
	}
	
}

/*希尔排序*/
void ShellSort(int a[],int n,int delta)
{
	int i,j;
	int t;
	int g;
    
	for(i=delta;i<n;i++){
		t=a[i];
		for(j=i-delta;j>=0 && t<a[j];j=j-delta){
			a[j+delta]=a[j];
		}
		a[j+delta]=t;
	}
	
}


/*改进的希尔排序*/
void ShellSort_1(int a[],int n)
{
    int i,j;
    int t;
    int g;//表示间隔gap
    
    for(g=n/2;g>0;g=g/2){
        for(i=g;i<n;i++){
            t=a[i];
            for(j=i-g;j>=0&&t<a[j];j=j-g){
                a[j+g]=a[j];
            }
            a[j+g]=t;
        }
    }
    
}

/*归并排序*/
void Merge(int a[],int s1,int e1,int s2,int e2,int b[])
{
	int k=s1;
	int i=s1;
	
	while(s1<=e1 && s2<=e2){
		if(a[s1]<=a[s2]){
			b[k++]=a[s1++];
		}else{
			b[k++]=a[s2++];
		}
	}
	
	while(s1<=e1)b[k++]=a[s1++];
	while(s2<=e2)b[k++]=a[s2++];
	k--;
	while(k>=i){
		a[k]=b[k];
		k--;
	}
}
void MergeSort(int a[],int i,int j,int b[])
{
	int k;
	if(i<j){
		k=(i+j)/2;
		MergeSort(a,i,k,b);
		MergeSort(a,k+1,j,b);
		Merge(a,i,k,k+1,j,b);
	}
}

/*主函数*/
int main()
{
    int n;
    int i;
    
    scanf("%d",&n);
    for(i=0;i<n;i++){
        scanf("%d",&a[i]);
    }
    
    /*快速排序：满分（约3507 ms）*/
//     QuickSort(a,0,n-1);
    
    /*选择排序：满分（约3574 ms）*/
//     SelectionSort(a,n);
    
    /*冒泡排序：部分案例超时,超过了10000ms*/
//     BubbleSort(a,n);
    
    /*插入排序：满分（约3372 ms）*/
//     InsertionSort(a,n);
    
    /*希尔排序：满分（约33 ms）；该版本需要多次调用*/
//     int g;
//     for(g=n/2;g>0;g=g/2){
//         ShellSort(a,n,g);
//     }
    
    /*希尔排序：满分（约30 ms）；做了改进，使原来的ShellSort()变成了三层循环*/
//     ShellSort_1(a,n);
    
    /*归并排序：满分（约28 ms）*/
    MergeSort(a,0,n-1,b);
    
    
    for(i=0;i<n;i++){
        if(i==n-1)printf("%d",a[i]);
        else printf("%d ",a[i]);
    }
    return 0;
}