整理排序算法（四）：希尔排序

    /**
     * 希尔排序：
     * 每次都将元素分成一些小组，在小组内进行排序。
     * 小组根据元素数量划分。
     * 小组跨度一般是元素数量的一半。
     * 此后每次跨度都除以二。
     * 一直到最后，小组跨度变成1。
     * 这样就变成插入排序了。
     * <p>
     * 希尔排序的复杂度和增量序列是相关的
     * {1,2,4,8,...}这种序列并不是很好的增量序列，使用这个增量序列的时间复杂度（最坏情形）是O(n^2)
     * Hibbard提出了另一个增量序列{1,3,7，...,2^k-1}，这种序列的时间复杂度(最坏情形)为O(n^1.5)
     * Sedgewick提出了几种增量序列，其最坏情形运行时间为O（n^1.3）,其中最好的一个序列是{1,5,19,41,109,...}
     *
     * @param arr
     */
    public static void xierSort(int[] arr) {
        //        初始化元素跨度
        int span = arr.length / 2;
        while (span >= 1) {
            //            比较的是两个跨度之间的数据
            // 因为这个是从头开始的，所以每遍历一次，前面的跨度值已经是顺序了
            for (int i = span; i < arr.length; i++) {
                int tmp = arr[i];//记录
                int j = i - span; // 找到前一个跨度的下标
                while (j >= 0 && arr[j] > tmp) { // 这个下标大于0，并且下标的值比记录的值大
                    arr[j + span] = arr[j]; // 交换比较的两个位置，当span=1就是插入排序的意思了。
                    j = j - span; // 每一个跨度进行比较
                }
                arr[j + span] = tmp; //
            }
            span = span / 2;
        }
    }

    /**
     * 这种方法好理解一些，外面就是跨度。里面和简单插入一模一样
     * @param arr
     */
    public static void xierSort2(int[] arr) {
        //        初始化元素跨度
        int span = arr.length / 2;
        while (span >= 1) {
            //            里面完全可以就是插入排序
            for (int i = span; i < arr.length; i++) {
                int tmp = arr[i];
                for (int j = i; j >= 0; j -= span) {
                    //                    后一个比前一个值大，交换位置，这已经是有序序列
                    if (j - span >= 0 && arr[j - span] > tmp) {
                        arr[j] = arr[j - span];
                    } else {//找到tmp的位置
                        arr[j] = tmp;
                        break;
                    }
                }
            }
            span = span / 2;
        }
    }

 

排序方法	平均情况	最好情况	最坏情况	辅助空间	稳定性
冒泡排序	N2	n	N2	1	稳定
选择排序	N2	N2	N2	1	不稳定
插入排序	N2	n	N2	1	稳定
希尔排序	N*logn~n2	N1.3	N2	1	不稳定
堆排序	N*logn	N*logn	N2	1	不稳定
归并排序	N*logn	N*logn	N*logn	N	稳定
快速排序	N*logn	N*logn	N2	1	不稳定