希尔排序-交换式-移动式

学习希尔排序后仔细想了想，发现它就是一种变种的冒泡排序和变种的插入排序。
希尔排序的基本思想
希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。

示例数组
int[] arr={8,9,1,7,2,3,5,4,6,0}

1. 初始增量是gap=arr.length/2，意味着整个数组被分成5组即[8,3],[9,5],[1,4],[7,6],[2,0]
   
   对这5个组分别进行插入排序，因为只有两个元素所以直接交换即可
   3,5,1,6,0,8,9,4,7,2
2. 缩小增量gap=gap/2; gap=2 数组被分为两组[3,1,0,9,7],[5,6,8,4,2]
   再分别对[3,1,0,9,7],[5,6,8,4,2]两个组进行排序,得到如下
   0,2,1,4,3,5,7,6,9,8
   即将每组排序好的元素按增量的顺序添加到数组相应的位置即
   [3,1,0,9,7]插入排序好的是[0,1,3,7,9]
[5,6,4,8,2] 插入排序好的是[2,4,5,6,8]
   
3. 缩小增量gap=gap/2; gap=1 数组被分为一组[0,2,1,4,3,5,7,6,9,8],对剩下的进行插入排序，得到
   [0,1,2,3,4,5,6,7,8,9]
   其中的直接插入算法就是核心的算法。核心的算法就是冒泡和插入，不过是带增量的排序
   因此算法如下

//交换式  （冒泡）
 public static void shellSort(int[] arr){
        int gap= arr.length/2;
        while(gap!=0){
            for(int i=gap;i<arr.length;i++){
                for(int j=i-gap;j>=0;j-=gap){
                    if(arr[j]>arr[j+gap]){
                        int temp = arr[j];
                        arr[j]=arr[j+gap];
                        arr[j+gap]=temp;
                    }
                }
            }
            gap/=2;
        }
    }
    //移动式 （插入）
    public static void shellSort1(int[] arr){
        int gap= arr.length/2;
        while(gap!=0){
            for(int i=gap;i<arr.length;i++){
                int j=i;
                int temp=arr[j];
                while(j-gap>=0&&temp<arr[j-gap]){
                    arr[j]=arr[j-gap];
                    j-=gap;
                }

                //找到合适的时候就替换进屋
                if(j!=i){
                    arr[j]= temp;
                }
            }
            gap/=2;
        }
        System.out.println(Arrays.toString(arr));
    }