希尔排序

Java实现希尔排序

希尔排序即插入排序的优化版

插入排序当遇到大规模数组时，因它只能交换相邻的元素，所以排序速度很慢。

希尔排序则使用插入排序的方式对间隔h的元素进行排序交换，即对下标分别为i, i+h, i+h+h ...的序列进行排序，通过不断地减小h，最后令h = 1，就可以实现整个数组的有序。通常h取值为（1，4，13…）即$h=h\ast 3+1$

希尔排序的运行时间达不到平方级别，使用递增序列的希尔排序所有的比较次数不会超过N的若干倍乘以递增序列的长度（即while(h>=1)循环的次数乘上N的若干倍）。

import java.util.Arrays;
import java.util.Random;

/**
 * @author Nino
 */
public class ShellSort<E extends Comparable<E>> {

    /**
     * 排序主体
     * @param arr
     */
    public void sort(E[] arr) {

        int N = arr.length;
        // 步长h的初始值为1
        int h = 1;

        // h要取最大步长
        while (h < N / 3) {
            h = h * 3 + 1;
        }

        // h为正数的情况才需要排序嘛~
        while (h >= 1) {
            // 对索引在[h, N)的数组以间隔h向前面的元素进行插入排序
            for (int i = h; i < N; i++) {
                // 元素交换的条件：
                // 1、当前位置不能小于h
                // 2、后面的数字比前面的数字小
                for (int j = i; j >= h && less(arr[j], arr[j - h]); j -= h) {
                    swap(arr, j, j-h);
                }
            }
            // 更新步长h
            h = (h - 1) / 3;
        }
    }

    /**
     * 给定a，b两元素大小的比较方式
     * @param a
     * @param b
     * @return
     */
    private boolean less(E a, E b) {
        return a.compareTo(b) < 0;
    }

	 /**
     * 交换数组nums中i，j索引的值
     * @param nums
     * @param i
     * @param j
     */
    private void swap(E[] nums, int i, int j) {
        E temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }

    /**
     * 测试用例
     * @param args
     */
    public static void main(String[] args) {
        Random random = new Random();
        Integer[] arr = new Integer[10];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = Integer.valueOf(random.nextInt(20));
        }
        System.out.println(Arrays.asList(arr).toString());
        new ShellSort<Integer>().sort(arr);
        System.out.println(Arrays.asList(arr).toString());
    }
}

用例输出：

[8, 2, 13, 10, 14, 1, 4, 10, 19, 8]
[1, 2, 4, 8, 8, 10, 10, 13, 14, 19]