数据结构与算法单排日记-2020/3/22-排序算法&希尔排序

希尔排序法基本思想

希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止

过程代码：

import java.util.Arrays;

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

    public static void shellSort(int[] arr) {
        /**
         * 第1次排序【8,3】【9,5】【1,4】【7,6】【2,0】
         * [3, 5, 1, 6, 0, 8, 9, 4, 7, 2]
         * */
        int gap = arr.length / 2;//类似二分法
        int index = 0;//用于盛放插入的位置
        int temp = 0;//用于盛放待插入的数字
        //将数组分为10/2=5组
        //使用简单插入法对每组中数据进行排序,所以从每组第二个数据开始，下面这个循环从gap开始，就是可以跳过每组的第一个数
        for (int j = gap; j < arr.length; j++) {
            temp = arr[j];//盛放待插入的数字
            //而下面循环的目的是从j的同组的前一个数开始,其位置为j-gap,每次都向前跳gap个数,就可以把同组的数选出来了,所以index-=gap;
            index = j - gap;
            while (index >= 0 && temp < arr[index]) {//简单插入法
                arr[index + gap] = arr[index];
                index -= gap;
            }
            //循环停止后，将arr[j]插到index后面的位置，即index+gap
            arr[index + gap] = temp;
        }
        System.out.println("第1次排序："+Arrays.toString(arr));
        
        
        /**
         * 第2次排序【3,1,0,9,7】【5,6,8,4,2】
         * [0 2 1 4 3 5 7 6 9 8]
         * */
        gap = arr.length / 2 / 2;//类似二分法
        index = 0;
        temp = 0;
        for (int j = gap; j < arr.length; j++) {
            temp = arr[j];//盛放待插入的数字
            index = j - gap;
            while (index >= 0 && temp < arr[index]) {//简单插入法
                arr[index + gap] = arr[index];
                index -= gap;
            }
            arr[index + gap] = temp;
        }
        System.out.println("第2次排序："+Arrays.toString(arr));

        /**
         * 第3次排序【0 2 1 4 3 5 7 6 9 8】
         *[0 1 2 3 4 5 6 7 8 9]
         * */
        gap = arr.length / 2 / 2 /2;//类似二分法
        index = 0;
        temp = 0;
        for (int j = gap; j < arr.length; j++) {
            temp = arr[j];
            index = j - gap;
            while (index >= 0 && temp < arr[index]) {//简单插入法
                arr[index + gap] = arr[index];
                index -= gap;
            }
            arr[index + gap] = temp;
        }
        System.out.println("第3次排序："+Arrays.toString(arr));

    }
}

循环代码：

import java.util.Arrays;

public class SellSort02 {
    public static void main(String[] args) {
        int[] arr = {8, 9, 1, 7, 2, 3, 5, 4, 6, 0};
        shellSort(arr);
        System.out.println(Arrays.toString(arr));
    }

    public static void shellSort(int[] arr) {

        for (int gap = arr.length / 2; gap > 0; gap /= 2) {
            int index = 0;//用于盛放插入的位置
            int temp = 0;//用于盛放待插入的数字
            //将数组分为10/2=5组
            //使用简单插入法对每组中数据进行排序,所以从每组第二个数据开始，下面这个循环从gap开始，就是可以跳过每组的第一个数
            for (int j = gap; j < arr.length; j++) {
                temp = arr[j];//盛放待插入的数字
                //而下面循环的目的是从j的同组的前一个数开始,其位置为j-gap,每次都向前跳gap个数,就可以把同组的数选出来了,所以index-=gap;
                index = j - gap;
                while (index >= 0 && temp < arr[index]) {//简单插入法
                    arr[index + gap] = arr[index];
                    index -= gap;
                }
                //循环停止后，将arr[j]插到index后面的位置，即index+gap
                arr[index + gap] = temp;
            }
        }
    }
}

测试

import java.util.Arrays;

public class SellSort02 {
    public static void main(String[] args) {
        int[] arr = new int[8000];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int) (Math.random() * 80000);
        }
        long startTime = System.currentTimeMillis(); //获取开始时间doSomething(); //测试的代码段
        shellSort(arr);
        long endTime = System.currentTimeMillis(); //获取结束时间
        System.out.println("程序运行时间：" + (endTime - startTime) + "ms"); //输出程序运行时间
    }

    public static void shellSort(int[] arr) {

        for (int gap = arr.length / 2; gap > 0; gap /= 2) {
            int index = 0;//用于盛放插入的位置
            int temp = 0;//用于盛放待插入的数字
            //将数组分为10/2=5组
            //使用简单插入法对每组中数据进行排序,所以从每组第二个数据开始，下面这个循环从gap开始，就是可以跳过每组的第一个数
            for (int j = gap; j < arr.length; j++) {
                temp = arr[j];//盛放待插入的数字
                //而下面循环的目的是从j的同组的前一个数开始,其位置为j-gap,每次都向前跳gap个数,就可以把同组的数选出来了,所以index-=gap;
                index = j - gap;
                while (index >= 0 && temp < arr[index]) {//简单插入法
                    arr[index + gap] = arr[index];
                    index -= gap;
                }
                //循环停止后，将arr[j]插到index后面的位置，即index+gap
                arr[index + gap] = temp;
            }
        }
    }
}