总结一下常见的几种排序

1、插入排序

public void insertsort(int[] a){    for(int i=1;i<a.length;i++)    {        for(int j=i;j>0;j--)        {            if(a[j]<a[j-1])                swap(a,j,j-1);        }    }}

时间复杂度O(n^2)，没有多余的空间开销，虽然复杂度为平方级别，但在数组为近似有序的情况下效率非常高，有时在归并和快排的的子序列中可以使用插入排序，一般能提升20%-30%的效率。

2、希尔排序

希尔排序可以理解为插入排序的改进，大概思想是不断循环把数组根据间隔进行部分排序，直至间隔为1，这样做充分利用了插入排序对近似有序数组排序的高效特点，效率比插入排序提高70%-80%。

public void hillsort(int[] a){    int length=a.length;    int h=1;    while(h<length/3)    {        h=h*3+1;    }    while(h>=1)    {        for(int i=h;i<length;i++)        {            for(int j=i;j>=h;j-=h)            {                if(a[j]<a[j-h])                {                    swap(a,j,j-h);                }            }        }        h/=3;    }}

这里的间隔取值是按《Algorithms》书中取得，一般来说这样的间隔取值能达到最优速度。

3、快速排序

快排的理论最差时间复杂度为O(n^2)，但实际运行速度还是很快的，平均效率为O(nlgn)，通过随机化key值基本可以规避掉最坏情况。笔者认为快排是一种很优秀的排序，内循环极为精简，比较次数很少，通过随机化快排切分数组的效果也很好。

public void quicksort(int[] a,int begin,int end){    if(begin>=end) return;    int temp=a[begin];    int key=begin;    for(int j=begin+1;j<=end;j++)    {        if(a[j]<temp) {            swap(a, key + 1, j);            key++;        }    }    swap(a,begin,key);    quicksort(a,begin,key-1);    quicksort(a,key+1,end);}

4、归并排序

归并排序的理论时间复杂度应该是排序中最优秀的了，但实际运行中其实速度却不是最快的，因为归并排序的代码操作非常多，因此性能并不像理论上表现的那么优秀，还有一个问题是归并排序需要额外的空间复杂度，与数组长度成正比，因此也要根据实际情况选择。

public void mergesort(int[] a,int begin,int end){    if(begin>=end) return;    int mid=(begin+end)/2;    mergesort(a,begin,mid);    mergesort(a,mid+1,end);    merge(a,begin,mid,end);}public void merge(int[] a,int begin,int mid,int end){    int[] temp=new int[end-begin+1];    int i=begin,j=mid+1,k=0;    while(i<=mid&&j<=end)    {        if(a[i]<a[j])        {            temp[k++]=a[i++];        }        else{            temp[k++]=a[j++];        }    }    while(i<=mid){        temp[k++]=a[i++];    }    while(j<=end){        temp[k++]=a[j++];    }    for(int m=0;m<temp.length;m++){        a[m+begin]=temp[m];    }}

5、堆排序

二叉堆的维护分为插入和删除两种情况，即上浮和下沉两种操作，如果只是用堆排序的话只用到下沉就可以了，堆排序是目前所知能够同时最优的利用空间和时间的方法，它的缺点也很明显，无法利用缓存，因为很少与相邻的其他元素进行比较，因此缓存未命中的概率远高于快速排序、归并排序等排序。

public void heapsort(int[] a){    int length=a.length;    for(int i=(length-1)/2;i>=0;i--)    {        sink(a,i,length-1);    }    int n=length-1;    while(n>0){        swap(a,n--,0);        sink(a,0,n);    }}public void sink(int[] a,int k,int n){    while(2*k+1<=n)    {        int j=2*k+1;        if(j<n&&a[j]<a[j+1])            j++;        if(a[k]>a[j]) break;        swap(a,j,k);        k=j;    }}