算法

要点：利用了插入排序对于数据有序性的依赖，先对部分元素位置进行调整，再执行插入排序。整体上降低了插入排序的时间复杂度，是插入排序的改进版本。当然，人品好的，还是用插入吧。

import java.util.Random;

public class ShellSort<T extends Comparable> {

    public void sort(T[] arr) {
        // 数据间距
        int space = arr.length / 2;
        while (space >= 1) {
            // 当前元素下标
            int index = 0;
            // 每组首元素的下标
            int move = 0;
            // 按照间距能分出的数据组数
            double capcity = Math.floor(arr.length / Math.floor(arr.length / space));
            printArr(arr);
            while (move < capcity) {
                // 下一个元素下标
                int next = index + space;
                // 对比交换
                if (arr[index].compareTo(arr[next]) > 0) {
                    printIndex(index, next);
                    T temp = arr[next];
                    arr[next] = arr[index];
                    arr[index] = temp;
                }
                // 当前坐标移动
                index = next;
                // 一组元素执行完进入下一组，首元素后移一位，当前坐标移至首元素位置
                if (index + space >= arr.length) {
                    index = ++move;
                }
            }
            // 当拆分的组数只有1组时，执行插入排序
            if (capcity == 1) {
                for (int i = 1; i < arr.length; i++) {
                    if (arr[i].compareTo(arr[i - 1]) < 0) {
                        printArr(arr);
                        T temp = arr[i];
                        for (int j = i; j > 0; j--) {
                            arr[j] = arr[j - 1];
                            if (arr[j - 1].compareTo(temp) <= 0) {
                                arr[j] = temp;
                                break;
                            }
                        }
                        printArr(arr);
                    }
                }
            }
            // 间距减半
            space /= 2;
        }
    }

    private void printIndex(int index, int next) {
        String[] stringArr = new String[]{"|", "|", "|", "|", "|", "|", "|", "|", "|", "|", "|"};
        stringArr[index] = "*";
        stringArr[next] = "*";
        for (String s : stringArr) {
            System.out.print(s);
        }
        System.out.println();
    }

    private void printArr(T[] arr) {
        for (T n : arr) {
            System.out.print(n);
        }
        System.out.println();
    }

    public static void main(String[] args) {
        int n = 11;
        Integer[] arr = new Integer[n];
        for (int i = 0; i < n; i++) {
            arr[i] = new Random().nextInt(10);
        }
        ShellSort ss = new ShellSort();
        ss.sort(arr);
    }

    /**
     * 60372574404 => 原始数据, 按照间隔``arr.length/2``拆分
     * *||||*||||| => 交换
     * |||||*||||* => 交换 => 发生了顺序改变，因此不稳定
     * |||*||||*|| => 交换
     * ||||*||||*| => 交换
     * 50340474726 => 间隔减半，由5变2
     * *|*|||||||| => 交换
     * ||*|*|||||| => 交换
     * ||||||||*|* => 交换
     * |||||||*|*| => 交换
     * 30045472647 => 间隔减半，由2变1
     * **||||||||| => 交换
     * |**|||||||| => 交换
     * ||||**||||| => 交换
     * ||||||**||| => 交换
     * |||||||**|| => 交换
     * ||||||||**| => 交换
     * 00344526477 => 开始执行插入排序，发现2
     *       ^
     * 00234456477 => 将2插入到有序位置
     * 00234456477 => 发现4
     *         ^
     * 00234445677 => 将4插入到有序位置
     *
     * 序列按排序方向的有序性越高，插入排序越快
     * 希尔排序是尽可能先排好序，再执行插入，是插入排序的改进版
     * 插入拼人品，希尔求稳定
     * => 遍历次数：与数据分布有关
     * => 时间复杂度：最小为O(nlogn)
     * => 稳定性：不稳定
     */

}