排序算法（三） —— 直接插入排序

 

1.     減治法（增量法）

 

　　直接插入排序，借鑒了減治法的思想（也有人稱之為增量法）。

• 減治法：對於一個全局的大問題，和一個更小規模的問題建立遞推關系。
• 增量法：基於一個小規模問題的解，和一個更大規模的問題建立遞推關系。

　　

　　可以發現，無論是減治法還是增量法，從本質上來講，都是基於一種建立遞推關系的思想來減小或擴大問題規模的一種方法。

　　

　　很顯然，無論是減治法還是增量法，其核心是如何建立一個大規模問題和一個小規模問題的遞推關系。根據應用的場景不同，主要有以下3種變化形式：

• 減去一個常量。（直接插入排序）
• 減去一個常量因子。（二分查找法）
• 減去的規模可變。（輾轉相除法）

 

 

2.     直接插入排序

 

　　直接插入排序（straight insertion sort），有時也簡稱為插入排序（insertion sort），是減治法的一種典型應用。其基本思想如下：

• 對於一個數組A[0,n]的排序問題，假設認為數組在A[0,n-1]排序的問題已經解決了。
• 考慮A[n]的值，從右向左掃描有序數組A[0,n-1]，直到第一個小於等於A[n]的元素，將A[n]插在這個元素的后面。

　　很顯然，基於增量法的思想在解決這個問題上擁有更高的效率。

 

　　直接插入排序對於最壞情況（嚴格遞減的數組），需要比較和移位的次數為n(n-1)/2；對於最好的情況（嚴格遞增的數組），需要比較的次數是n-1，需要移位的次數是0。當然，對於最好和最壞的研究其實沒有太大的意義，因為實際情況下，一般不會出現如此極端的情況。然而，直接插入排序對於基本有序的數組，會體現出良好的性能，這一特性，也給了它進一步優化的可能性。（希爾排序）

 

　　直接插入排序的時間復雜度是O(n^2)，空間復雜度是O(1)，同時也是穩定排序。

 

　　下面用一個具體的場景，直觀地體會一下直接插入排序的過程。

場景：

現有一個無序數組，共7個數：89 45 54 29 90 34 68。

使用直接插入排序法，對這個數組進行升序排序。

 

89 45 54 29 90 34 68

45 89 54 29 90 34 68

45 54 89 29 90 34 68

29 45 54 89 90 34 68

29 45 54 89 90 34 68

29 34 45 54 89 90 68

29 34 45 54 68 89 90

 

直接插入排序的 Java 代碼實現：

    public static void basal(int[] array) {
        if (array == null || array.length < 2) {
            return;
        }
        // 從第二項開始
        for (int i = 1; i < array.length; i++) {
            int cur = array[i];
            // cur 落地標識，防止待插入的數最小
            boolean flag = false;
            // 倒序遍歷，不斷移位
            for (int j = i - 1; j > -1; j--) {
                if (cur < array[j]) {
                    array[j + 1] = array[j];
                } else {
                    array[j + 1] = cur;
                    flag = true;
                    break;
                }
            }
            if (!flag) {
                array[0] = cur;
            }
        }
    }

 

 

3.     優化直接插入排序：設置哨兵位

 

　　

　　仔細分析直接插入排序的代碼，會發現雖然每次都需要將數組向后移位，但是在此之前的判斷卻是可以優化的。

　　不難發現，每次都是從有序數組的最后一位開始，向前掃描的，這意味着，如果當前值比有序數組的第一位還要小，那就必須比較有序數組的長度n次。這個比較次數，在不影響算法穩定性的情況下，是可以簡化的：記錄上一次插入的值和位置，與當前插入值比較。若當前值小於上個值，將上個值插入的位置之后的數，全部向后移位，從上個值插入的位置作為比較的起點；反之，仍然從有序數組的最后一位開始比較。

 

設置哨兵位優化直接插入排序的 Java 代碼實現：

    // 根據上一次的位置，簡化下一次定位
    public static void optimized_1(int[] array) {
        if (array == null || array.length < 2) {
            return;
        }
        // 記錄上一個插入值的位置和數值
        int checkN = array[0];
        int checkI = 0;
        // 循環插入
        for (int i = 1; i < array.length; i++) {
            int cur = array[i];
            int start = i - 1;
            // 根據上一個值，定位開始遍歷的位置
            if (cur < checkN) {
                start = checkI;
                for (int j = i - 1; j > start - 1; j--) {
                    array[j + 1] = array[j];
                }
            }
            // 剩余情況是：checkI 位置的數字，和其下一個坐標位置是相同的
            // 循環判斷+插入
            boolean flag = false;
            for (int j = start; j > -1; j--) {
                if (cur < array[j]) {
                    array[j + 1] = array[j];
                } else {
                    array[j + 1] = cur;
                    checkN = cur;
                    checkI = j + 1;
                    flag = true;
                    break;
                }
            }
            if (!flag) {
                array[0] = cur;
            }
        }
    }

 

 

4.     優化直接插入排序：二分查找法

 

　　優化直接插入排序的核心在於：快速定位當前數字待插入的位置。在一個有序數組中查找一個給定的值，最快的方法無疑是二分查找法，對於當前數不在有序數組中的情況，官方的 JDK 源碼 Arrays.binarySearch() 方法也給出了定位的方式。當然此方法的入參，需要將有序數組傳遞進去，這需要不斷地組裝數組，既消耗空間，也不現實，但是可以借鑒這方法，自己實現類似的功能。

　　這種方式有一個致命的缺點，導致雖然效率高出普通的直接插入排序法很多，但是卻不被使用。就是這種定位方式找到的位置，最終形成的數組會打破排序算法的穩定性。既然一定會打破穩定性，那么為什么不使用更優秀的希爾排序呢？

 

二分查找法優化直接插入排序的 Java 代碼實現：

    // 利用系統自帶的二分查找法，定位插入位置
    // 不穩定排序
    public static void optimized_2(int[] array) {
        if (array == null || array.length < 2) {
            return;
        }
        for (int i = 1; i < array.length; i++) {
            int cur = array[i];
            int[] sorted = Arrays.copyOf(array, i);
            int index = Arrays.binarySearch(sorted, cur);
            if (index < 0) {
                index = -(index + 1);
            }
            for (int j = i - 1; j > index - 1; j--) {
                array[j + 1] = array[j];
            }
            array[index] = cur;
        }
    }

    // 自己實現二分查找
    // 不穩定排序
    public static void optimized_3(int[] array) {
        if (array == null || array.length < 2) {
            return;
        }
        for (int i = 1; i < array.length; i++) {
            int cur = array[i];
            // 二分查找的高位和低位
            int low = 0, high = i - 1;
            // 待插入的索引位置
            int index = binarySearch(array, low, high, cur);
            for (int j = i - 1; j > index - 1; j--) {
                array[j + 1] = array[j];
            }
            array[index] = cur;
        }
    }

    // 二分查找，返回待插入的位置
    private static int binarySearch(int[] array, int low, int high, int cur) {
        while (low <= high) {
            int mid = (low + high) >>> 1;
            int mVal = array[mid];
            if (mVal < cur) {
                low = mid + 1;
            } else if (mVal > cur) {
                high = mid - 1;
            } else {
                return mid;
            }
        }
        // 未查到
        return low;
    }

 

 

5.     簡單的性能比較

 

　　

　　最后，通過以下程序，簡單地統計一下上述各種方法的運行時間。

 

    public static void main(String[] args) {

        final int size = 100000;
        // 模擬數組
        int[] array = new int[size];
        for (int i = 0; i < array.length; i++) {
            array[i] = new Random().nextInt(size) + 1;
        }
        
        // 時間輸出：納秒
        long s1 = System.nanoTime();
        StraightInsertion.basal(array);
        long e1 = System.nanoTime();
        System.out.println(e1 - s1);
    }

 

執行結果：

 

結論如下：

• 在某些特定場景下，由於入參的條件不同，不能執着於 JDK 給的現有方法，自定義的實現效率，可能高於源碼的效率。
• 對於小規模的數組，優化的結果和預想的向左，效率比不上最初的方法。原因在於本身只是對於判斷的優化，而不是執行次數的優化。在每次循環中，加上更多的計算去優化這個判斷，在小數組上對於整個排序的效率，反而是一種傷害。
• 大規模數組，二分查找優化效率明顯。

 

 

相關鏈接：

https://github.com/Gerrard-Feng/Algorithm/blob/master/Algorithm/src/com/gerrard/sort/StraightInsertion.java

 

PS：如有描述不當之處，歡迎指正！