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;
                }
                /*
                程序运行到此处
                说明已经找到了合适的位置
                直接插入即可
                 */
                cloneArray[j] = tmp;
            }
        }
        return cloneArray;
    }

附赠3大排序算法

	/**
     * 冒泡排序算法
     * @param array 需要排序的数组
     * @return 排序好的数组
     */
    public static int[] bubbleSort(int[] array){
        if (array.length <= 1){
            return array;
        }
        int[] cloneArray = array;
        for (int i = 0; i < cloneArray.length; i++) {
            for (int j = 0; j < cloneArray.length - i - 1; j++) {
                if (cloneArray[j] > cloneArray[j+1]){
                    /*
                    程序运行到此处
                    说明前面的元素大于后面的元素
                    需要交换位置
                     */
                    int tmp = cloneArray[j];
                    cloneArray[j] = cloneArray[j + 1];
                    cloneArray[j + 1] = tmp;
                }
            }
        }
        return cloneArray;
    }

    /**
     * 选择排序算法实现
     * @param array 需要排序的数组
     * @return 排序好的数组
     */
    public static int[] selectSort(int[] array){
        if (array.length <= 1){
            return array;
        }
        int[] cloneArray = array;

        for (int i = 0; i < array.length - 1; i++) {
            int minNum = i;
            /*
            程序运行到此处
            说明进行到了第一轮扫描
            这里的i + 1表示
            从当前头元素后面的元素开始扫描
             */
            for (int j = i + 1; j < array.length; j++) {
                if (cloneArray[minNum] > array[j]){
                    /*
                    程序运行到此处
                    说明找到了比当前头元素
                    更小的数
                    需要记录
                    用于后面交换位置
                     */
                    minNum = j;
                }
            }
            /*
            程序第1次运行到此处
            说明第1伦扫描完毕
            需要判断是否需要交换位置
             */
            if (minNum != i){
                int tmp = cloneArray[i];
                cloneArray[i] = cloneArray[minNum];
                cloneArray[minNum] = tmp;
            }
        }
        return cloneArray;
    }

    /**
     * 插入排序算法实现
     * @param array 需要排序的数组
     * @return 排序好的数组
     */
    public static int[] insertSort(int[] array) {
        int len;
        if(array == null || (len = array.length) == 0 || len == 1) {
            return array;
        }
        int current;
        int[] cloneArray = array;
        for (int i = 0; i < len - 1; i++) {
            /*
            程序第1次运行到此处
            当前扫描指针指向的元素是第2个元素
            当前头指针指向的是第1个元素
             */
            current = cloneArray[i + 1];
            int preIdx = i;
            while (preIdx >= 0 && current < cloneArray[preIdx]) {
                /*
                程序运行到此处
                说明当前扫描元素 < 比较元素
                此时交换位置
                并将索引指针前移
                画张图就清晰多了
                 */
                cloneArray[preIdx + 1] = cloneArray[preIdx];
                preIdx--;
            }
            /*
            程序运行到此处
            说明当前扫描元素 > 比较元素
            已经找到了该元素适合放置的位置
            直接赋值即可
             */
            cloneArray[preIdx + 1] = current;
        }
        return cloneArray;
    }

快速排序算法实现

package du;

import java.util.Arrays;

/**
 * @author 404小恐龙
 * @version 1.8
 * @date 2021/10/17 11:21
 */
public class m06 {
    /*
    快速排序算法思路分析
        顾名思义，快速排序的速度较快
        获取一个基准点
        比基准点小的放在左边
        大的放在右边

        有一个很好的图解
        把第一位数字作为基准点
        left指针指向基准点，right指针指向最后一个元素
        先从右开始查找
        比基准点大的就往前移，比基准点小的覆盖掉left指针指向的数据
        直到两点同时指向同一个元素
        此时将原有基准点替换掉该点
        第一轮就进行完了

        然后保括当前基准点的左边部分
        以及初次之外的右边部分
        两者进行同样的操作
        最终会得到有序的数组
     */
    public static void main(String[] args) {
        int[] array = new int[]{3,4,6,7,2,7,2,8,0};
        quickSort(array,0,array.length - 1);
        System.out.println(Arrays.toString(array));
        // [0, 2, 2, 3, 7, 7, 6, 8, 4]
    }

    public static void quickSort(int[] array,int left,int right){
        if (left < right){
            /*
            程序运行到此处
            说明证明条件可以通过
            此时开始位置和结束位置不能重复
            且开始位置必须小于结束位置
             */
            /*
        程序第2次运行到此处
        说明递归已经开始进行
        此时有两个递归程序分别运行这段代码
        所以需要记录
         */
            int benchmark = array[left];
            int low = left;
            int high = right;

            while (low < high){
                while (low < high && benchmark <= array[high]){
                /*
                程序运行到此处
                说明右边的数字比基准数大
                移动指针即可
                 */
                    high--;
                }
            /*
            程序运行到此处
            说明右边的数字比基准数小
            需要覆盖掉前面的位置
             */
                array[low] = array[high];

                while (low < high && benchmark >= array[low]){
                /*
                程序运行到此处
                说明左边的数比基准数小
                移动指针即可
                 */
                    low++;
                }
            /*
            程序运行到此处
            说明左边的数字比基准数大
            需要覆盖掉前面的位置
             */
                array[high] = array[low];
            }
        /*
        程序第1次运行到此处
        说明第一轮排序已经完成
        需要基准数覆盖重合节点
        开始进行分割递归
         */
            array[low] = benchmark;
        /*
        此时拆分成两块进行递归
        小的部分递归和大的部分递归
         */
            quickSort(array,benchmark,low);
            quickSort(array,low + 1,high);
        }
    }
}

归并排序算法实现

package du;

import java.util.Arrays;

/**
 * @author 404小恐龙
 * @version 1.8
 * @date 2021/10/17 21:04
 */
public class m07 {
    /*
    归并排序思路分析
        就是把一个无序的数组分成两部分
        并且两部分都有序
        然后再正常操作进行数组合并

        比如有一个数组，随便举一个例子
        3 5 2 6 7 8 1 2 0 3 2 9
        先提取3，5
        把他们看成两个数组
        排序完成后是3，5
        再把2和[3,5]进行比较
        进行归并排序
        组成[2,3,5]
        然后就是正常操作，我就不举例了

        按照大佬的思路，是分成3个一组
        [6,7,8]按照归并思路排序后，
        再整体和[2,3,5]进行归并排序

        随后再合成大的
        3个一组转换成6个一组
        进行整体归并排序
        得到最终答案
     */
    public static void main(String[] args) {
         int[] array = new int[]{1,3,5,9,6,4,5,2,4,6,8,10};
        // merge(array,0,2,array.length - 1);
        // System.out.println(Arrays.toString(array));
        mergeSort(array,0,array.length - 1);
        System.out.println(Arrays.toString(array));
        // [1, 2, 3, 4, 4, 5, 5, 6, 6, 9, 8, 10]
    }

    /**
     * 归并排序算法实现
     * @param array 需要排序的数组
     */
    private static void mergeSort(int[] array,int low,int high){
        int middle = (high + low) / 2;
        /*
        处理左边和右边
        最后归并
        前提是左边的要小于右边的
        否则就是重合了
        或者说只剩下1个数字了
         */
        if (low < high){
            mergeSort(array,0,middle - 1);
            mergeSort(array,middle + 1,high);
            merge(array,low,middle,high);
        }
    }

    /**
     * 数组归并操作
     * @param array 需要进行归并排序的数组
     * @param start 开始位置
     * @param split 中间位置
     * @param end 结束位置
     */
    private static void merge(int[] array,int start,int split,int end){
        /*
        存取归并后的数组
        获取第1个需要遍历的索引位置
        获取第2个需要遍历的索引位置
        初始化临时数组索引指针
         */
        int[] tmp = new int[end - start + 1];
        int i = start;
        int j = split + 1;
        int index = 0;


        while (i <= split && j <= end){
            /*
            程序运行到此处
            开始进行归并排序
            需要找出两个数中较小的数字
            放入临时数组中
             */
            if (array[i] <= array[j]){
                tmp[index] = array[i];
                i++;
            }else{
                tmp[index] = array[j];
                j++;
            }
            index++;
        }
        /*
        程序运行到此处
        说明有一侧有序数组已经遍历扫描完成了
        剩下那个比较长的数组就可以直接放入了
        两个数组多余的情况都要写出来
         */
        while (j <= end){
            tmp[index] = array[j];;
            j++;
            index++;
        }
        while (i <= split){
            tmp[index] = array[i];
            i++;
            index++;
        }
        /*
        程序运行到此处
        说明当前内部代码块已经排好序
        需要放回原数组
         */
        for (int k = 0; k < tmp.length; k++) {
            array[k + start] = tmp[k];
        }
    }
}

基数排序算法实现

package du;

import java.util.Arrays;

/**
 * @author 404小恐龙
 * @version 1.8
 * @date 2021/10/17 22:01
 */
public class m08 {
    /*
    基数排序实现思路
        首先初始化10个桶
        也就是10个数组
        先按个位数大小分别放入对应数组桶中
        然后再按先进先出的顺序依次从10个数组里面往外拿

        然后再按照十位数大小依次放入对应桶中
        拿出来的步骤和个位数一样

        我们排序的次数取决于
        当前数组最大的数字的位数
     */
    public static void main(String[] args) {
        int[] array = new int[]{23, 6, 9, 189, 306, 509, 666};
        baseSort(array);
        System.out.println(Arrays.toString(array)); // [6, 9, 23, 189, 306, 509, 666]
    }

    private static void baseSort(int[] array) {
        /*
        程序开始运行
        首先要找出数组中最大的数
        首先拿最小的去比才能找到最大值

        计算最大数字的位数
        初始化数组桶
        初始化counter记录存了多少个数

        counter赋值为10的原因是10个桶对应10个数组
        每个位置记录对应桶的存放个数
         */
        int arrayLen = array.length;
        int max = Integer.MIN_VALUE;
        for (int i = 0; i < arrayLen; i++) {
            if (array[i] > max) {
                max = array[i];
            }
        }

        int maxLen = (max + "").length();
        int[][] bucket = new int[10][arrayLen];
        int[] counter = new int[10];

        /*
        程序运行到这里
        说明已经找到了max的长度
        此时需要规定循环maxLen次
         */
        for (int i = 0, n = 1; i < maxLen; i++, n *= 10) {
            /*
            程序第一次运行到此处
            说明需要取到所有数字的余数
            首先取的是个位数
            此时n = 1
             */
            for (int j = 0; j < arrayLen; j++) {
                int remainder = array[j] / n % 10;
                bucket[remainder][counter[remainder]] = array[j];
                counter[remainder]++;
            }
            /*
            程序第一次运行到此处
            说明第1轮排序已经完成
            此时需要将元素按顺序取出来
            以便进行第二轮排序
            这里需要初始化索引
             */
            int index = 0;
            for (int k = 0; k < counter.length; k++) {
                if (counter[k] != 0){
                    /*
                    程序运行到此处
                    说明这个位置的bucket还没有取完
                    继续将元素取出来
                     */
                    for (int l = 0; l < counter[k]; l++) {
                        array[index++] = bucket[k][l];
                    }
                    /*
                    程序运行到此处
                    每次遍历取完值
                    需要清空对应counter的k值
                    以便下一轮余数的放置
                     */
                    counter[k] = 0;
                }
            }
        }
    }
}

总目录