希爾排序

1. 基本思路
2. 執行軌跡
3. 程式碼實現
4. 效能分析
5. 優化方案

1、基本思路

什麼希爾排序？ 一種基於插入排序的快速的排序演算法。

希爾排序為了加快速度簡單的改進了插入排序，交換不相鄰的元素 以對陣列的區域性進行排序，並最終用插入排序將區域性有序的陣列排序。（區域性有序的陣列很適合插入排序）

希爾排序的思想？ 使陣列中任意間隔為 h 的元素都是有序的。這樣的陣列被稱為 h 有序陣列，也就是說：一個 h 有序陣列就是 h 個相互獨立的有序陣列編織在一起組成的一個數組。

它的一種實現方法： 在插入排序的程式碼中將移動元素的距離由 1 改為 h 即可。

h 的取值？ while( h < arr.length/3 ) h = 3*h + 1 ； //（1、4、13、40、121、364、1093…）

優點：希爾排序對於中等大小的陣列，執行時間是可以接受的，程式碼量少，且不需要使用額外的記憶體空間。

2、執行軌跡

增幅 h 的初始值是陣列長度乘以一個常數因子，最小為 1 。
當 h = 4 時，4-sort；
當 h = 1 時，1-sort；

3、程式碼實現

根據實現選擇排序（提醒：點藍字檢視詳情）

import java.util.Random;

/**
 * 希爾排序
 *
 * @author TinyDolphin
 *         2017/5/30 22:33.
 */
public class Shell {
    /**
     * 排序實現
     *
     * @param
 
 arr 待排序陣列
     */
    public static void sort(Comparable[] arr) {
        int length = arr.length;
        int h = 1;
        while (h < length / 3) {
            h = 3 * h + 1;  // 1 , 4 , 13 , 40 , 121 , 364 , 1093...
        }
        while (h >= 1) {
            // 將陣列變為 h 有序
            for (int
 
 indexI = h; indexI < length; indexI++) {
                for (int indexJ = indexI; indexJ >= h && less(arr[indexJ], arr[indexJ - h]); indexJ -= h) {
                    exch(arr, indexJ, indexJ - h);
                }
            }
            h = h / 3;
        }
    }

    /**
     * 比較兩個元素的大小
     *
     * @param comparableA 待比較元素A
     * @param comparableB 待比較元素B
     * @return 若 A < B,返回 true,否則返回 false
     */
    private static boolean less(Comparable comparableA, Comparable comparableB) {
        return comparableA.compareTo(comparableB) < 0;
    }

    /**
     * 將兩個元素交換位置
     *
     * @param arr    待交換元素所在的陣列
     * @param indexI 第一個元素索引
     * @param indexJ 第二個元素索引
     */
    private static void exch(Comparable[] arr, int indexI, int indexJ) {
        Comparable temp = arr[indexI];
        arr[indexI] = arr[indexJ];
        arr[indexJ] = temp;
    }

    /**
     * 列印陣列的內容
     *
     * @param arr 待列印的陣列
     */
    private static void show(Comparable[] arr) {
        for (int index = 0; index < arr.length; index++) {
            System.out.print(arr[index] + " ");
        }
        System.out.println();
    }

    /**
     * 判斷陣列是否有序
     *
     * @param arr 待判斷陣列
     * @return 若陣列有序，返回 true，否則返回 false
     */
    public static boolean isSort(Comparable[] arr) {
        for (int index = 1; index < arr.length; index++) {
            if (less(arr[index], arr[index - 1])) {
                return false;
            }
        }
        return true;
    }

    public static void main(String[] args) {
        Integer[] arr = new Integer[100000];
        for (int index = 0; index < 100000; index++) {
            arr[index] = new Random().nextInt(100000) + 1;
        }
        long start = System.currentTimeMillis();
        sort(arr);      //耗費時間：480ms
        long end = System.currentTimeMillis();
        System.out.println("耗費時間：" + (end - start) + "ms");
        assert isSort(arr);
    }
}

4、效能分析

演算法的效能不僅取決於 h ， 還取決於 h 之間的數學性質，比如它們的公因子等。

使用遞增序列 1、4、13、40、121、364… 的希爾排序所需的比較次數不會超過 N 的若干倍乘以遞增序列的長度。

在實際應用中，h 的取值使用以上遞增序列基本就足夠了。但是我們為了追求效能的提升，也使用以下的序列，使效能提高 20%-40% 。1、5、19、41、109、209、505、929、2161、3905、8929、16001、36289、64769、146305、260609（這是通過 9×4^k-9×2^k+1(k=1,2,3,4,5…) 和 4^k-3×2^k+1(k=2,3,4,5,6…) 綜合得到的）

希爾排序更加高效的原因：它權衡了子陣列的規模和有序性。

和選擇排序以及插入排序形成對比的是：希爾排序也可以用於大型陣列。它對任意排序（不一定是隨機的）的陣列表現也很好。希爾排序比插入排序和選擇排序要快的多，並且陣列越大，優勢越大。【提示：點選藍色字型，可以檢視其詳細資訊。】

什麼時候用希爾排序？ 當你需要解決一個排序問題而又沒有系統排序函式可用（例如直接接觸硬體或是運行於嵌入式系統中的程式碼）時，可用先用希爾排序，然後再考慮是否值得將它替換為更加複雜的排序演算法。

※ 研究演算法的設計和效能的主要原因之一：通過提升速度來解決其他方式無法解決的問題。

5、優化方案

第一種：使用更為複雜的遞增序列，效能可以提高 20%-40%（這裡就不說了，上述的遞增序列夠用）

第二種：因為是基於插入排序的，所以可以使用其插入排序中給出的優化方案。

優化之後執行軌跡：
增幅 h 的初始值是陣列長度乘以一個常數因子，最小為 1 。
當 h = 4 時，4-sort；
當 h = 1 時，1-sort；

優化之後程式碼：

    public static void sortPlus(Comparable[] arr) {
        int length = arr.length;
        int h = 1;
        while (h < length / 3) {
            h = 3 * h + 1;  // 1 , 4 , 13 , 40 , 121 , 364 , 1093...
        }
        int exchanges = 0; //交換次數
        //若 arr[index] < arr[index - 1]，則交換兩數
        for (int index = length - 1; index > 0; index--) {
            if (less(arr[index], arr[index - 1])) {
                exch(arr, index, index - 1);
                exchanges++;
            }
        }
        //若交換次數為0（即陣列有序），則無需進行下一步排序。
        if (exchanges == 0) return;
        //若有交換次數，表明目前的陣列無序。
        while (h >= 1) {
            // 將陣列變為 h 有序
            for (int indexI = h; indexI < length; indexI++) {
                Comparable temp = arr[indexI];  //記錄一下arr[indexI]的值
                int indexJ = indexI;            //indexI 的代替品
                //若 indexJ 的前 h 位元素小於 temp，則將小於temp的元素向右移動 h 位
                //需要注意：可能會出現 indexJ < h 的情況。而一般的插入排序不會出現。
                while (indexJ >= h && less(temp, arr[indexJ - h])) {
                    arr[indexJ] = arr[indexJ - h];
                    indexJ -= h;
                }
                arr[indexJ] = temp; //將記錄的值放在 indexJ 的位置上
            }
            h = h / 3;
        }
    }

測試程式碼：
【】，提示：點選藍色字型檢視方法詳情。

    public static void main(String[] args) {
        int length = 10000000;//千萬級別
        Integer[] arr = new Integer[length];
        Integer[] arr2 = new Integer[length];
        for (int index = 0; index < length; index++) {
            arr[index] = new Random().nextInt(length) + 1;
        }
        //高效複製陣列的方法
        System.arraycopy(arr, 0, arr2, 0, arr.length);

        long start = System.currentTimeMillis();
        sort(arr);  //千萬級別-耗費時間：43690ms //百萬-耗費時間：2845ms //十萬-耗費時間：226ms
        long end = System.currentTimeMillis();
        System.out.println("耗費時間：" + (end - start) + "ms");
        assert isSort(arr);

        start = System.currentTimeMillis();
        sortPlus(arr2); //千萬級別-耗費時間：32513ms //百萬-耗費時間：1592ms //十萬-耗費時間：252ms
        end = System.currentTimeMillis();
        System.out.println("耗費時間：" + (end - start) + "ms");
        assert isSort(arr2);
    }

※由以上測試可知，當資料量越大（超過十萬級別）的時候，優化效果越明顯。

注意：編譯器預設不適用 assert 檢測（但是junit測試中適用），所以要使用時要新增引數虛擬機器啟動引數-ea
具體新增過程，請參照