一些常见排序算法的总结

直接插入排序

插入排序是一种简单直观的排序方法，其基本思想是按其元素大小插入到前面已经排好序的子序列中。就像打牌抓牌时按照大小排好一样。

步骤：

数组a[0…i-1]已经有序

查找a(i)在a[0…i-1]中的插入位置k

将a[k…i-1]所有元素全部后移一位

将a(i)复制到a(k)

 

比较次数和移动次数取决于待排序表的状态。最好情况下表中已经有序，时间复杂度为O(n)。

适用于基本有序的排序表和数据量不大的排序表。

实现代码（Java）：

 //插入排序

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

希尔排序

基于插入排序，1959年D.L.Shell提出了希尔排序，又称为缩小增量排序。

基本思想：将待排序表分割成若干形如a[i,i+d,i+2d,…,i+kd]的“特殊”子表，对其分别进行排序，当整个表基本有序时，在对其全体记录进行一次直接插入排序。

步骤：

先取一个小于n的步长d1，把表中元素分成d1个组，在各组中进行直接插入排序；

取第二个步长d2<d1，重复上述过程直到dk=1。

 

一般取d1=n/2。由于希尔排序的时间复杂度依赖于增量序列的函数，其时间复杂度分析比较困难。

实现代码（Java）： 

//希尔排序    public static void shellSort(int[] a){        int i,j,k;        for(int dk=a.length/2;dk>=1;dk=dk/2)            for(i=dk;i<a.length;i++){                if(a[i]<a[i-dk]){                    k=a[i];                    for(j=i-dk;j>=0&&k<a[j];j-=dk){                        a[j+dk]=a[j];                    }                    a[j+dk]=k;                }            }    }

冒泡排序

基本思想：从后往前（或从前往后）两两比较元素的值，若a[i-1]>a[i]（假如逆序）则交换它们，直到序列比较结束。这样一趟下来将会把最大（或最小）交换到一端，就像冒泡一样。下一趟该元素则不参与比较。这样做最多n-1趟冒泡就能把所有元素排好序。

实现代码（Java）： 

//冒泡排序    public static void bubbleSort(int[] a){        int temp;        boolean flag;        for(int i=0;i<a.length;i++){            flag=false;            for(int j=1;j+i<a.length;j++){                if(a[j]<a[j-1]){                   temp=a[j];                   a[j]=a[j-1];                   a[j-1]=temp;                   flag=true;                }            }            if (flag==false)                return;        }    }

快速排序

快速排序是对冒泡排序的一种改进。其基本思想是基于分治法的：在待排序表a[0…n-1]中任取一个元素pivot作为基准，通过一趟排序将待排序划分为独立的两部分a[0…k-1]和a[k+1…n-1]，使得a(k)=pivot左边部分<pivot，右边部分>=pivot。这个过程称作一趟快速排序。然后对两个独立部分进行递归求解，直至所有元素放在了其最终位置上。

快速排序中，每一趟排序后将一个元素（基准元素）放到其最终位置上。

实现代码（Java）： 

//快速排序    public static void quickSort(int[] a,int low,int high){        if(low<high){            int pivotpos=Partition(a,low,high);            quickSort(a,low,pivotpos-1);            quickSort(a,pivotpos+1,high);        }    }    static int Partition(int[] a,int low,int high){        int pivot=a[low];        while (low<high){            while (low<high&&a[high]>=pivot)                high--;            a[low]=a[high];            while (low<high&&a[low]<=pivot)                low++;            a[high]=a[low];        }        a[low]=pivot;        return low;    }

简单选择排序

基本思想：第i趟选择a[i…n-1]中选择最小的元素与a(i)交换，每一趟确定一个元素的最终位置。

实现代码（Java）： 

//简单选择排序    public static void selectSort(int[] a){        int min,j;        for(int i=0;i<a.length-1;i++){            min=i;            for(j=i+1;j<a.length;j++){                if(a[j]<a[min])                    min=j;            }            if(min!=j){                int temp=a[i];                a[i]=a[min];                a[min]=temp;            }        }    }

堆排序

堆排序是一种树形选择排序方法，它的特点是在排序过程中，将a[0…n-1]看成一颗完全二叉树的顺序存储结构，利用完全二叉树中双亲节点和还在节点之间的内在关系，在当前无序区中选择最大（或最小）元素。

堆排序的关键是构造初始堆，整体从下往上，局部从上往下。

建成堆后，堆顶就是最大值，输出堆顶元素，通常将堆底元素送入堆顶，再对其进行调整，再输出堆顶，直至堆中仅剩下一个元素。

实现代码（Java）：

//堆排序    public static void heapSort(int[] a){        buildMaxHeap(a);        for(int i=a.length-1;i>0;i--){            int temp=a[i];            a[i]=a[0];            a[0]=temp;            adjustDown(a,0,i-1);        }    }    static void buildMaxHeap(int[] a){        for(int i=a.length/2;i>=0;i--)//建堆时针对每个非叶节点子树进行向下调整            adjustDown(a,i,a.length-1);    }    static void adjustDown(int[] a,int k,int len){        //将元素i向下调整        int tem=a[k];        for(int i=2*k;i<=len;i*=2){            if(i<len&&a[i]<a[i+1])                i++;            if(tem>=a[i])                break;            else {                a[k]=a[i];                k=i;            }            a[k]=tem;        }    }

归并排序

归并的含义是将两个或两个以上的有序表组合成一个新的有序表。归并排序是基于分治算法的思想。

分解：将含有n个元素的待排序表分成各含n/2个元素的子表，采用2-路归并排序算法对两个子表递归地进行排序

合并：合并两个已排序的子表得到排序结果。

实现代码（Java）：

//归并排序    public static void mergeSort(int[] a,int low,int high){        if(low<high){            int mid=(low+high)/2;            mergeSort(a,low,mid);            mergeSort(a,mid+1,high);            merge(a,low,mid,high);        }    }    static int[] c = new int[length];    static void merge(int[] a,int low,int mid,int high){        int i,j,k;        for(k=low;k<=high;k++)            c[k]=a[k];        for(i=low,j=mid+1,k=i;i<=mid&&j<=high;k++){            if(c[i]<=c[j])                a[k]=c[i++];            else                a[k]=c[j++];        }        while (i<=mid)            a[k++]=c[i++];        while (j<=high)            a[k++]=c[j++];    }

总结

若n较小，则可以采用直接插入排序或简单选择排序。 

若初始状态基本有序选择直接插入或冒泡排序。

若n较大，应选择nlogn的排序算法：快速、堆排或归并。快速排序被认为是目前基于比较的内部排序中最好的方法。

下面是测试的一些结果：单位毫秒，测试的时候使用的是随机数，所以对结果也有一些不确定性的影响，但是大致上的时间是可以参考。