交换法：

    1.     //希尔排序 --> 交换法
    2.     public static void shellSort(int[] arr) {
    3.         int temp;
    5.         //增量：gap，并逐步缩小增量
    6.         for (int gap = arr.length / 2; gap > 0; gap /= 2) {
    7.             for (int i = gap; i < arr.length; i++) {
    8.                 //遍历各组中所有的元素（共gap组，每组有arr.length / gap个元素），步长gap
    9.                 for (int j = i - gap; j >= 0; j -= gap) {
    10.                     //如果当前元素大于加上步长后的那个元素，说明需要交换
    11.                     if (arr[j] > arr[j + gap]) {
    12.                         temp = arr[j];
    13.                         arr[j] = arr[j + gap];
    14.                         arr[j + gap] = temp;
    15.                     }
    16.                 }
    17.             }
    18.         }
    20. //        System.out.println("排序后：");
    21. //        System.out.println(Arrays.toString(arr));
    22.     }

    位移法：

    2.     //希尔排序 --> 移位法
    3.     public static void shellSort2(int[] arr) {
    4.         int temp;
    5.         int j;
    7.         //增量：gap，并逐步缩小增量
    8.         for (int gap = arr.length / 2; gap > 0; gap /= 2) {
    9.             //从此gap个元素，逐个对其所在的组进行直接插入排序
    10.             for (int i = gap; i < arr.length; i++) {
    11.                 j = i;
    12.                 temp = arr[j];
    13.                 if (arr[j] < arr[j - gap]){
    14.                     while (j - gap >= 0 && temp < arr[j - gap]){
    15.                         arr[j] = arr[j - gap];
    16.                         j -= gap;
    17.                     }
    18.                     //当退出while后，说明给temp找到插入的位置了
    19.                     arr[j] = temp;
    20.                 }
    21.             }
    22.         }
    23. //        System.out.println("排序后：");
    24. //        System.out.println(Arrays.toString(arr));
    25.     }