希尔排序在三种著名增量下的时间性能比较

希尔排序是什么？

希尔增量
最坏时间复杂度：O(n^2)
教材上都是以希尔增量为例子 => [N/2, (N/2)/2, …]

void shellSort1(int[] arr){
        for (int gap = arr.length / 2; gap > 0; gap /= 2){ //排序趟数
            for (int i = gap; i < 2 * gap; i++) { //每趟排序组数
                //每组使用直接插入排序
                for (int j = i; j < arr.length; j += gap){
                    int pivot = arr[j];
                    int k;
                    for (k = j - gap; k >= 0; k -= gap){
                        if (arr[k] > pivot)
                            arr[k + gap] = arr[k];
                        else break;
                    }
                    arr[k + gap] = pivot;
                }
            }
        }
    }

Hibbard增量
最坏时间复杂度：O(n^1.5)
增量序列：2^k-1 => [1, 3, 7, 15, …]

	//构造Hibbard增量序列：
    List<Integer> getGapListH(int[] arr){
        List<Integer> list = new ArrayList<>();
        int i = 0;
        while (true){
             i = 2 * i + 1;
             if (i < arr.length)
                 list.add(i);
             else break;
             ++i;
        }
        return list;
    }

Sedgewick增量
最坏时间复杂度：O(n^(4/3))
增量序列：

9 * 4 ^ i - 9 * 2 ^ i + 1或4 ^ (i + 2) - 3 * 2 ^ (i + 2) + 1

变一下型： 9 * 2 ^ 2i - 9 * 2 ^ i + 1或2 ^ 2 * (i + 2) - 3 * 2 ^ (i + 2) + 1

增量序列是上面两个通项公式交替计算出来的 => [1, 5, 19, 41, 109, …]

	//构造Sedgewick增量序列：
    List<Integer> getGapListS(int[] arr){
        List<Integer> list = new ArrayList<>();
        int i = 0;
        while (true){
            int n = 9 * (1 << (2 * i)) - 9 * (1 << i) + 1;
            if (n < arr.length)
                list.add(n);
            else
                break;
            n = (1 << (2 * (i + 2))) - 3 * (1 << (i + 2)) + 1;
            if (n < arr.length)
                list.add(n);
            else
                break;
            ++i;
        }
        return list;
    }

对于Sedgewick增量的两通项，我怀疑过是否存在相等的情况，这一点很重要，会影响我的代码书写，于是我找了一个网上计算器

计算表面相等解全是负的，所以不用担心啦！

另外我将Hibbard增量和Sedgewick增量的构造过程单独提取出来，因为它们很显然不应该属于排序过程（事实上我测试过，就算和排序过程合并，结果表明增量构造过程用时相当少，远少于排序耗时，对整体影响甚微）。

下面排序过程为上面Hibbard增量 和 Sedgewick增量 公用

void shellSort2(int[] arr, List<Integer> list){
        for (int e = list.size() - 1; e >= 0; e--){
            int gap = list.get(e);
            for (int i = gap; i < Math.min(arr.length, 2*gap); i++) {
                for (int j = i; j < arr.length; j += gap){
                    int pivot = arr[j];
                    int k;
                    for (k = j - gap; k >= 0; k -= gap){
                        if (arr[k] > pivot)
                            arr[k + gap] = arr[k];
                        else break;
                    }
                    arr[k + gap] = pivot;
                }
            }
        }
    }

主函数

    @Test
    public void test2(){
        int[] arr1 = new int[9999999];
        for (int i = 0; i < arr1.length; i++) {
            arr1[i] = (int)(Math.random()*arr1.length);
        }
        int[] arr2 = arr1.clone();
        int[] arr3 = arr1.clone();

        long start1 = System.currentTimeMillis();
        shellSort1(arr1);
        long end1 = System.currentTimeMillis();
        System.out.println("希尔增量耗时：" + (end1 - start1) + "ms");

        List<Integer> listH = getGapListH(arr2);
        long start2 = System.currentTimeMillis();
        shellSort2(arr2, listH);
        long end2 = System.currentTimeMillis();
        System.out.println("Hibbard增量耗时：" + (end2 - start2) + "ms");

        List<Integer> listS = getGapListS(arr3);
        long start3 = System.currentTimeMillis();
        shellSort2(arr3, listS);
        long end3 = System.currentTimeMillis();
        System.out.println("Sedgewick增量耗时：" + (end3 - start3) + "ms");
    }

运行结果

上面虽然只是一次输出结果，但是我在其他次运行结果中均发现了Hibbard增量和希尔增量下的排序时间相差不大的事实，但是Sedgewick增量下的排序确实快了很多