java 希尔排序

package com.mulun.sorting;

import java.util.Arrays;

/**
 * <h1>希尔排序</h1>
 * <hr/>
 * <p>思路：</p>
 * <p>首先对无序列表进行分组，先宏观调控，控制增量。</p>
 * <p>然后不断调整，最后遍历排序</p>
 *
 * @author mulun
 */
public class ShellSort {
    public static void main(String[] args) {
        test2();
    }

    public static void test1() {
        int[] arr = {8, 9, 1, 7, 2, 3, 5, 4, 6, 0};
        shellSort2(arr);

        System.out.println(Arrays.toString(arr));
    }

    /**
     * 测试8万条数据的速度
     */
    public static void test2() {
        int[] arr = new int[80000];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int) (Math.random() * 800000);
        }

        long start = System.currentTimeMillis();
        shellSort2(arr);
        long end = System.currentTimeMillis();

        System.out.printf("花费时间：%d", (end - start));
        // 交换法：4992
        // 移动法：13
    }

    /**
     * 交换法
     */
    public static void shellSort(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] > arr[j + gap]) {
                        temp = arr[j];
                        arr[j] = arr[j + gap];
                        arr[j + gap] = temp;
                    }
                }
            }
        }
    }

    /**
     * <h2>移位法</h2>
     * <p>最坏时间复杂度：O(n2)</p>
     */
    public static void shellSort2(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];
                // j - gap >= 0  => 表示还能不能继续分组
                // temp < arr[j - gap] => 是否找到了插入位置
                while (j - gap >= 0 && temp < arr[j - gap]) {
                    // 元素移动
                    arr[j] = arr[j - gap];
                    j -= gap;
                }
                // 当while循环退出，表示找到位置
                arr[j] = temp;
            }
        }
    }
}