希尔排序——交换版和移动版

简单介绍：
希尔排序(Shell's Sort)是插入排序的一种又称“缩小增量排序”（Diminishing Increment Sort），是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。该方法因 D.L.Shell 于 1959年提出而得名。希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至 1 时，整个文件恰被分成一组，算法便终止。

图解：

直接插入排序：

public class InsertSort {
    public static void main(String[] args) {
        int[] arr = {2, 1, 4, 7, 5, 3, 6};
        insertSort(arr);
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "\t");
        }
    }

    public static void insertSort(int[] arr) {
        int count = 0;
        // 默认一个数是排好序的，所以从i = 1开始
        for (int i = 1; i < arr.length; i++) {
            // 将当前需要插入的数保存起来
            int temp = arr[i];
            // j是i前面数的下标
            int j = i - 1;
            while (j >= 0 && arr[j] > temp) {
                count++;
                arr[j + 1] = arr[j];
                // 继续向前搜索
                j--;
            }
            // 出了while循环，此时j + 1正是插入的位置
            arr[j + 1] = temp;
        }
        System.out.println(count);
    }
}

希尔排序交换版

public class ShellSortExchange {
    public static void main(String[] args) {
        int[] arr = {2, 9, 8, 7, 6, 4, 5, 1, 3, 0};
        shellSort(arr);
    }

    public static void shellSort(int[] arr) {
        int count = 0;
        // 分组，对每一组进行局部排序
        for (int gap = arr.length / 2; gap >= 1; gap /= 2) {
            // 分几组，就从第一组的最后一个元素开始遍历
            for (int i = gap; i < arr.length; i++) {
                int j = i - gap;
                while (j >= 0 && arr[j] > arr[j + gap]) {
                    int temp = arr[j];
                    arr[j] = arr[j + gap];
                    arr[j + gap] = temp;
                    j -= gap;
                }
            }
            System.out.println("第" + (++count) + "次循环后：" + Arrays.toString(arr));
        }
    }
}

希尔排序移动版

package com.lzp.util.sort;

import java.util.Arrays;

/**
 * Created by Administrator on 2021/3/19.
 * 希尔排序
 * 移动版
 */
public class ShellSortMove {
    public static void main(String[] args) {
        int[] arr = {4, 2, 1, 5, 3, 8, 7, 6};
        shellSort(arr);
        System.out.println(Arrays.toString(arr));
    }

    public static void shellSort(int[] arr) {
        // 先确定增量，而且增量每次减半，直到减到0就全部排好序了
        for (int gap = arr.length / 2; gap >= 1; gap /= 2) {
            // 找每次分组后的第一组中的最后一个元素，就是针对每一组先进行排序（局部排序）
            for (int i = gap; i < arr.length; i++) {
                // 遍历该组，让该组的最后一个元素跟其所在组的前面其他元素进行依次比较
                int j = i - gap;
                // 先将该组的最后一个元素保存到temp变量中，因为这是移动元素，而不是交换元素
                int temp = arr[i];
                while (j >= 0 && arr[j] > temp) {
                    // 如果前面的比后面的大，就覆盖后面的
                    arr[j + gap] = arr[j];
                    // 指针继续向前移动gap
                    j -= gap;
                }
                // 程序运行到这里，while循环结束，表示此时指针指向的后一个位置才是temp最终应该处于的位置，所以指针j要向后移动gap
                arr[j + gap] = temp;
            }
        }
    }
}

测试80000数据量：

直接插入排序消耗的时间

希尔排序所消耗的时间

 由此可以看出希尔排序比直接插入排序的效率高了很多