【更新】排序算法比较：插入排序，冒泡排序，归并排序，堆排序，快速排序，计数排序，基数排序，桶排序

1、插入排序

插入排序是最简单、最自然的排序方法，通过保证A[1..j-1]已排序，来将A[j]插入到A[1..j-1]中，从而保证A[1..j]有序。

<span style="font-size:18px;">void    ztInsertSort(int *begin, int *end)//插入排序
{
    int n=end-begin;
    int tmp=0,i=0,j=0;
    for(i=1;i<n;++i){
        for(tmp=begin[i],j=i-1;j>=0;--j)
            if(tmp<begin[j]) begin[j+1]=begin[j];
            else break;
        begin[j+1]=tmp;
    }
}</span>

2、冒泡排序

冒泡排序是很形象的一种算法，每次对数组从后往前两两比较，若A[j-1]>A[j]，j-1>=i 则交换，否则继续往前比较。这样造成的结果是，每次从后往前比较完一轮后，最小的元素都跑到最前面（即每轮结束后，最小的元素都像气泡一样，浮出水面），从而有A[1..i]是有序的，且A[1..i]中任何一个数都比A[i+1..n]中的小。

<span style="font-size:18px;">void ztBubbleSort(int *begin, int *end)//冒泡排序
{
    int n=end-begin,tmp=0;
    for(int i=0;i<n-1;++i)
        for(int j=n-1;j>i;--j)
            if(begin[j] < begin[j-1]){
                tmp=begin[j-1];begin[j-1]=begin[j];begin[j]=tmp;
            }
}</span>

3、归并排序

归并排序利用分治的思想，将A[1..n]分割为A[1..n/2]和A[n/2+1,n]，它们分别排序，然后合并它们，这样就形成递归树，每层的合并有序的数组的排序时间复杂度为O(n)，总共为log n层，所以时间复杂度为O(nlogn)。

<span style="font-size:18px;">void ztMerge(int *a,int *m,int *b)
{
    if(a==m && m+1==b) return;
    if(a!=m || m+1!=b) {ztInsertSort(a,b+1);return;}

    int len1=m-a+1, len2=b-m;
    ztMerge(a,a+len1/2,m);
    ztMerge(m+1,m+1+len2/2,b);

    int cp1[len1],cp2[len2];
    for(int i=0;i<len1;++i) cp1[i]=a[i];
    for(int j=0;j<len2;++j) cp2[j]=a[len1+j];

    int i=0,j=0,k=0;
    for(;i<len1 && j<len2;)
    {
        if(cp1[i]<cp2[j]) {a[k++]=cp1[i];++i;}
        else {a[k++]=cp2[i];++j;}
    }
    if(i==len1) {while(j<len2) a[k++]=cp2[j++];}
    else {while(i<len1) a[k++]=cp1[i++];}
}

void    ztMergeSort(int *begin, int *end)//归并排序
{
    int n=end-begin;
    ztMerge(begin,begin+n/2,end-1);
}</span>