java基础算法之希尔排序算法

        希尔排序的基本思想是：先将待排序的数组分组成多个待排子序列，然后对各个子序列分别进行排序，待到整个待排序的序列基本有序的时候，最后在对所有的元素进行一次排序。

package com.example.datastructures.sort;

import java.util.Arrays;

/**
 * @author maoyouhua
 * @version jdk21
 *
 *          希尔排序的基本思想是：先将待排序的数组分组成多个待排子序列，
 *          然后对各个子序列分别进行排序，待到整个待排序的序列基本有序的时候，
 *          最后在对所有的元素进行一次排序。
 */
public class ShellSort {

    /**
     *          希尔排序（交换式）
     * @param arr
     */
    private static void shellSortOfExchange(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;
                    }
                }
            }
            System.out.println(Arrays.toString(arr));
        }
    }
    /**
     *          希尔排序（移动式）
     * @param arr
     */
    private static void shellSortOfMove(int[] arr){
        for (int gap = arr.length / 2; gap > 0 ; gap /= 2) {
            for (int i = gap; i < arr.length ; i++) {
                int j = i;
                int temp = arr[i];
                if (arr[j] < arr[j - gap]){
                    while (j - gap >= 0 && temp < arr[j - gap]) {
                        arr[j] = arr[j - gap];
                        j -= gap;
                    }
                    arr[j] = temp;
                }
            }
            System.out.println(Arrays.toString(arr));
        }
    }
    /**
     *      排序效率测试
     *      希尔排序（交换式）花费时间是：3367毫秒
     *      希尔排序（移动式）花费时间是：17毫秒
     */
    private static void efficiencyTest(){
        int capacity = 80000;
        int[] arr = new int[capacity];
        for (int i = 0; i < capacity; i++) {
            arr[i] = (int)(Math.random()  * 100 * capacity);
        }
        int[] arr2 = Arrays.copyOf(arr, arr.length);
        long start = System.currentTimeMillis();
        shellSortOfExchange(arr);
        long end = System.currentTimeMillis();
        System.out.println("希尔排序（交换式）花费时间是：" + (end - start) + "毫秒");
        start = System.currentTimeMillis();
        shellSortOfMove(arr2);
        end = System.currentTimeMillis();
        System.out.println("希尔排序（移动式）花费时间是：" + (end - start) + "毫秒");
    }

    /**
     * [3, 5, 1, 6, 0, 8, 9, 4, 7, 2]
     * [0, 2, 1, 4, 3, 5, 7, 6, 9, 8]
     * [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
     * @param args
     */
    public static void main(String[] args) {
        int[] arr = {8,9,1,7,2,3,5,4,6,0};
        int[] arr2 = Arrays.copyOf(arr, arr.length);
        shellSortOfExchange(arr);
        shellSortOfMove(arr2);
        efficiencyTest();
    }
}