直接插入排序、折半插入排序、希尔排序、冒泡排序、选择排序、快排、堆排序、归并排序算法效率比较

这里建议使用三万左右的随机数个数进行比较。

这里比较的算法有直接插入排序，折半插入排序，希尔排序，冒泡排序，选择排序，快排，堆排序，归并排序。

#include<stdio.h>
#include<time.h>
#include<stdlib.h>
#include<math.h>
#define MAXSIZE 100001
typedef struct {
    int key;
}Rectype;

void stInsertSort(Rectype r[],int n){//直接插入排序
    for(int i=2;i<n;i++){
        r[0]=r[i];
        int j;
        for(j=i-1;r[0].key<r[j].key;j--)
            r[j+1].key=r[j].key;
        r[j+1]=r[0];
    }
}

void binInsertSort(Rectype r[],int n){//折半插入排序
    int i,j,low,mid,high;
    for(i=1;i<n;i++){
        r[0]=r[i];
        low=1;
        high=i-1;
        while(low<=high){
            mid=(low+high)/2;
            if(r[i].key>r[mid].key)
                low=mid+1;
            else
                high=mid-1;
        }
        for(j=i-1;j>=high+1;j--)
            r[j+1]=r[j];
        r[high+1]=r[0];
    }
}

void ShellInsert(Rectype array[],int dk,int n){//希尔排序
    int i,j,temp;
    for(i=dk;i<n;i++){
        temp=array[i].key;
        for(j=i-dk;(j>=i%dk)&&array[j].key>temp;j-=dk)
            array[j+dk]=array[j];
        if(j!=i-dk)
            array[j+dk].key=temp;
    }
}
int dkHibbard(int t,int k){
    return (int)(pow(2,t-k+1)-1);
}
void ShellSort(Rectype array[],int t,int n){

    int i;
    for(i=1;i<=t;i++)
        ShellInsert(array,dkHibbard(t,i),n);
}

void BubbleSort(Rectype r[],int n){//冒泡排序
    int i,j,flag;
    for(i=2;i<n;i++){
        flag=0;
        for(j=1;j<=n-i;j++){
            if(r[j].key>r[j+1].key){
                r[0]=r[j+1];
                r[j+1]=r[j];
                r[j]=r[0];
                flag=1;
            }
        }
        if(flag==0)
            break;
    }
}

void SelectSort(Rectype r[],int n){//选择排序
    int i,j,min;
    for(i=1;i<n-1;i++){
        min=i;
        for(j=i+1;j<n;j++)
            if(r[j].key<r[min].key) min=j;
        if(min!=i){
            r[0]=r[i];
            r[i]=r[min];
            r[min]=r[0];
        }
    }
}

void QuickSort(Rectype r[], int left, int right){//快速排序
    if(left >= right)
        return;
    int i=left;
    int j=right;
    r[0]=r[left];
    while(i<j){
        while(i<j&&r[j].key>=r[0].key){
            j--;
        }
        if(i<j){
            r[i]=r[j];
            i++;
        }
        while(i<j&&r[i].key<=r[0].key){
            i++;
        }
        if(i<j){
            r[j]=r[i];
            j--;
        }
    }
    r[i]=r[0];
    QuickSort(r, left, i-1);
    QuickSort(r, i+1, right);
}

void HeapAdjust(Rectype r[],int k,int m){//堆排序
    int i=k;
    int j=2*i;
    int x=r[k].key;
    int finished=0;
    Rectype rc=r[k];
    while(j<=m&&!finished){
        if(j<m&&r[j].key>r[j+1].key)j++;
        if(x<r[j].key)finished=1;
        else {
            r[i]=r[j];
            i=j;
            j=2*i;
        }
    }
    r[i]=rc;
}
void HeapSort(Rectype r[],int n){
    for(int i=n/2;i>=1;i--)
        HeapAdjust(r,i,n);
    for(int i=n;i>=2;i--){
        r[0]=r[1];
        r[1]=r[i];
        r[i]=r[0];
        HeapAdjust(r,1,i-1);
    }
}

void Merge(Rectype r[],Rectype r1[],int s,int m,int t){//归并排序
    int i=s,j=m+1,k=s;
    while(i!=m+1&&j!=t+1){
        if(r[i].key>r[j].key)
            r1[k++]=r[j++];
        else
            r1[k++]=r[i++];
    }
    while(i!=m+1)
        r1[k++]=r[i++];
    while(j!=t+1)
        r1[k++]=r[j++];
    for(i=s;i<=t;i++)
        r[i]=r1[i];
}
void MergeSort(Rectype r[],Rectype r1[],int s,int t){
    int m;
    if(s<t){
        m=s+(t-s)/2;
        MergeSort(r,r1,s,m);
        MergeSort(r,r1,m+1,t);
        Merge(r,r1,s,m,t);
    }
}

void Menu(){
    printf(" 请输入下列数字开始操作：\n");
	printf(" 1  ---------------------------------  直接选择排序\n");
	printf(" 2  ---------------------------------  拆半插入排序\n");
	printf(" 3  ---------------------------------  希尔排序\n");
	printf(" 4  ---------------------------------  冒泡排序\n");
	printf(" 5  ---------------------------------  直接插入排序\n");
	printf(" 6  ---------------------------------  快速排序\n");
	printf(" 7  ---------------------------------  堆排序\n");
	printf(" 8  ---------------------------------  归并排序\n");
	printf(" 9  ---------------------------------  结束操作\n\n");
}

int main(){
    Rectype r[MAXSIZE],r1[MAXSIZE]={0};
    int i,n,s,t=3;
    int begin;
    Menu();
    printf("请输入元素个数：");
    scanf("%d",&n);
    srand((unsigned int)time(NULL));
    printf("请输入您需要选择的操作：");
    while(scanf("%d",&s)){
        begin=0;
        switch(s){
            case 1:
                for(i=1;i<n+1;i++)
                    r[i].key=rand();
                begin=clock();
                stInsertSort(r,n+1);
                printf("直接选择排序对%d个随机数排序的运行时间为：%d\n",n,clock()-begin);
                break;
            case 2:
                for(i=1;i<n+1;i++)
                    r[i].key=rand();
                begin=clock();
                binInsertSort(r,n+1);
                printf("拆半插入排序对%d个随机数排序的运行时间为：%d\n",n,clock()-begin);
                break;
            case 3:
                for(i=0;i<n;i++)
                    r[i].key=rand();
                begin=clock();
                ShellSort(r,t,n);
                printf("希尔排序对%d个随机数排序的运行时间为：%d\n",n,clock()-begin);
                break;
            case 4:
                for(i=1;i<n+1;i++)
                    r[i].key=rand();
                begin=clock();
                BubbleSort(r,n+1);
                printf("冒泡排序对%d个随机数排序的运行时间为：%d\n",n,clock()-begin);
                break;
            case 5:
                for(i=1;i<n+1;i++)
                    r[i].key=rand();
                begin=clock();
                SelectSort(r,n+1);
                printf("直接插入排序对%d个随机数排序的运行时间为：%d\n",n,clock()-begin);
                break;
            case 6:
                for(i=1;i<n+1;i++)
                    r[i].key=rand();
                begin=clock();
                QuickSort(r,1,n);
                printf("快速排序对%d个随机数排序的运行时间为：%d\n",n,clock()-begin);
                break;
            case 7:
                 for(i=1;i<n+1;i++)
                    r[i].key=rand();
                begin=clock();
                HeapSort(r,n);
                printf("堆排序对%d个随机数排序的运行时间为：%d\n",n,clock()-begin);
                break;
            case 8:
                 for(i=1;i<n+1;i++)
                    r[i].key=rand();
                begin=clock();
                MergeSort(r,r1,1,n);
                printf("归并排序的运行时间为：%d\n",clock()-begin);
                break;
            case 9:
                exit (0);
            default :
                printf("输入错误!");
                break;
        }
        printf("请输入您需要选择的操作：");
	}
}