X16数据结构部分06

交换式希尔排序算法

package du;

/**
 * @author 404小恐龙
 * @version 1.8
 * @date 2021/10/4 11:53
 */
public class m05 {
   
    /*
    希尔排序实现思路（交换式实现）
        假设有10个无序数

        则初始增量 gap = 10 / 2 = 5
        把这个集合分成5组
        索引为0的元素和索引为5的元素分成一组
        索引为1的元素和索引为6的元素分成一组
        ... ...
        每组的步长一样
        两两一组比较大小
        两个中的比较小的数放在前面

        完成后再重新定义增量
        gap = 5 / 2 = 2，注意需要按位运算标准
        然后分成两组，每组5个数，看起来像奇数和偶数序列
        然后两组组内元素分别比较大小

        完成后再重新定义增量
        gap = 2 / 2 = 1
        这时候对整个数组进行插入排序

        这个时候开起来更加有序了
        这种操作可以理解成插入排序之前的预处理
        是为了让插入排序时，内容更加有序
        然后插入排序效率更高
     */
    public static void main(String[] args) {
   
        int[] array = new int[]{
   8, 9, 1, 7, 2, 3, 5, 4, 6, 0};
        sort(array);
    }

    /**
     * 交换式，逐步推导法实现希尔排序
     *
     * @param arr 需要排序的数组
     */
    private static void sort(int[] arr) {
   
        for (int gap = arr.length / 2; gap > 0; gap /= 2) {
   
            /*
            程序第1次运行到此处
            假设数组长度为10
            则增量初始值为5
            也就是分成了5组
            循环一次比较一组
             */
            for (int i = gap; i < arr.length; i++) {
   
            /*
            第2层for循环的意思是
            分组依据是步长为5
            第1次循环比较
            索引为0的元素和索引为5的元素
            第2次循环比较
            索引为1的元素和索引为6的元素
             */
                for (int j = i - gap; j >= 0; j -= gap) {
   
                /*
                程序运行到此处
                说明需要比较2个数的大小
                 */
                    if (arr[j] > arr[j + gap]) {
   
                        int tmp = arr[j];
                        arr[j] = arr[j + gap];
                        arr[j + gap] = tmp;
                    }
                }
            }
        /*
        程序第一次运行到此处
        说明希尔排序第一轮已经结束
        得到排序结果
        然后再次执行最外层for循环
        得到第2次希尔排序的结果
         */
        }
        for (int i = 0; i < arr.length; i++) {
   
            System.out.print(arr[i] + " "); // 0 1 2 3 4 5 6 7 8 9
        }
    }
}

移动式希尔排序算法

	/**
     * 移位法希尔排序
     * @param array 需要排序的数组
     */
    public static int[] shellSort2(int[] array){
   
        if (array.length <= 1){
   
            return array;
        }
        int[] cloneArray = array;
        /*
        移位法希尔排序是交换式希尔排序的优化
        解决了交换法希尔排序处理大数据量
        时间开销大的缺陷
         */
        for (int gap = cloneArray.length / 2; gap > 0 ; gap /= 2) {
   
            /*
            程序运行到此处
            此时直接对所在组进行直接插入排序
             */
            for (int i = gap; i < cloneArray.length; i++) {
   
                int j = i;
                int tmp = cloneArray[j];
                while (j - gap >= 0 && tmp < cloneArray[j - gap]){
   
                    /*
                    程序运行到此处
                    说明后面比前面的小
                    此时需要移动位置
                    指针前移
                     */
                    cloneArray[j] = cloneArray[j - gap];
                    j -= gap;