希尔排序

希尔排序是基于插入排序的以下性质而提出改进方法的：

1. 插入排序在对几乎已经排好序的数据操作时，效率高，即可以达到线性排序的效率。
2. 但插入排序一般来说是低效的，因为插入排序每次只能将数据移动一位，因此插入排序只能将元素一点一点地从数组的一端移动到另一端。
3. 希尔排序没有减少元素的比较次数，但减少了元素的移动次数。

public class Shell extends Sort {
    /**
     * 将a[]升序排列
     * @param a
     * @return
     */
    public static Comparable[] shell(Comparable[] a) {
        int N = a.length;
        int h = 1;
        // h以3为底数：h={1,4,13,40...}
        while (h < N / 3) {
            h = 3 * h + 1;
        }
        while (h >= 1) {
            for (int i = h; i < N; i++) {
                // 从j-h=0号开始，以增幅h开始排序。分组排序
                for (int j = i; j >= h && less(a[j], a[j - h]); j -= h) {
                    exch(a, j, j - h);
                }
            }
            // h值为希尔排序增量，最后值必须为1,h={...40,13,4,1}
            h = h / 3;
        }
        return a;
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        String[] strings = { "S", "H", "E", "L", "Z", "L", "S", "O", "R", "T",
                "A", "Q", "B" };
        String[] strings2 = (String[]) shell(strings);
        for (String string : strings2) {
            System.out.print(string + "   ");
        }
    }

}

父类Sort：

public  class Sort {
    protected static boolean less(Comparable a, Comparable b) {
        return a.compareTo(b) < 0;
    }

    protected static void exch(Comparable[] a, int i, int j) {
        Comparable tComparable = a[i];
        a[i] = a[j];
        a[j] = tComparable;
    }

    public  void show(Comparable[] a) {
        for (Comparable comparable : a) {
            StdOut.print(comparable + "  ");
        }
        StdOut.println();
    }

    protected static boolean isSorted(Comparable[] a) {
        for (int i = 1; i < a.length; i++) {
            if (less(a[i], a[i - 1])) {
                return false;
            }
        }
        return true;
    }
}