一些常见排序算法的总结

直接插入排序

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

步骤：

数组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!=i){
                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的排序算法：快速、堆排或归并。快速排序被认为是目前基于比较的内部排序中最好的方法。

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