经典排序算法原理、代码实现和稳定性分析_如何体现代码稳定性原理-优快云博客

本文链接：https://blog.youkuaiyun.com/tubro2017/article/details/80308973

选择排序：

首先找到数组中最小的那个元素，将它与数组的第一个位置交换位置。
然后找出剩下的元素中最小的元素，将它与数组中的第二个元素交换位置，如此往复，直到整个数组排序。

数据结构	数组
最坏时间复杂度	О(n²)
最优时间复杂度	О(n²)
平均时间复杂度	О(n²)
空间复杂度	О(n) total, O(1) auxiliary

public class Selection {
    public static void sort(Comparable[] a){
        int N=a.length;
        for (int i = 0; i < N; i++) {
            int min=i;
            for(int j=i+1;j<N;j++){
                //如果a[j]<a[min]，则min=j
                if(less(a[j],a[min])) min=j;
            }
            exch(a,i,min);
        }
    }
    private static boolean less(Comparable v,Comparable w){
        return v.compareTo(w)<0;
    }
    private static void exch(Comparable[] a,int i,int j){
        Comparable t=a[i];
        a[i]=a[j];
        a[j]=t;
    }
    public static void show(Comparable[] a){
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i]+" ");
        }
        System.out.println();
    }

    public static boolean isSorted(Comparable[] a){
        for (int i = 1; i < a.length; i++) {
            if(less(a[i],a[i-1])) return false;
        }
        return true;
    }
}

冒泡排序：

比较相邻的元素。如果第一个比第二个大，就交换他们两个。
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。
在这一点，最后的元素应该会是最大的数。针对所有的元素重复以上的步骤，除了最后一个。
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

数据结构	数组
最坏时间复杂度	$O(n^{2})$
最优时间复杂度	$O(n)$
平均时间复杂度	$O(n^{2})$
空间复杂度	$O(n)$ ，需要辅助空间 $O(1)$

package chapter2;

public class Bubble {
    public static void sort(Comparable[] a){
        int N=a.length;
        for (int i = 0; i < N; i++) {
            for(int j=0;j<N-i-1;j++){
                if(less(a[j+1],a[j])){
                    exch(a,j,j+1);
                }
            }
        }
    }
    private static boolean less(Comparable v,Comparable w){
        return v.compareTo(w)<0;
    }
    private static void exch(Comparable[] a,int i,int j){
        Comparable t=a[i];
        a[i]=a[j];
        a[j]=t;
    }
    public static void show(Comparable[] a){
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i]+" ");
        }
        System.out.println();
    }

    public static boolean isSorted(Comparable[] a){
        for (int i = 1; i < a.length; i++) {
            if(less(a[i],a[i-1])) return false;
        }
        return true;
    }
}

插入排序：

把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中
直到所有的记录插入完为止，得到一个新的有序序列。

数据结构	数组
最坏时间复杂度	$O(n^{2})$
最优时间复杂度	$O(n)$
平均时间复杂度	$O(n^{2})$
空间复杂度	$O(n)$ ，需要辅助空间 $O(1)$

public class Insertion {
    public static void sort(Comparable[] a){
        int N=a.length;
        for (int i = 1; i < N; i++) {
            for(int j=i;j>0&&less(a[j],a[j-1]);j--){
                exch(a,j,j-1);
            }
        }
        //内循环将较大的元素都向右移动而不总是交换两个元素，可大幅度提高插入排序的速度。
//        for(int i=1;i<N;i++){
//            Comparable tmp=a[i];
//            int j=i;
//            for(;j>0&&less(tmp,a[j-1]);j--){
//                a[j]=a[j-1];
//            }
//            a[j]=tmp;
//        }
    }
    private static boolean less(Comparable v,Comparable w){
        return v.compareTo(w)<0;
    }
    private static void exch(Comparable[] a,int i,int j){
        Comparable t=a[i];
        a[i]=a[j];
        a[j]=t;
    }
    public static void show(Comparable[] a){
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i]+" ");
        }
        System.out.println();
    }

    public static boolean isSorted(Comparable[] a){
        for (int i = 1; i < a.length; i++) {
            if(less(a[i],a[i-1])) return false;
        }
        return true;
    }

}

归并排序：

申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列
设定两个指针，最初位置分别为两个已经排序序列的起始位置
比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置
重复步骤3直到某一指针到达序列尾
将另一序列剩下的所有元素直接复制到合并序列尾
数据结构数组
最坏时间复杂度 $\Theta (n\log n)$
最优时间复杂度 $\Theta(n)$
平均时间复杂度 $\Theta (n\log n)$
空间复杂度 $\Theta(n)$

public class Merge {

    private static Comparable[] aux;
    public static void merge(Comparable[] a,int low,int mid,int high){
        int i=low,j=mid+1;
        for (int k = 0; k <=high; k++) {
            aux[k]=a[k];
        }
        for(int k=low;k<=high;k++){
            if(i>mid) a[k]=aux[j++];
            else if(j>high) a[k]=aux[i++];
            else if(less(aux[j],aux[i])) a[k]=aux[j++];
            else a[k]=aux[i++];
        }
    }

    public static void sort(Comparable[] a){
        aux=new Comparable[a.length];
        sort(a,0,a.length-1);
    }
    private static void sort(Comparable[] a,int low,int high){
        if(high<=low){
            return;
        }
        int mid=low+(high-low)/2;
        sort(a,low,mid);
        sort(a,mid+1,high);
        //如果左半边最大的值，小于或者等于则不进行归并操作
        if(less(a[mid+1],a[mid])){
            merge(a,low,mid,high);
        }
    }
    private static boolean less(Comparable v,Comparable w){
        return v.compareTo(w)<0;
    }
    private static void exch(Comparable[] a,int i,int j){
        Comparable t=a[i];
        a[i]=a[j];
        a[j]=t;
    }
    public static void show(Comparable[] a){
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i]+" ");
        }
        System.out.println();
    }

    public static boolean isSorted(Comparable[] a){
        for (int i = 1; i < a.length; i++) {
            if(less(a[i],a[i-1])) return false;
        }
        return true;
    }
}

快速排序：

在数组中选择一个元素，将大于这个元素的分在一个子数组，将小于这个元素的分在另外一个子数组
在子数组中继续进行第一步的操作，直到无法再进行
数据结构不定
最坏时间复杂度 $\Theta (n^{2})$
最优时间复杂度 $\Theta (n\log n)$
平均时间复杂度 $\Theta (n\log n)$
空间复杂度根据实现的方式不同而不同

数据结构	不定
最坏时间复杂度	$\Theta (n^{2})$
最优时间复杂度	$\Theta (n\log n)$
平均时间复杂度	$\Theta (n\log n)$
空间复杂度	根据实现的方式不同而不同

public class Quick {

    public static void sort(Comparable[] a){
        sort(a,0,a.length-1);
    }
    private static void sort(Comparable[] a,int low,int high){
        if(high<=low){return; }
        int j=partition(a,low,high);
        sort(a,low,j-1);
        sort(a,j+1,high);
    }
    private static int partition(Comparable[] a,int low,int high){
        int i=low;
        int j=high+1;
        Comparable tmp=a[i];
        while(true){
            while(less(a[++i],tmp)){
                if(i==high) break;
            }
            while(less(tmp,a[--j]));
            if(i>=j) break;
            exch(a,i,j);
        }
        exch(a,low,j);
        return j;
    }
    private static boolean less(Comparable v,Comparable w){
        return v.compareTo(w)<0;
    }
    private static void exch(Comparable[] a,int i,int j){
        Comparable t=a[i];
        a[i]=a[j];
        a[j]=t;
    }
    public static void show(Comparable[] a){
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i]+" ");
        }
        System.out.println();
    }

    public static boolean isSorted(Comparable[] a){
        for (int i = 1; i < a.length; i++) {
            if(less(a[i],a[i-1])) return false;
        }
        return true;
    }

}

堆排序：

堆节点的访问

通常堆是通过一维数组来实现的。在数组起始位置为0的情形中：

父节点i的左子节点在位置 $(2i+1)$ ;
父节点i的右子节点在位置 $(2i+2)$ ;

堆的操作

在堆的数据结构中，堆中的最大值总是位于根节点(在优先队列中使用堆的话堆中的最小值位于根节点)。堆中定义以下几种操作：

最大堆调整（Max_Heapify）：将堆的父节点作调整，使得子节点永远小于父节点
堆排序（HeapSort）：将在第一个数据的根节点与最后一个节点交换位置，然后对交换后的树的根节点进行下沉操作，确保该节点在正确的位置，再次将根节点与倒数第二个节点交换位置，然后进行下沉操作，循环进行，直到整个数组有序。

分类	排序算法
数据结构	数组
最坏时间复杂度	$O(n\log n)$
最优时间复杂度	$O(n\log n)$ ^[1]
平均时间复杂度	$\Theta (n\log n)$
空间复杂度	$O(n)$ total, $O(1)$

//注意该算法构建完全二叉树时，根节点是从1开始的，所以父节点i的左子节点在位置（2i），父节点i的右子节点在位置（2i+1）
public class Heap {
    public static void sort(Comparable[] tmpArray){
        int N=tmpArray.length;
        for(int k=N/2;k>=1;k--){
            sink(tmpArray,k,N);
        }
        while(N>1){
            exch(tmpArray,0,N-1);
            N--;
            sink(tmpArray,1,N);
        }
    }
    private static void sink(Comparable[] a,int k,int N){
        while(2*k<=N){
            int j=2*k;
            if(j<N&&less(a[j-1],a[j])) j++;
            if(!less(a[k-1],a[j-1])) break;
            exch(a,k-1,j-1);
            k=j;
        }
    }
    private static boolean less(Comparable v,Comparable w){
        return v.compareTo(w)<0;
    }
    private static void exch(Comparable[] a,int i,int j){
        Comparable t=a[i];
        a[i]=a[j];
        a[j]=t;
    }
    public static void show(Comparable[] a){
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i]+" ");
        }
        System.out.println();
    }

    public static boolean isSorted(Comparable[] a){
        for (int i = 1; i < a.length; i++) {
            if(less(a[i],a[i-1])) return false;
        }
        return true;
    }
}

常用算法稳定性分析

堆排序、快速排序、希尔排序、直接选择排序不是稳定的排序算法，而基数排序、冒泡排序、直接插入排序、折半插入排序、归并排序是稳定的排序算法。

首先，排序算法的稳定性大家应该都知道，通俗地讲就是能保证排序前2个相等的数其在序列的前后位置顺序和排序后它们两个的前后位置顺序相同。在简单形式化一下，如果Ai = Aj, Ai原来在位置前，排序后Ai还是要在Aj位置前。

其次，说一下稳定性的好处。排序算法如果是稳定的，那么从一个键上排序，然后再从另一个键上排序，第一个键排序的结果可以为第二个键排序所用。基数排序就是这样，先按低位排序，逐次按高位排序，低位相同的元素其顺序再高位也相同时是不会改变的。

回到主题，现在分析一下常见的排序算法的稳定性，每个都给出简单的理由。

(1)冒泡排序

冒泡排序就是把小的元素往前调或者把大的元素往后调。比较是相邻的两个元素比较，交换也发生在这两个元素之间。所以，如果两个元素相等，我想你是不会再无聊地把他们俩交换一下的；如果两个相等的元素没有相邻，那么即使通过前面的两两交换把两个相邻起来，这时候也不会交换，所以相同元素的前后顺序并没有改变，所以冒泡排序是一种稳定排序算法。

(2)选择排序

选择排序是给每个位置选择当前元素最小的，比如给第一个位置选择最小的，在剩余元素里面给第二个元素选择第二小的，依次类推，直到第n-1个元素，第n个元素不用选择了，因为只剩下它一个最大的元素了。那么，在一趟选择，如果当前元素比一个元素小，而该小的元素又出现在一个和当前元素相等的元素后面，那么交换后稳定性就被破坏了。比较拗口，举个例子，序列5 8 5 2 9，我们知道第一遍选择第1个元素5会和2交换，那么原序列中2个5的相对前后顺序就被破坏了，所以选择排序不是一个稳定的排序算法。

(3)插入排序

插入排序是在一个已经有序的小序列的基础上，一次插入一个元素。当然，刚开始这个有序的小序列只有1个元素，就是第一个元素。比较是从有序序列的末尾开始，也就是想要插入的元素和已经有序的最大者开始比起，如果比它大则直接插入在其后面，否则一直往前找直到找到它该插入的位置。如果碰见一个和插入元素相等的，那么插入元素把想插入的元素放在相等元素的后面。所以，相等元素的前后顺序没有改变，从原无序序列出去的顺序就是排好序后的顺序，所以插入排序是稳定的。

(4)快速排序

快速排序有两个方向，左边的i下标一直往右走，当a[i] <= a[center_index]，其中center_index是中枢元素的数组下标，一般取为数组第0个元素。而右边的j下标一直往左走，当a[j] > a[center_index]。如果i和j都走不动了，i <= j, 交换a[i]和a[j],重复上面的过程，直到i>j。交换a[j]和a[center_index]，完成一趟快速排序。在中枢元素和a[j]交换的时候，很有可能把前面的元素的稳定性打乱，比如序列为 5 3 3 4 3 8 9 10 11，现在中枢元素5和3(第5个元素，下标从1开始计)交换就会把元素3的稳定性打乱，所以快速排序是一个不稳定的排序算法，不稳定发生在中枢元素和a[j] 交换的时刻。

(5)归并排序

归并排序是把序列递归地分成短序列，递归出口是短序列只有1个元素(认为直接有序)或者2个序列(1次比较和交换),然后把各个有序的段序列合并成一个有序的长序列，不断合并直到原序列全部排好序。可以发现，在1个或2个元素时，1个元素不会交换，2个元素如果大小相等也没有人故意交换，这不会破坏稳定性。那么，在短的有序序列合并的过程中，稳定是否受到破坏？没有，合并过程中我们可以保证如果两个当前元素相等时，我们把处在前面的序列的元素保存在结果序列的前面，这样就保证了稳定性。所以，归并排序也是稳定的排序算法。

(6)基数排序

基数排序是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优先级排序，最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前。基数排序基于分别排序，分别收集，所以其是稳定的排序算法。

(7)希尔排序(shell)

希尔排序是按照不同步长对元素进行插入排序，当刚开始元素很无序的时候，步长最大，所以插入排序的元素个数很少，速度很快；当元素基本有序了，步长很小，插入排序对于有序的序列效率很高。所以，希尔排序的时间复杂度会比o(n^2)好一些。由于多次插入排序，我们知道一次插入排序是稳定的，不会改变相同元素的相对顺序，但在不同的插入排序过程中，相同的元素可能在各自的插入排序中移动，最后其稳定性就会被打乱，所以shell排序是不稳定的。

(8)堆排序

我们知道堆的结构是节点i的孩子为2*i和2*i+1节点，大顶堆要求父节点大于等于其2个子节点，小顶堆要求父节点小于等于其2个子节点。在一个长为n 的序列，堆排序的过程是从第n/2开始和其子节点共3个值选择最大(大顶堆)或者最小(小顶堆),这3个元素之间的选择当然不会破坏稳定性。但当为n /2-1, n/2-2, ...1这些个父节点选择元素时，就会破坏稳定性。有可能第n/2个父节点交换把后面一个元素交换过去了，而第n/2-1个父节点把后面一个相同的元素没有交换，那么这2个相同的元素之间的稳定性就被破坏了。所以，堆排序不是稳定的排序算法。

综上，得出结论: 选择排序、快速排序、希尔排序、堆排序不是稳定的排序算法，而冒泡排序、插入排序、归并排序和基数排序是稳定的排序算法。

本文部分内容来自维基百科、百度百科、《算法》（第四版）