希尔排序

希尔排序是插入排序的改良版，可以解决移位次数较多带来的效率低下问题。
要点：对序列（长度为length）进行多次分组，每次分组后都对不同组的数据进行插入排序，分组数量由步长决定，而第一次分组的步长由length / 2取整所得，下一次分组的步长由上次步长 / 2取整所得，当步长为0时，排序完成。比如说length=10，10/2=5，那么第一次分组的步长为5，所以分为5组，对每一组进行排序；5/2=2，所以第二次分组的步长为2，分成了2组，对每一组进行排序；2/2=1，步长为1，分成一组排序；1/2=0，步长为0，排序完成。

package DataStructure;

import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;

public class ShellSort {
    public static void main(String[] args) {
//        int[] arr = {55, 48, 6, 24, 88, 1230, 558};
//        sort2(arr);
//        System.out.println(Arrays.toString(arr));
        int[] arr = new int[80000];
        for (int i = 0; i < 80000; i++) {
            arr[i] = (int) (Math.random() * 800000); // 即[0,1) * 800000
        }
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        
//        System.out.println("排序前：" + sdf.format(new Date())); // 排序前：2020-08-06 21:08:06
//        sort(arr);
//        System.out.println("排序后：" + sdf.format(new Date())); // 排序后：2020-08-06 21:08:16

        System.out.println("排序前：" + sdf.format(new Date())); // 排序前：2020-08-06 21:21:34
        sort2(arr);
        System.out.println("排序后：" + sdf.format(new Date())); // 排序后：2020-08-06 21:21:34
    }

    // 希尔排序（交换法，每次找到前一个数字比当前数字大时，就交换）
    public static void sort(int[] arr) {
        int temp = 0;
        for (int gap = arr.length / 2; gap > 0; gap /= 2) {
            // 从索引为步长处开始迭代
            for (int i = gap; i < arr.length; i++) {
                // 迭代同组数据，每次对比上一个相距一个步长的数字，如果小于它，则交换（即对不同组进行插入排序）
                for (int j = i - gap; j >= 0; j -= gap) {
                    if (arr[j + gap] < arr[j]) {
                        temp = arr[j + gap];
                        arr[j + gap] = arr[j];
                        arr[j] = temp;
                    }
                }
            }
        }
    }

    // 移位法，找到前一个数字比当前数字大，不马上交换，只将前一个数字后移一位，直至当前数字不比前面的数字小
    // 或者前面已经没有数字，再赋值，这样可以极大提高效率。
    public static void sort2(int[] arr) {
        int insertValue = 0;
        for (int gap = arr.length / 2; gap > 0; gap /= 2) {
            // 从索引为步长处开始迭代
            for (int i = gap; i < arr.length; i++) {
                insertValue = arr[i];
                // 迭代同组数据，每次对比上一个相距一个步长的数字，如果小于它，则将上一个数字后移一位。
                int j = i - gap;
                while (j >= 0 && insertValue < arr[j]) {
                    arr[j + gap] = arr[j];
                    j -= gap;
                }
                if (j != i - gap) {
                    arr[j + gap] = insertValue;
                }
            }
        }
    }
}