16-希尔排序

1. 引入

插入排序存在的问题： 现在有这么一个数组，arr={2,3,4,5,6,1}；现在需要插入的数 1 (最小)，过程是：

{2,3,4,5,6,6} → {2,3,4,5,5,6} → {2,3,4,4,5,6} → {2,3,3,4,5,6} → {2,2,3,4,5,6} → {1,2,3,4,5,6}

[结论] 当需要插入的数是较小的数时，后移的次数明显增多，对效率有影响。

2. 概述

• 希尔排序也是一种插入排序，它是简单插入排序经过改进之后的一个更高效的版本，也称为缩小增量排序。
• 基本思想
  • 希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序
  • 随着增量逐渐减少，每组包含的关键词越来越多
  • 当增量减至1时，整个文件恰被分成一组，算法便终止
• 较之于〈插入排序〉效率高的原因：
  • 在间隔大的时候，挪动的次数少
  • 在间隔小的时候，挪动的距离短

3. 标配

• 平均时间复杂度：O(n^1.3)
• 最坏时间复杂度：O(n^2)
• 最好时间复杂度：O(n)
• 空间复杂度：O(1)，内排序
• 不稳定 // 比方说有俩 1，排之前 ..., a1, ..., b1, ... 排之后可能会出现 b1, a1, ...

4. 举例

• 希尔排序的思想是使数组中任意间隔为 h 的元素都是有序的。这样的数组被称为h 有序数组。换句话说，一个h 有序数组就是h 个互相独立的有序数组编织在一起组成的一个数组。
• 在进行排序时，如果 h 很大，我们就能将元素移动到很远的地方，为实现更小的 h 有序创造方便。用这种方式，对于任意以 1 结尾的 h 序列，我们都能将数组排序 → 这就是希尔排序。

5. 代码实现

public class ShellSort {
    public static void main(String[] args) {
        int[] arr = {9, 6, 11, 3, 5, 12, 8, 7, 10, 15, 14, 4, 1, 13, 2};
        print(arr);
        sortBySwap(arr);
        print(arr);
    }

    public static void sortBySwap(int[] arr) {
        // 比每次按半劈效率高
        // Knuth 序列: h = 1, h = 3 * h - 1
        int h = 1;
        // 退出时 h 等于 arr.length 分割时的最大间隔
        while (h <= arr.length / 3) h = h * 3 + 1;
        /*
         * i = gap;
         * - 相隔 gap 个的元素构成一个数组，对这些 [子数组(h数组)] 进行插入排序
         * - 回忆插入排序的思想，外层 for 循环为啥 i 上来就是 1？
         *     把 n 个待排序的元素看成为一个有序表和一个无序表，开始时有序表中只
         *     包含 1 个元素，无序表中包含有 n-1 个元素 (这其中第一个元素在原始
         *     数组中的索引不就是 1 吗)，排序过程中每次从无序表中取出第一个元素，
         *     把它的排序码依次与有序表元素的排序码进行比较，将它插入到有序表中的
         *     适当位置，使之成为新的有序表。
         * - Shell = 插排思想 + [h数组]
         *     → i 初始化为 [h数组] 中的无序表的第 1 个元素，也就是 i = gap。
         * -----------------------------------------------------------------
         * i++;
         * - i+=gap 只能实现第 1 个子数组有序，应该把间隔为 gap 的子数组都排序
         * - 多个 [h数组] 编制在一起构成原始数组，i++ 直到 length-1，则保证了对
         *     每个 [h数组] 的元素都进行了插入排序
         * - 外层的一个循环周期(gap次)之后，就会使每个 [h数组] 中的有序表元素数+1
         * -----------------------------------------------------------------
         * j > gap-1
         * - 因为条件的右半部分是 a[j] < a[j-gap]
         *     如果条件左边写的是 j > 0，再配合着 a[j-gap] 可不就数组下标越界了吗？
         * - 又因为这是 [h数组], 每个 [h数组] 的第1个元素：0, 1, ... , gap-1
         *     故结合 a[j-gap]，j 最小应等于 gap -> a[j-gap] = a[0]
         */
        for (int gap = h; gap > 0; gap = (gap-1)/3)
            for (int i = gap; i < arr.length; i++)
                for (int j = i; j > gap-1 && arr[j] < arr[j-gap]; j -= gap)
                    swap(arr, j, j-gap);
    }

    public static void sortByMove(int[] arr) {
        int insertIndex, insertValue;
        for (int gap = arr.length >> 1; gap > 0; gap/=2) {
            for (int i = gap; i < arr.length; i++) {
                insertIndex = i;
                insertValue = arr[insertIndex];
                while (insertIndex > gap-1 && insertValue < arr[insertIndex-gap]) {
                    arr[insertIndex] = arr[insertIndex-gap];
                    insertIndex -= gap;
                }
                arr[insertIndex] = insertValue;
            }
        }
    }

    public static void print(int[] arr) {
        for (int i = 0; i < arr.length; i++)
            System.out.print(arr[i] + " ");
        System.out.println();
    }

    public static void swap(int[] arr, int a, int b) {
        int temp = arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }
}

6. sortBySwap全过程