四个基本排序源代码重新写了一下，温故+比较运行速度

插入排序  
#include<stdio.h>  
#include<stdlib.h>  
#define LEN 500000  
int A[LEN];  
  
int main()  
{  
    int i,j;  
    for(i=0;i<LEN;i++)  
        A[i]=rand()%LEN+1;     //产生随机数据  
    for(j=1;j<LEN;j++)         
    {  
        int key=A[j];    //哨兵数据  
        i=j-1;  
        while(i>-1&&A[i]>key)  
        {  
            A[i+1]=A[i];      
            i--;  
        }  
        A[i+1]=key;  
    }  
    for(i=0;i<LEN;i++)  
        printf("%d ",A[i]);  
    printf("\n");  
    system("pause");  
    return 0;  
}  

堆排序  
#include<stdio.h>  
#include<stdlib.h>  
#define LEN 11    /*只需把这个值改变一下，然后把数都写进下面这个数组中，则任意数组都可以进行排序了*/  
int A[LEN]={0,4,1,3,2,16,9,10,14,8,7};  
int length=LEN-1;  
  
void swape(int *a,int *b)  
{  
     int x=*a;  
     *a=*b;  
     *b=x;  
     }  
void max_heapify(int* A,int i)  //核心函数，用来对值为i的节点及其子树形成大顶堆  
{  
     int l=2*i;  
     int r=2*i+1;  
     int largest;  
     if(l<=length&&A[l]>A[i])  
     largest=l;  
     else  
     largest=i;  
       
     if(r<=length&&A[r]>A[largest])  
     largest=r;  
       
     if(largest!=i)  
     {  
                   swape(&A[i],&A[largest]);  
                   max_heapify(A,largest);  
                   }  
     }  
  
void build_max_heap(int* A)    //对从一半开始的节点进行堆整理  
{  
     int i;  
     for(i=(LEN-1)/2;i>=1;i--)  
     max_heapify(A,i);  
     }  
  
/*该函数先用上述函数把堆构建好，然后首尾交换，逐个读出最大值，然后对换过去的数进行堆的构建*/  
void heapsort(int* A)    
{  
     build_max_heap(A);  
     int i;  
     for(i=(LEN-1);i>=2;i--)  
     {  
                            swape(&A[i],&A[1]);  
                            length--;  
                            max_heapify(A,1);  
                            }  
     }  
  
int main()  
{  
    heapsort(A);   //只需调用这一个函数，即可形成大小排序的数组了  
  
    int i;     
    for(i=1;i<LEN;i++)     //输出各个元素，从小到大  
    printf("%d ",A[i]);  
    printf("\n");  
    system("pause");  
    return 0;  
    }

快速排序  
#include<stdio.h>  
#include<stdlib.h>  
#define LEN 12  
int A[LEN]={13,19,9,5,12,8,7,4,21,2,6,11};  
  
void exchange(int *a,int *b)  
{  
     int x=*a;  
     *a=*b;  
     *b=x;  
     }  
  
int parti(int* A,int p,int r)  
{  
    int x=A[r];  
    int i=p-1;  
    int j;  
    for(j=p;j<=r-1;j++)  
    {  
                       if(A[j]<=x)  
                       {  
                                  i++;  
                                  exchange(&A[i],&A[j]);  
                                  }  
                       }  
    exchange(&A[i+1],&A[r]);  
      
    return i+1;  
    }  
      
void quicksort(int* A,int p,int r)  
{  
     if(p<r)  
     {  
     int q=parti(A,p,r);  
     quicksort(A,p,q-1);  
     quicksort(A,q+1,r);  
     }  
     }  
      
int main()  
{  
    quicksort(A,0,LEN-1);  
      
    int i;  
    for(i=0;i<LEN;i++)  
    printf("%d ",A[i]);  
    printf("\n");  
    system("pause");  
    return 0;  
    } 

归并排序  
#include<stdio.h>  
#include<stdlib.h>  
#define LEN 5000000  
#define MAX 999999999  
int A[LEN],L[LEN],R[LEN];  
  
void merge(int p,int q,int r)  
{  
    int n1=q-p+1,n2=r-q,i,j,k;  
    for(i=1;i<=n1;i++)  
        L[i]=A[p+i-1];  
    for(j=1;j<=n2;j++)  
        R[j]=A[q+j];  
    L[i]=MAX;  
    R[j]=MAX;  
    i=1;  
    j=1;  
    for(k=p;k<=r;k++)  
    {  
        if(L[i]<=R[j])  
        {  
            A[k]=L[i];  
            i++;  
        }  
        else  
        {  
            A[k]=R[j];  
            j++;  
        }  
    }  
}  
void merge_sort(int p,int r)  
{  
    if(p<r)  
    {  
        int q=(p+r)/2;  
        merge_sort(p,q);  
        merge_sort(q+1,r);  
        merge(p,q,r);  
    }  
}  
int main()  
{  
    int i;  
    for(i=1;i<=LEN-1;i++)  
        A[i]=rand()%LEN+1;  
    merge_sort(1,LEN-1);  
    for(i=1;i<=LEN-1;i++)  
        printf("%d ",A[i]);  
    printf("\n");  
    return 0;  
}

1. 其中，在运行大数据量（我用rand()函数生成5000000个随机数）排序时，  
2. 归并排序是最快出结果的，大概3秒多一点
3. 然后是堆排序，10秒多一点
4. 再是快速排序，20多秒出的结果
5. 最后是插入排序，不得不说这个插入排序果然是O(n2)的时间复杂度，在500000的数据量的时候，已经等了将近3分多钟才跑出了结果
6. 对于5000000级数据量我是丝毫提不起勇气来进行测试了，而且插入排序的时间耗费会随着数据量的提升而呈指数级增长，更进一步打消了我测试插入排序性能的念头，但是它在数据数量很小的时候还是很有方便有用的
7. 以上测试结果基于Intel(R) Pentium(R) 1.86GHZ 
8.                                    1G内存