有個叫希爾的人提出的演算法

據說是基於插入排序的性質進行的優化：
1、插入排序在對幾乎已經排好序的資料操作時，效率高，即可以達到線性排序的效率。
2、但插入排序一般來說是低效的，因為插入排序每次只能將資料移動一位。

解釋：
假設全域性上大的全部在後面，小的前面在前面；區域性上也滿足這個條件，那麼交換的次數將大大降低。
假設最大值在前面，排序完成最大值需要移動n次才能移動到最後，因為每次都只能移動一位。假設我們能一次把這個最大值移動到後面，接近將來目標的位置，效率就提高了很多。

希爾排序思路：
將序列按照步長分組，分別兩兩取0 0+step， 1 1+step， 2 2+step進行排序，這樣大的部分就到了後面
然後按照一定規則，遞減步長，直到步長為1，排序完成，，，
只要保證最後一次會用1進行簡單插入排序，結果一定是滿足排序規則的，前面的過程其實是將陣列往前面小，後面大的趨勢格式化。所以我們可以藉助之前實現的二分插入排序，在外面再套一層迴圈，迴圈一個增量序列，將間隔傳入內層迴圈，我的程式碼也是這麼實現的。

序列理論上可以任意選擇，只要最後一次序列為1，理論上序列怎麼選都可以，當然目的是更快
這個數列如何選取才是最優是個數學難題，至今未有最優解，只有根據經驗來的最優解

有多種增量序列，其中最快的是塞奇威克的增量序列
1、希爾（Shell）原始步長序列：N / 2，N / 4，…，1（重複除以2），步長的選擇簡單粗暴，但是思想很重要;
2、希伯德（Hibbard）的步長序列：1，3，7，…。由前面的數用2 k + 1遞迴獲得;
3、克努特（Knuth）的步長序列：1，4，13，…。由前面的數用3 k + 1遞迴獲得;
4、塞奇威克（Sedgewick） 的步長序列：1，5，19，41，109，….
　　它是通過交織兩個序列的元素獲得的： 步長序列陣列下標 n 從0開始，奇數的k值從0開始，逢奇數+1；偶數的下標從2開始，逢偶數+1，定義k1 = 0;k2 = 2;
　　n偶數用 ：1，19，109，505，2161，…。
　　公式為：9（4 ^k1 - 2^ k1）+ 1；然後k1++…
　　n奇數用 ：5，41，209，929，3905，…。
　　公式為：4 ^k2- 3(2^k2)+ 1；然後k2++…

專家們提倡，幾乎任何排序工作在開始時都可以用希爾排序，若在實際使用中證明它不夠快，再改成快速排序這樣更高階的排序演算法.

時間複雜度：
最差n(log(n))，最快n

穩定性：
不穩定，因為被拆開之後不會相鄰比較，所以不能保持穩定性

Java程式碼實現：
public static void main(String[] args){
int[] arr = new int[]{10, 1, 4 ,2 , 8, 3, 5};

System.out.println(Arrays.toString(indexSort1(arr)));
arr = new int[]{10, 1, 4 ,2 , 8, 3, 5};
System.out.println(Arrays.toString(indexSort2(arr)));
arr = new int[]{10, 1, 4 ,2 , 8, 3, 5};
System.out.println(Arrays.toString(shellIndexSort(arr)));
 

}

/**
* 相鄰逐個比較，找到合適的位置，放入
* @param arr
* @return
*/
private static int[] indexSort1(int[] arr){

// 外層控制次數，從1開始，不必從0開始
for(int i = 1;i < arr.length;i++){
    // 從後向前比較
    int idx = i;
    int value = arr[idx];
    // 1 2 3 4 3
    // 拿著value和前面的資料比，直到找到第一個大於等於的位置，和j比大於等於，那麼j+1，就是要插入的位置
    // 找到第一個後面大等於前面的位置，停下來，這個位置後一個位置就是要放入的位置
    // 有可能第一趟就停了下來，這個時候j應該為j+1
    // 2 3 4 1
    // 如果一直找不到，找到0
    for(int j = idx - 1; j >= 0; j--){
        // 記錄當前位置
        idx = j;
        if(value >= arr[j]){
            idx = j + 1;
            break;
        }
    }

    // 將從找到的位置開始到i的位置（不包括i）的資料全部後移一位
    for(int j = i - 1; j >= idx; j--){
        arr[j + 1] = arr[j];
    }
    arr[idx] = value;
}
return arr;

}

/**
* 使用二分查詢法查詢應該插入的位置
* @param arr
* @return
*/
private static int[] indexSort2(int[] arr){
return binarySort(arr, 1);
}

/**
* 使用二分查詢的插入排序，使用step作為引數，用來在希爾排序中複用這個方法
* @param arr
* @param step
* @return
*/
private static int[] binarySort(int[] arr, int step){
for(int i = 1; i< arr.length;i++){
int idx = i;
int value = arr[idx];
// 找到應該插入的位置
int insertIndex = binarySearch(arr, value, 0, i - 1);
for(int j = i - 1; j >= insertIndex; j–){
arr[j + 1] = arr[j];
}
arr[insertIndex] = value;
}
return arr;
}

/**
* 遞迴查詢
* @param arr
* @param value
* @param startIndex
* @param endIndex
* @return
*/
private static int binarySearch(int[] arr, int value, int startIndex, int endIndex){
// 推到startIndex = endIndex的時候，就是應該退出的時候
// 假設0-9，獲取中間一位4，前半部分[0 - 4] 後半部分 [5 - 9]
// 假設0-8，獲取中間一位4，前半部分[0-4] 後半部分[5-8]
// 如果中間一位大於等於，往後找，否則往前找
// 如果找到startIndex等於endIndex的時候，無論如何都應該退出
// 考慮一般情況，如果
// 最終返回值應該是0~endIndex+1之間的數，因為多了一位數，這個數可能在最後
// 舉特例：假設往1 或者 2 後面插入2，2的位置應該是endIndex + 1
// 假設往2 裡插入1,1的位置應該是0，也就是startIndex
if(startIndex == endIndex){
// 往後往前的邏輯和下面一樣其實
if(arr[startIndex] <= value){
return startIndex + 1;
}else{
return startIndex;
}
}
int midIndex = (startIndex + endIndex) / 2;
if(arr[midIndex] <= value){
return binarySearch(arr, value, midIndex + 1, endIndex);
}else{
return binarySearch(arr, value, 0, midIndex);
}
}

/**
* 使用希爾的分組排序，最後直接插入排序
* 其實就是在上面的排序外面再套一層殼子，然後先進行一些少次但是結果很有用的排序，這樣後面的排序就會快很多
* @param arr
* @return
*/
private static int[] shellIndexSort(int[] arr){
// 先計算步長陣列
int[] gap = getGap(arr.length);

// 從大到小的間隔
for(int i = gap.length - 1; i >= 0; i--){
    // 使用間隔來比較
    arr = binarySort(arr, gap[i]);
}

return arr;

}

/**
* 獲取塞奇威克的增量序列，這個公式網上全是錯誤的，麻痺
* @param len
* @return
*/
private static int[] getGap(int len){
List gap = new ArrayList();
int i = 0;
int startup1 = 0;
int startup2 = 2;
int value = 0;
while(true){
if(i % 2 == 0){
value = (int)(9 * (Math.pow(4, startup1) - Math.pow(2 ,startup1)) + 1);
startup1++;
}else{
value = (int)(Math.pow(4, startup2) - 3 * Math.pow(2 ,startup2) + 1);
startup2++;
}
gap.add(value);
i++;
if(value >= len){
System.out.println(gap);
int[] arr = new int[gap.size()];
for(int j = 0; j < arr.length;j++){
arr[j] = gap.get(j);
}
return arr;
}
}
}