希尔排序

希尔排序是由插入排序更高效版，也称为缩小增量排序，

此算法的平均时间复杂度为：,最坏时间时间复杂度为，最好时间复杂度为：

空间复杂度为：1

稳定性：不稳定

我们设置间隔为4

第一次排序，将在1,5,9,13上的数先进行排序，一次

以此类推：

然后缩小间隔再来排序：

最后间隔一定为1再来排一次

代码实现如下

 public static void main(String[] args) {
        int[] arr = {9,6,11,3,5,12,8,7,10,15,14,4,1,13,2};
        sort(arr);
        print(arr);
    }
    static void sort(int[] arr){
  //      for (int grap = 4; grap >0; grap/=2) {
        for (int grap = arr.length >> 1; grap >0; grap/=2) {
            for (int i = grap; i < arr.length; i++) {
                for (int j = i; j > grap-1; j-=grap) {
                    if (arr[j] < arr[j-grap]){
                        swap(arr,j,j-grap);
                    }
                }
            }
        }
    }
    static void swap(int[] arr,int i,int j){
        int temp=arr[i];
        arr[i]=arr[j];
        arr[j]=temp;
    }
    static void print(int[] arr){
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
    }

代码优化，使用Knuth序列：

static void sort(int[] arr){
        int h=1;
        while (h <= arr.length/3){
            h=h*3+1;
        }
        for (int grap = h; grap >0; grap=(grap-1)/3) {
            for (int i = grap; i < arr.length; i++) {
                for (int j = i; j > grap-1; j-=grap) {
                    if (arr[j] < arr[j-grap]){
                        swap(arr,j,j-grap);
                    }
                }
            }
        }
    }