希尔排序

　直接插入排序在在本身数量比较少的时候情况下效率很高，如果待排数的数量很多，其效率不是很理想。

按gap进行分组得到一个小组(a[i],a[i+gap])然后对小组进行排序

　　回想一下直接插入排序过程，排序过程中，我们可以设置一条线，左边是排好序的，右边则是一个一个等待排序，

如果最小的那个值在最右边，那么排这个最小值的时候，需要将所有元素向右边移动一位。

　　是否能够减少这样的移位呢？

　　我们不希望它是一步一步的移动，而是大步大步的移动。希尔排序就被发明出来了，它也是当时打破效率

O（n2）的算法之一。希尔排序算法通过设置一个间隔，对同样间隔的数的集合进行插入排序，此数集合中的元素

移位的长度是以间隔的长度为准，这样就实现了大步位移。但是最后需要对元素集合进行一次直接插入排序，所以

最后的间隔一定是1。

下面以数列{80,30,60,40,20,10,50,70}为例，演示它的希尔排序过程。

第1趟：(gap=4)

当gap=4时,意味着将数列分为4个组： {80,20},{30,10},{60,50},{40,70}。 对应数列： {80,30,60,40,20,10,50,70}
对这4个组分别进行排序，排序结果： {20,80},{10,30},{50,60},{40,70}。 对应数列： {20,10,50,40,80,30,60,70}

第2趟：(gap=2)

当gap=2时,意味着将数列分为2个组：{20,50,80,60}, {10,40,30,70}。 对应数列： {20,10,50,40,80,30,60,70}
注意：{20,50,80,60}实际上有两个有序的数列{20,80}和{50,60}组成。
          {10,40,30,70}实际上有两个有序的数列{10,30}和{40,70}组成。
对这2个组分别进行排序，排序结果：{20,50,60,80}, {10,30,40,70}。 对应数列： {20,10,50,30,60,40,80,70}

 

第3趟：(gap=1)

当gap=1时,意味着将数列分为1个组：{20,10,50,30,60,40,80,70}
注意：{20,10,50,30,60,40,80,70}实际上有两个有序的数列{20,50,60,80}和{10,30,40,70}组成。
对这1个组分别进行排序，排序结果：{10,20,30,40,50,60,70,80}

/**
 * 对每个分组进行插入排序
 * gap是增量，gap是组数，每个组内进行插入排序（此小组不是直接相连的那几个元素，而是相隔gap的元素），然后再比较交换a[i]和a[i+gap]
 * 如对{80,30,60,40,20,10,50,70}进行排序
 * 当gap=4时,意味着将数列分为4个组： {80,20},{30,10},{60,50},{40,70},每个组分别进行排序然后合并得到{20,10,50,40,80,30,60,70}
 * 当gap=2时,意味着将数列分为2个组：{20,50,80,60}, {10,40,30,70}每个组分别进行排序然后合并得到{20,10,50,30,60,40,80,70}
 */
import java.util.Arrays;
public class ShellSort {
    public static void main(String []args){
        int []arr ={80,30,60,40,20,10,50,70};
        ShellSort shellSort = new ShellSort();
        shellSort.sort(arr);
        System.out.println(Arrays.toString(arr));
    }

    /**
     * 希尔排序 针对有序序列在插入时采用交换法
     * @param arr
     */
    public void sort(int []arr){
        //外层循环是控制gap的，里面的两层循环是insert sort
        //增量gap，并逐步缩小增量
        for(int gap=arr.length/2;gap>0;gap/=2){
            //从第gap个元素，逐个对其所在组进行直接插入排序操作
            for(int i=gap;i<arr.length;i++){
                int j = i;
                while(j-gap>=0 && arr[j]<arr[j-gap]){
                    //插入排序采用交换法
                    swap(arr,j,j-gap);
                    j-=gap;
                }
            }
            System.out.println(String.valueOf(gap) + " :" + Arrays.toString(arr));
        }
    }

    /**
     * 交换数组元素
     * @param arr
     * @param a
     * @param b
     */
    public static void swap(int []arr,int a,int b){
        arr[a] = arr[a]+arr[b];
        arr[b] = arr[a]-arr[b];
        arr[a] = arr[a]-arr[b];
    }

    //    另外一种方法，与上面不同之处就是插入排序中采用的是移动法
//    /**
//     * 希尔排序 针对有序序列在插入时采用移动法。
//     * @param arr
//     */
//    public static void sort1(int []arr){
//        //增量gap，并逐步缩小增量
//        for(int gap=arr.length/2;gap>0;gap/=2){
//            //从第gap个元素，逐个对其所在组进行直接插入排序操作
//            for(int i=gap;i<arr.length;i++){
//                int j = i;
//                int temp = arr[j];
//                if(arr[j]<arr[j-gap]){
//                    while(j-gap>=0 && temp<arr[j-gap]){
//                        //移动法
//                        arr[j] = arr[j-gap];
//                        j-=gap;
//                    }
//                    arr[j] = temp;
//                }
//            }
//        }
//    }
}

https://www.cnblogs.com/skywang12345/p/3597597.html