java 插入排序及希尔排序

看一下这两种排序的算法。

1. 插入排序，其大致实现如下：

    /**
     * 插入排序;
     * <pre>
     *     插入排序（英语：Insertion Sort）是一种简单直观的排序算法。
     *     它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，
     *     通常采用in-place排序（即只需用到{\displaystyle O(1)}{\displaystyle O(1)}的额外空间的排序），
     *     因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。
     *
     *     ======
     *     注意:
     *     1. 这里说的“构建有序序列”，并不是创建一个新的数组或者其他容器，
     * 而是把当前数组的前面当作一个有序队列，从0 开始，每次给这个有序序列增加一个元素;
     *     2. 这里的后移是逐步进行的， 判断目标元素，是不是比当前的小，
     * 如果是，就把当前的元素后移; 然后当前的元素变成了arr[i-1],继续判断和后移;
     * </pre>
     *
     * @param array origin
     */
    public static void insertionSort(int[] array) {
        if (SHOW_INFO) {
            System.out.printf("insertionSort: before: %s\t size=%d\n", Arrays.toString(array), array.length);
        }
        for (int i = 1; i < array.length; ++i) {
            int val = array[i];
            int pos = i;
            // search the target position to insert the waiting value;
            for (int j = i - 1; j >= 0; --j) {
                // compare val with array[j] to found the insert position
                if (val < array[j]) {
                    array[j + 1] = array[j];
                    pos = j;
                }
            }
            if (pos != i) {
                array[pos] = val;
            }
            if (SHOW_DETAIL) {
                System.out.printf("each sort in insertionSort: NO.[%d] -> %s | val =%d\n", i, Arrays.toString(array), val);
            }
        }
        if (SHOW_INFO) {
            System.out.printf("insertionSort: after: %s\t size=%d\n", Arrays.toString(array), array.length);
        }
    }

上面的注释写的比较清楚了。这里的插入，是一种很抽象的思考。把一个数组当成两个数组来看，前面的部分当成已经排好序的数组，后面的当成未排序的数组。然后是从前往后的遍历，每次的遍历都会让前面的有序部分长度+1，让无序的部分-1 ， 然后注意这里的一个实现细节就是，它并不是先遍历一次找到这次应该插入的位置，然后进行移位和插入，而是在遍历中去比较和移位，这样可以省去一次查找插入位置的遍历。

2. 然后看一下希尔排序：

    /**
     * 希尔排序.
     * 首先是分组，然后在每组中间使用插入插入排序的方式进行排序.
     * @param array which prepared to sort.
     */
    public static void shellSort(int[] array) {
        if (SHOW_INFO) {
            System.out.printf("shell: before: %s\t size=%d\n", Arrays.toString(array), array.length);
        }
        for (int gap = array.length / 2; gap > 0; gap /= 2) {
            for (int i = gap; i < array.length; ++i) {
                int pos = i;
                int val = array[i];
                for (int j = i; j - gap >= 0; j -= gap) {
                    // System.out.println();
                    if (val < array[j - gap]) {
                        pos = j - gap; // change target pos
                        array[j] = array[j - gap];
                    }
                }
                if (pos != i) {
                    array[pos] = val;
                }
                if (SHOW_DETAIL) {
                    System.out.printf("shell: in sort:[j=%d] %s\t size=%d\n", i - gap, Arrays.toString(array), array.length);
                }
                //---
            }
        }
        if (SHOW_INFO) {
            System.out.printf("shell: after: %s\t size=%d\n", Arrays.toString(array), array.length);
        }
    }

希尔排序的思想其实很容易理解，它是通过分组的方式，先分成多个组，然后慢慢合成为一个组。在每个组里面进行插入排序，最后合成为一个组的时候，再进行最后一次的插入排序。这么做是为了，在最后一次的插入排序时，移位的操作能减少。每组中的插入排序实现跟直接插入排序是一致，只是这里的步长不一定是1，可能会大于1；也意味着，你要把这种带有间隔的逻辑上的数组当成一个待排序的数组，然后对这个数组进行排序。