算法——希尔排序

前言

为了学习面试中常常要考察到的希尔排序，在网上搜索了很多篇资料，才大致搞懂了希尔排序的原理。现在作出总结，以防日后忘记。

介绍

希尔排序(Shell’s Sort)是插入排序的一种又称“缩小增量排序”（Diminishing Increment Sort），是直接插入排序算法的一种更高效的改进版本。
希尔排序是非稳定排序算法。该方法因D.L.Shell于1959年提出而得名。
希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。

特点

• 时间复杂度
  • 最好情况：O(n)
  • 平均情况：O($n^1{.}^3$)
  • 最坏情况：O($n^2$)
• 空间复杂度：O(1)
• 稳定性：不稳定

基本思想

• 希尔排序，也称递减增量排序算法，是插入排序的一种更高效的改进版本。但希尔排序是非稳定排序算法。
• 希尔排序是基于插入排序的以下两点性质而提出改进方法的：
• 插入排序在对几乎已经排好序的数据操作时，效率高，即可以达到线性排序的效率；
• 但插入排序一般来说是低效的，因为插入排序每次只能将数据移动一位；
• 希尔排序的基本思想是：先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录进行依次直接插入排序。

实现

假设存在这样一个数组a[10]，数组中存在有10个10以下的数：

a[10] = [8,9,1,7,2,3,5,4,6,0];

这里用表格显示该数组，即为：

表格①

0	1	2	3	4	5	6	7	8	9
8	9	1	7	2	3	5	4	6	0

首先，选择增量。
初始增量gap = 10 / 2 = 5，缩小增量继续以 gap = gap / 2 的方式进行
根据这个增量来划分，整个数组便分成了5组：
【 8 , 3 】，【 9 , 5 】，【 1 , 4 】，【 7 , 6 】，【 2 , 0 】，用表格来显示即为：

表格②

0	1	2	3	4	5	6	7	8	9
8	9	1	7	2	3	5	4	6	0

对这分开的5组分别使用插入排序，变换后的数组用表格表示即为：

表格③

0	1	2	3	4	5	6	7	8	9
3	5	1	6	0	8	9	4	7	2

可以发现，这5组中的相对小元素都被调到前面了。
缩小增量gap = gap / 2 = 5 / 2 = 2
根据这个增量来划分，整个数组便分成了两组
【 3 , 1 , 0 , 9 , 7 】，【 5 , 6 , 8 , 4 , 2 】，用表格来显示即为：

表格④

0	1	2	3	4	5	6	7	8	9
3	5	1	6	0	8	9	4	7	2

对这分开的2组分别使用插入排序，变换后的数组用表格表示即为：

表格⑤

0	1	2	3	4	5	6	7	8	9
0	2	1	4	3	5	7	6	9	8

可以发现，这2组中的相对小元素都被调到前面了，并且整个数组的有序性已经凸显出来了
继续缩小增量gap = gap / 2 = 2 / 2 = 1
根据这个增量来划分，整个数组便分成了一组
【 0， 2 , 1 , 4 , 3 , 5 , 7 , 6 , 9 , 0 】
根据之前的方法，只需要对这个数列进行简单的微调，不需要大量的移动操作便可完成整个数组的排序

总结

1. 选择一个增量序列 t1，t2，……，tk，其中 ti > tj, tk = 1；
2. 按增量序列个数 k，对序列进行 k 趟排序；
3. 每趟排序，根据对应的增量 ti，将待排序列分割成若干长度为 m 的子序列，分别对各子表进行直接插入排序。仅增量因子为 1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。

代码实现

这里仅列出用Java代码实现的版本，其他版本可以参考网上的其他资料

public class Test2 {
    public static void main(String[] args) {
            //希尔排序，是对直接插入排序的一种改进，他的思想选择一个合适的增量，然后经过一轮插入排序后，就会让数组大致有序
            //然后不断的缩小增量，进行插入排序，直到增量为1 整个排序结束
            int arr[] = {24, 69, 80, 57, 13};
            shellSort(arr);
            //其实我们的直接插入排序，就是增量为1的希尔排序

            //int h = 1;
            //for (int i = h; i < arr.length; i++) {
            //    for (int j = i; j > h - 1; j -= h) {
            //        if (arr[j] < arr[j - h]) {
            //            swapValue(arr, j, j - h);
            //        }
            //    }
            //}
            System.out.println(Arrays.toString(arr));
        }

        private static void shellSort(int[] arr) {
            //定义增量为4
       /* int h=4;
        for (int i = h; i < arr.length; i++) {
            for (int j = i; j > h - 1; j-=h) {
                if (arr[j] < arr[j - h]) {
                    swapValue(arr, j, j - h);
                }
            }
        }

        h = 2;
        for (int i = h; i < arr.length; i++) {
            for (int j = i; j > h - 1; j -= h) {
                if (arr[j] < arr[j - h]) {
                    swapValue(arr, j, j - h);
                }
            }
        }

        h = 1;
        for (int i = h; i < arr.length; i++) {
            for (int j = i; j > h - 1; j -= h) {
                if (arr[j] < arr[j - h]) {
                    swapValue(arr, j, j - h);
                }
            }
        }*/
            //间隔选为4 不是很合理
       /* for (int h = 4; h>0; h/=2) {
            for (int i = h; i < arr.length; i++) {

                for (int j = i; j > h - 1; j -= h) {

                    if (arr[j] < arr[j - h]) {
                        swapValue(arr, j, j - h);
                    }
                }
            }
        }*/
            //间隔得选取合理 ：一般第一次的增量我们选取数组长度的一半
       /* for (int h = arr.length/2; h > 0; h /= 2) {
            for (int i = h; i < arr.length; i++) {

                for (int j = i; j > h - 1; j -= h) {

                    if (arr[j] < arr[j - h]) {
                        swapValue(arr, j, j - h);
                    }
                }
            }
        }
*/
            //克努特序列
            //int h=1;
            //h=3*h+1; // 1,4,13,40,121,364


            //我要选择一个合适的增量 使用克努特序列来选

            int jianGe = 1;
            while (jianGe <= arr.length / 3) {
                jianGe = 3 * jianGe + 1;
            }

            for (int h = jianGe; h > 0; h = (h - 1) / 3) {
                for (int i = h; i < arr.length; i++) {

                    for (int j = i; j > h - 1; j -= h) {

                        if (arr[j] < arr[j - h]) {
                            int t = arr[j];
                            arr[j] = arr[j - h];
                            arr[j - h] = t;
                        }
                    }
                }
            }

        }
    }

拓展：克努特序列

克努特序列，即一种在哈希排序中寻找增量的最佳方式，代码如下：

int h=1;
h=3*h+1; // 1,4,13,40,121,364