数据结构与算法（第七章 八大排序算法--堆排序在后面章节）

已于 2023-06-15 15:55:01 修改
阅读量234 收藏 2
点赞数 2
分类专栏： 数据结构 java 文章标签： 算法 数据结构 java 排序算法
于 2021-05-11 22:26:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45087487/article/details/116354448
版权

7.1冒泡算法
7.1.1基本介绍
（1）冒泡排序（Bubble Sorting）的基本思想是：通过对待排序序列从前向后（从下标较小的元素开始），依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部，就像水底下的气泡一样逐渐向上冒。
（2）优化：因为排序的过程中，各元素不断接近自己的位置，如果一趟比较下来没有进行过交换，就说明序列有序，因此要在排序过程中设置一个标志flag判断元素是否进行交换。从而减少不必要的比较。（这里说的优化，可以在冒泡排序写好后，在进行）
7.1.2演示冒泡过程的例子（图解）
在这里插入图片描述
小结以上图解：
（1）一共进行（数组的大小-1）次 大的循环
（2）每一趟排序的次数在逐渐的减少
（3）如果我们发现在某趟排序中，没有发生一次交换，可以提前结束冒泡排序。这个就是优化。

7.1.3冒泡排序应用实例
@将五个无序的数：3,9，-1,10，-2使用冒泡排序法将其排成一个从小到大的有序数列。

public class Demo1 {
    public static void main(String[] args) {
        //为了便于理解，冒泡排序的演变过程如下
        /*int[] arr={3,9,-1,10,-2};

        //起始的数组为
        System.out.println("初始的数组为：");
        System.out.println(Arrays.toString(arr));*/

        //测试冒泡排序的时间O(n^2)
        //定义一个随机数组
        int[] arr=new int[80000];
        for (int i=0;i<80000;i++){
            arr[i]=(int)(Math.random()*800000); //math.random的范围是[0,1)
        }

        //输出起始时间
        long time = System.currentTimeMillis();
        System.out.println(time);
        //调用封装好的冒泡方法
        bubbleSort(arr);
        //排序后时间
        long time2 = System.currentTimeMillis();
        System.out.println(time2);

        //排序后的数组为
        /*System.out.println("排序后的数组为：");
        System.out.println(Arrays.toString(arr));*/

        /*//第二趟排序
        for (int j=0;j<arr.length-1-1;j++){
            if (arr[j]>arr[j+1]){
                temp=arr[j];
                arr[j]=arr[j+1];
                arr[j+1]=temp;
            }
        }

        //第三趟排序
        for (int j=0;j<arr.length-1-2;j++){
            if (arr[j]>arr[j+1]){
                temp=arr[j];
                arr[j]=arr[j+1];
                arr[j+1]=temp;
            }
        }

        //第四趟排序
        for (int j=0;j<arr.length-1-3;j++){
            if (arr[j]>arr[j+1]){
                temp=arr[j];
                arr[j]=arr[j+1];
                arr[j+1]=temp;
            }
        }*/
    }

    //将冒泡排序封装为方法
    public static void bubbleSort(int[] arr){
        int temp=0; //临时变量
        boolean flag=false;  //定义标识符，判断每一趟是否交换过
        //冒泡排序时间复杂度为O(n^2)
        for (int i=0;i<arr.length-1;i++){
            for (int j=0;j<arr.length-1-i;j++){
                if (arr[j]>arr[j+1]){
                    flag=true;   //如果交换就将flag置位true
                    temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
            //System.out.println("第"+(i+1)+"趟排序后的数组为：");
            //System.out.println(Arrays.toString(arr));
            if (!flag){
                break;   //结束循环（因为此趟没有交换数组位置，说明数组已经有序）
            }else {
                flag=false;  //如果此趟交换过位置，需要将flag重置，以便于下一轮的循环
            }
        }
    }
}

7.2选择排序

7.2.1基本介绍
选择排序也属于内部排序法，是从欲排序的数据中，按指定的规则选出来某一元素，再一次规定交换位置后达到排序的目的。

7.2.2选择排序思想
选择排序（select sorting）也是一种简单的排序方法。它的基本思想是：第一次从arr[0]-arr[n-1]中选取最小值，与arr[0]交换，第二次从arr[1]-arr[n-1]中选取最小值，与arr[1]交换，第三次从arr[2]-arr[n-1]中选取最小值，与arr[2]交换，…, 第i次从arr[i-1]-arr[n-1]中选取最小值，与arr[i-1]交换，…, 第n-1次从arr[n-2]-arr[n-1]中选取最小值，与arr[n-2]交换，总共通过n-1次，得到一个按排序码从小到大排列的有序序列。

7.2.3选择排序的思路图
在这里插入图片描述

7.2.4选择排序实例
@将数组101,34,119,1进行排序

public class SelectSort {
    public static void main(String[] args) {
        //int[] arr={101,34,119,1};
        //System.out.println("起始数组");
        //System.out.println(Arrays.toString(arr));
        //定义一个随机数组（测试时间：时间比冒泡排序快）
        int[] arr=new int[80000];
        for (int i=0;i<80000;i++){
            arr[i]=(int)(Math.random()*800000); //math.random的范围是[0,1)
        }
        //起始时间
        System.out.println(System.currentTimeMillis());
        selectSort(arr);
        //排序后时间
        System.out.println(System.currentTimeMillis());
        //System.out.println("排序后数组");
        //System.out.println(Arrays.toString(arr));
    }

    //选择排序算法
    public static void selectSort(int[] arr){
        //算法  先简单--》做复杂，就是可以把一个复杂的算法，拆分成简单的问题-》逐步解决

        //冒泡时间复杂度为O(n^2)
        //第一轮
        for (int i=0;i<arr.length-1;i++){
            int minIndex=i;  //假设起始数小标为最小下标
            int min=arr[minIndex];  //假设起始数为最小值
            for (int j=i+1;j<arr.length;j++){
                if (arr[j]<min){  //判断循环的数是否比假设的起始值小，如果小则交换
                    minIndex=j;   //交换最小值下标
                    min=arr[j];   //交换最小值
                }
            }
            if (minIndex !=i){  //如果最小值不为当前假设值才可进入if语句
                arr[minIndex]=arr[i];
                arr[i]=min;
            }
        }


        /*//第二轮
         minIndex=1;  //假设起始数小标为最小下标
         min=arr[1];  //假设起始数为最小值
        for (int j=1+1;j<arr.length;j++){
            if (arr[j]<min){  //判断循环的数是否比假设的起始值小，如果小则交换
                minIndex=j;   //交换最小值下标
                min=arr[j];   //交换最小值
            }
        }
        if (minIndex !=1){  //如果最小值不为当前假设值才可进入if语句
            arr[minIndex]=arr[1];
            arr[1]=min;
        }

        //第三轮
        minIndex=2;  //假设起始数小标为最小下标
        min=arr[2];  //假设起始数为最小值
        for (int j=2+1;j<arr.length;j++){
            if (arr[j]<min){  //判断循环的数是否比假设的起始值小，如果小则交换
                minIndex=j;   //交换最小值下标
                min=arr[j];   //交换最小值
            }
        }
        if (minIndex !=2){  //如果最小值不为当前假设值才可进入if语句
            arr[minIndex]=arr[2];
            arr[2]=min;
        }*/
    }
}

7.3插入排序
7.3.1插入排序法介绍
插入式排序属于内部排序法，是对于欲排序的元素以插入的方式寻找该元素的适当位置，以达到排序的母的。
7.3.2插入排序法思想
插入排序（Insertion Sorting）的基本思想是：把n个待排序的元素看成为一个有序表和一个无序表，开始时有序表中只包含一个元素，无序表中包含有n-1个元素，排序过程中每次从无序表中取出第一个元素，把它的排序码依次与有序表元素的排序码进行比较，将它插入到有序表中的适当位置，使之成为新的有序表。
7.3.3插入排序思路图
在这里插入图片描述
7.3.4插入排序法应用实例：
@有一群小牛，考试成绩为101,34,119,1；请从小到大排序

public class InsertSort {
    public static void main(String[] args) {
        //int[] arr={101,34,119,1};
        int[] arr=new int[80000];
        for (int i=0;i<80000;i++){
            arr[i]=(int)(Math.random()*800000); //math.random的范围是[0,1)
        }
        //起始时间
        System.out.println(System.currentTimeMillis());
        insertSort(arr);
        //排序后时间
        System.out.println(System.currentTimeMillis());
    }
    //插入排序
    public static void insertSort(int[] arr){
        int indexVal=0;  //待排序的数
        int beforeIndex=0;
       //分步演示，便于理解
        for (int i=1;i<arr.length;i++){
            //第一轮（101,34,119,1） ==》（34,101,119,1）
            indexVal=arr[i];  //待排序的数
            beforeIndex=i-1;  //待排序前面一个数的索引（从次数开始进行往前遍历）
            //1.首先保证beforeIndex不越界
            //2.保证待插入的值小于与之比较的值后方可进入循环
            //3.满足条件就将待排序前一个数往后移，并将before--继续与前面的数比较
            while (beforeIndex>=0 && indexVal<arr[beforeIndex]){
                arr[beforeIndex+1]=arr[beforeIndex];
                beforeIndex--;
            }
            //循环结束后，将待排序数插入(在循环的最后将beforeIndex--作为循环判断条件，所以要把待排序数放在后一位)
            arr[beforeIndex+1]=indexVal;
           // System.out.println("第"+i+"次排序后");
            //System.out.println(Arrays.toString(arr));
        }

        /*//第二轮
        indexVal=arr[2];  //待排序的数
        beforeIndex=2-1;  //待排序前面一个数的索引（从次数开始进行往前遍历）
        while (beforeIndex>=0 && indexVal<arr[beforeIndex]){
            arr[beforeIndex+1]=arr[beforeIndex];
            beforeIndex--;
        }
        //循环结束后，将待排序数插入(在循环的最后将beforeIndex--作为循环判断条件，所以要把待排序数放在后一位)
        arr[beforeIndex+1]=indexVal;
        System.out.println("第二次排序后");
        System.out.println(Arrays.toString(arr));

        //第三轮
        indexVal=arr[3];  //待排序的数
        beforeIndex=3-1;  //待排序前面一个数的索引（从次数开始进行往前遍历）
        while (beforeIndex>=0 && indexVal<arr[beforeIndex]){
            arr[beforeIndex+1]=arr[beforeIndex];
            beforeIndex--;
        }
        //循环结束后，将待排序数插入(在循环的最后将beforeIndex--作为循环判断条件，所以要把待排序数放在后一位)
        arr[beforeIndex+1]=indexVal;
        System.out.println("第三次排序后");
        System.out.println(Arrays.toString(arr));*/
    }
}

7.4希尔排序
在这里插入图片描述

7.4.1希尔排序*法介绍
希尔排序是希尔（Donald Shell）于1959年提出的一种排序算法。希尔排序也是一种插入排序，它是简单插入排序经过改进之后的一个更高效的版本，也称为缩小增量排序。
7.4.2希尔排序法基本思想
希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。
7.4.3希尔排序法的示意图
在这里插入图片描述
ps：经过上面的“宏观调控”，整个数组的有序化程度成果喜人。此时，仅仅需要对以上数列简单微调，无需大量移动操作即可完成整个数组的排序。
在这里插入图片描述
7.4.4希尔排序法*应用实例
有一群小牛，考试成绩分别是{8,9，1,7，2，3,5，4,6，0}请从小到大排序，请分别使用
（1）希尔排序时，对有序序列在插入时采用交换法，并测试排序速度
（2）希尔排序时，对有序序列在插入时采用移动法，并测试排序速度

public class ShellSort {
    public static void main(String[] args) {
        //int[] arr={8,9,1,7,2,3,5,4,6,0};
        //定义一个随机数组（测试时间：时间比冒泡排序快）
        int[] arr=new int[80000];
        for (int i=0;i<80000;i++){
            arr[i]=(int)(Math.random()*800000); //math.random的范围是[0,1)
        }
        //起始时间
        System.out.println(System.currentTimeMillis());
        //shellSort1(arr);
        shellSort2(arr);
        //结束时间
        System.out.println(System.currentTimeMillis());
    }
    //希尔排序采用交换法实现
    public static void shellSort1(int[] arr){
        int temp=0;
        int count=0;
        for (int gap=arr.length/2;gap>0;gap /=2){
            //第一轮排序
            for (int i=gap;i<arr.length;i++){
                //遍历各组中所有的元素（共gap组，每组有2个元素，步长gap）
                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("第"+(++count)+"轮后数组为："+ Arrays.toString(arr));
        }

        /*//第二轮排序
        for (int i=2;i<arr.length;i++){
            //遍历各组中所有的元素（共2组，每组有5个元素，步长gap）
            for (int j=i-2;j>=0;j -=2){
                //如果当前元素大于加上步长后的那个元素，交换
                if (arr[j]<arr[j-2]){
                    temp=arr[j];
                    arr[j]=arr[j-2];
                    arr[j-2]=arr[j];
                }
            }
        }

        //第三轮排序
        for (int i=1;i<arr.length;i++){
            //遍历各组中所有的元素（共5组，每组有10个元素，步长gap）
            for (int j=i-1;j>=0;j -=1){
                //如果当前元素大于加上步长后的那个元素，交换
                if (arr[j]<arr[j-1]){
                    temp=arr[j];
                    arr[j]=arr[j-1];
                    arr[j-1]=arr[j];
                }
            }
        }*/
    }
    //对交换式的希尔排序进行优化->移位法
    public static void shellSort2(int[] arr){
        //增量gap，并逐步的缩小增量
        for (int gap=arr.length/2;gap>0;gap /=2){
            //从第gap个元素后开始判断
            for (int i=gap;i<arr.length;i++){
                int j=i;
                int temp=arr[j];
                //首先进行校验是否进入循环比较
                //ps:此处的arr[j]<arr[j-gap]与下方while里的temp<arr[j-gap]
                //含义不一样，此处表示当前索引j处值是否小于j-gap，如果小于就进入while循环
                //而while中的含义是往下遍历的过程中索引j-gap处的值是否大于待插入的值，如果大于就继续往前遍历（插入法）
                if (arr[j]<arr[j-gap]){
                    while (j-gap>=0 && temp<arr[j-gap]){
                        arr[j]=arr[j-gap];
                        j -=gap;
                    }
                    //循环结束,将temp的值放入指定位置
                    arr[j]=temp;
                }
            }
            //System.out.println("第某次循环后的结果"+Arrays.toString(arr));
        }
    }
}

7.5快速排序
7.5.1快速排序法介绍
快速排序（Quicksort）是对冒泡排序的一种改进。基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
7.5.2快速排序法示意图
在这里插入图片描述

7.5.3快速排序实例
@排序{-9,78,0,23,-567,70}

public class QuickSort {
    public static void main(String[] args) {
       int[] arr={-9,78,0,23,-567,70};
       quickSort(arr,0,arr.length-1);
        System.out.println(Arrays.toString(arr));
    }
    //快排
    public static void quickSort(int[] arr,int low,int high){

        int i,j,temp,t;
        if(low>high){
            return;
        }
        i=low;
        j=high;
        //temp就是基准位
        temp = arr[low];

        while (i<j) {
            //先看右边，依次往左递减
            while (temp<=arr[j]&&i<j) {
                j--;
            }
            //再看左边，依次往右递增
            while (temp>=arr[i]&&i<j) {
                i++;
            }
            //如果满足条件则交换
            if (i<j) {
                t = arr[j];
                arr[j] = arr[i];
                arr[i] = t;
            }

        }
        //最后将基准为与i和j相等位置的数字交换
        arr[low] = arr[i];
        arr[i] = temp;
        //递归调用左半数组
        quickSort(arr, low, j-1);
        //递归调用右半数组
        quickSort(arr, j+1, high);
    }
}

7.6归并排序
7.6.1归并排序介绍
归并排序（MERGE-SORT）是利用归并的思想实现的排序方法，该算法采用经典的分治（divide-and-conquer）策略（分治法将问题分（divide）成一些小问题然后递归求解，而治（conquer）的阶段则将分的阶段得到的各答案“修补”在一起，即分而治之）。
7.6.2归并排序思想示意图1-基本思想
在这里插入图片描述
说明：可以看到这种结构很像一颗完全二叉树，本文的归并排序我们采用递归去实现（也可采用迭代的方式去实现）。分阶段可以理解为就是递归拆分子序列的过程。
7.6.3归并排序思想示意图2-合并相邻有序子序列
再来看看治阶段，我们需要将两个已经有序的子序列合并成一个有序序列，比如上图中的最后一次合并，要将【4,5，7,8】和【1,2，3,6】两个已经有序的子序列，合并为最终序列【1,2，3,4，5,6，7,8】，如下是实现步骤
在这里插入图片描述
在这里插入图片描述
7.6.4归并排序的应用实例
@对数组{8,4,5,7,1,3,6,2}进行归并排序

public class MergeSort {
    public static void main(String[] args) {
        int[] arr={8,4,5,7,1,3,6,2};
        int[] temp=new int[arr.length];
        mergeSort(arr,0,arr.length-1,temp);
        System.out.println(Arrays.toString(arr));
    }

    //分+合方法
    public static void mergeSort(int[] arr, int left, int right, int[] temp) {
        if(left < right) {
            int mid = (left + right) / 2; //中间索引
            //向左递归进行分解
            mergeSort(arr, left, mid, temp);
            //向右递归进行分解
            mergeSort(arr, mid + 1, right, temp);
            //合并
            merge(arr, left, mid, right, temp);

        }
    }

    //合并的方法
    /**
     *
     * @param arr 排序的原始数组
     * @param left 左边有序序列的初始索引
     * @param mid 中间索引
     * @param right 右边索引
     * @param temp 做中转的数组
     */
    public static void merge(int[] arr, int left, int mid, int right, int[] temp) {

        int i = left; // 初始化i, 左边有序序列的初始索引
        int j = mid + 1; //初始化j, 右边有序序列的初始索引
        int t = 0; // 指向temp数组的当前索引

        //(一)
        //先把左右两边(有序)的数据按照规则填充到temp数组
        //直到左右两边的有序序列，有一边处理完毕为止
        while (i <= mid && j <= right) {//继续
            //如果左边的有序序列的当前元素，小于等于右边有序序列的当前元素
            //即将左边的当前元素，填充到 temp数组
            //然后 t++, i++
            if(arr[i] <= arr[j]) {
                temp[t] = arr[i];
                t += 1;
                i += 1;
            } else { //反之,将右边有序序列的当前元素，填充到temp数组
                temp[t] = arr[j];
                t += 1;
                j += 1;
            }
        }

        //(二)
        //把有剩余数据的一边的数据依次全部填充到temp
        while( i <= mid) { //左边的有序序列还有剩余的元素，就全部填充到temp
            temp[t] = arr[i];
            t += 1;
            i += 1;
        }

        while( j <= right) { //右边的有序序列还有剩余的元素，就全部填充到temp
            temp[t] = arr[j];
            t += 1;
            j += 1;
        }


        //(三)
        //将temp数组的元素拷贝到arr
        //注意，并不是每次都拷贝所有
        t = 0;
        int tempLeft = left; //
        //第一次合并 tempLeft = 0 , right = 1 //  tempLeft = 2  right = 3 // tL=0 ri=3
        //最后一次 tempLeft = 0  right = 7
        while(tempLeft <= right) {
            arr[tempLeft] = temp[t];
            t += 1;
            tempLeft += 1;
        }

    }
}

7.7基数排序（桶排序）
7.7.1基数排序（桶排序）介绍
（1）基数排序（radix sort）属于“分配式排序”（distribution sort），又称“桶子法”（bucket sort）或bin sort，顾名思义，他是通过键值的各个位的值，将要排序的元素分配至某些“桶”中，达到排序的作用
（2）基数排序法师属于稳定性的排序，基数排序法是效率高的稳定性排序法
（3）基数排序（Radix Sort）是桶排序的扩展
（4）基数排序是1887年赫尔曼.何乐礼发明的。它是这样实现的：将整数按位数切割成不同的数字，然后按每个位数分别比较。
7.7.2基数排序基本思想
将所有待比较数值统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，依次进行一次排序。这样从最低位排序一直到最高位排序完成以后，数列就变成一个有序序列。
7.7.3基数排序图文步骤如下
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
7.7.4代码实现
@将数组{53，3,542,748,14,214}使用基数排序，进行升序排序

public class RadixSort {
    public static void main(String[] args) {
       int arr[] = {53,3,542,748,14,214};
       radixSort(arr);
    }
    //基数排序（典型的空间换时间算法）
    public static void radixSort(int[] arr){
        //1.求出数组中最大的数
        int max=arr[0];   //假设第一个数是最大值
        for (int i=0;i<arr.length;i++){
            if (arr[i]>max){
                max=arr[i];
            }
        }
        //计算最大值的有几位数
        int maxLength=(max+"").length();
        //定义一个二维数组用来存放每轮排序后的值
        //二维数组第一个是固定的值10，从0-9，第二个参数为了防止溢出大小为传入数组的长度
        int[][] bucket=new int[10][arr.length];
        //再定义一个数组来存放每轮排序后各个桶中一共有多少个元素
        int[] bucketNum=new int[10];

        //根据推导后的基数排序实现代码如下
        for (int a=0,n=1;a<maxLength;a++,n*=10){
            for (int i=0;i<arr.length;i++){
                //求出每个数的相应位的数（个位，十位，百位.....）
                int num1=arr[i] /n % 10;
                bucket[num1][bucketNum[num1]]=arr[i];
                bucketNum[num1]++;   //存入一个数字后就加一
            }
            //每轮数字放好后就将桶中元素存入原始数组中
            int index=0;
            for (int i=0;i<bucket.length;i++){
                //如果桶中有元素就存放到原始数组中
                if (bucket[i].length !=0){
                    //遍历每个特定的桶
                    for (int j=0;j<bucketNum[i];j++){
                        arr[index] =bucket[i][j];
                        index++;
                    }
                }
                //每次取完后将每个bucketNum中的数置位0，以便下次使用
                bucketNum[i]=0;
            }
            System.out.println("第"+(a+1)+"轮后数组为"+Arrays.toString(arr));
        }
        /*//第一轮排序（比较个位数）
        for (int i=0;i<arr.length;i++){
            //求出每个数的个位数
            int num1=arr[i] % 10;
            bucket[num1][bucketNum[num1]]=arr[i];
            bucketNum[num1]++;   //存入一个数字后就加一
        }
        //第一轮数字放好后就将桶中元素存入原始数组中
        int index=0;
        for (int i=0;i<bucket.length;i++){
            //如果桶中有元素就存放到原始数组中
            if (bucket[i].length !=0){
                //遍历每个特定的桶
                for (int j=0;j<bucketNum[i];j++){
                    arr[index] =bucket[i][j];
                    index++;
                }
            }
            //每次取完后将每个bucketNum中的数置位0，以便下次使用
            bucketNum[i]=0;
        }
        System.out.println(Arrays.toString(arr));

        //第二轮排序（比较十位数）
        for (int i=0;i<arr.length;i++){
            //求出每个数的个位数
            int num1=arr[i] /10 % 10;
            bucket[num1][bucketNum[num1]]=arr[i];
            bucketNum[num1]++;   //存入一个数字后就加一
        }
        //第二轮数字放好后就将桶中元素存入原始数组中
        index=0;
        for (int i=0;i<bucket.length;i++){
            //如果桶中有元素就存放到原始数组中
            if (bucket[i].length !=0){
                //遍历每个特定的桶
                for (int j=0;j<bucketNum[i];j++){
                    arr[index] =bucket[i][j];
                    index++;
                }
            }
            //每次取完后将每个bucketNum中的数置位0，以便下次使用
            bucketNum[i]=0;
        }
        System.out.println(Arrays.toString(arr));

        //第三轮排序（比较百位数）
        for (int i=0;i<arr.length;i++){
            //求出每个数的个位数
            int num1=arr[i] /100 % 10;
            bucket[num1][bucketNum[num1]]=arr[i];
            bucketNum[num1]++;   //存入一个数字后就加一
        }
        //第三轮数字放好后就将桶中元素存入原始数组中
        index=0;
        for (int i=0;i<bucket.length;i++){
            //如果桶中有元素就存放到原始数组中
            if (bucket[i].length !=0){
                //遍历每个特定的桶
                for (int j=0;j<bucketNum[i];j++){
                    arr[index] =bucket[i][j];
                    index++;
                }
            }
            //每次取完后将每个bucketNum中的数置位0，以便下次使用
            bucketNum[i]=0;
        }
        System.out.println(Arrays.toString(arr));*/
    }
}

7.7.5基数排序的说明
（1）基数排序是对传统桶排序的扩展，速度很快
（2）基数排序是经典的空间换时间的方式，占用内存很大，当对海量数据排序时，容易造成OutOfMemoryError
（3）基数排序是稳定的。【ps：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j],且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的；否则称为不稳定的】
（4）有负数的数组，我们不用基数排序来进行排序，如果要支持负数，参考：地址

7.8常用排序算法比对
在这里插入图片描述

懒惰的小白521
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
学习笔记--数据结构与算法基础（青岛大学-王卓）--第七章查找算法
孤夜的博客
02-16 555
视频链接 数据结构与算法基础（青岛大学-王卓）–第七章查找 本章知识框架 目录:1.查找的基本概念2.线性表的查找3.树表的查找4.哈希表的查找 1.查找的基本概念 什么是查找表? 什么是关键字 什么是查找 查找是否成功? 查找的目的? 查找的分类 如何评价查找算法 查找过程中我们需要研究什么? 2.线性表的查找 对于这一部分,该视频讲解了顺序查找(线性查找),折半查找(二分或对分查找)和分块查找这三类查找。 顺序查找(线性查找) 顺序查找 算
java面试题16-排序算法的稳定性
a166244的博客
09-05 135
(1)冒泡排序 冒泡排序就是把小的元素往前调或者把大的元素往后调。比较是相邻的两个元素比较，交换也发生在这两个元素之间。所以，如果两个元素相等，我想你是不会再无聊地把他们俩交换一下的；如果两个相等的元素没有相邻，那么即使通过前面的两两交换把两个相邻起来，这时候也不会交换，所以相同元素的前后顺序并没有改变，所以冒泡排序是一种稳定排序算法。 (2)选择排序...
数据结构 第七章 排序——冒泡排序，快速排序
qq_40344308的博客
05-13 698
冒泡排序： void Bubble_Sort( ElementType a[], int n ) { int i, k; for( k = n - 1; k > 0; k-- ){ //外部循环，每一次冒泡结束后最后一个位置的元素总是有序的，所以在下一次排序时就不需要比较它 int flag = 0; //标记设为0 f...
C# 第二章冒泡排序
qq_36074043的博客
11-08 419
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace ConsoleApplication6 { class Program { static void Main(st
数据结构与算法A实验八排序---7-7 堆排序
qq_53078834的博客
12-06 2891
【堆排序】堆排序算法（图解详细流程）_阿顾的博客-CSDN博客_堆排序过程图解 给定一个整数序列，请按非递减序输出采用堆排序的各趟排序后的结果。 输入格式: 测试数据有多组，处理到文件尾。每组测试数据第一行输入一个整数n（1≤n≤100），第二行输入n个整数。 输出格式: 对于每组测试，输出若干行，每行是一趟排序后的结果，每行的每两个数据之间留一个空格。 输入样例: 4 8 7 2 1 输出样例: 7 1 2 8 2 1 7 8 1 2 7 8 #include<bits/
数据结构与算法--八大排序
m0_59052131的博客
11-03 747
1.基本概念：1.排序:2.需要掌握的点：3.稳定性：4.排序难点：2.分类：3.比较：1.稳定性：2.时间复杂度：3.空间复杂度：4.排序详解：1.选择排序--直接插入排序2.插入排序--希尔排序(Insert Sort)3.选择排序-简单选择排序(Simple selection sort)4.选择排序-堆排序(Heap sort)5.交换排序-冒泡排序(Bubble Sort)6.交换排序-快速排序(Quick-Sort)7.归并排序-(Merge sort)8. 基数排序(RadixSort)
【数据结构】--八大排序算法【完整版】
m0_74044018的博客
07-23 2075
数据结构中的8大排序：直接插入排序，希尔排序...他们的具体实现，递归与非递归实现等
【数据结构】八大排序(超详解+附动图+源码)
热门推荐
Edward_Asia的博客
11-21 8万+
前言 所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。 生活中各种地方都需要用到排序，所以学好排序算法是非常重要的。 排序分为 内部排序 和 外部排序。 内部排序：数据元素全部放在内存中的排序。外部排序：数据元素太多不能同时放在内存中，根据排序过程的要求不能在内外存之间移动数据的排序。 这部分主要是内部排序。排序讲解都以升序为例。 常见的排序算法： // 排序实现的接口 // 插入排序 void InsertSort(int* arr..
数据结构算法---八大排序
weixin_57535054的博客
05-03 2628
数据结构八大排序详细解读！
【数据结构】常见八大排序算法总结
m0_64538862的博客
01-16 2098
1.直接插入排序2.希尔排序3.选择排序4.堆排序5.冒泡排序6.快速排序,Hoare版本,挖坑法,前后指针法 快速排序的递归实现 快速排序的非递归实现 7.归并排序8.计数排序（非比较排序）9基数排序 10排序算法的复杂度及稳定性分析
Caused by: java.lang.IllegalStateException: Failed to introspect Class
qq_45087487的博客
03-15 2万+
1、问题报错如下： Caused by: java.lang.IllegalStateException: Failed to introspect Class [com.jeequan.jeepay.components.mq.vender.rabbitmq.RabbitMQBeanProcessor] from ClassLoader [sun.misc.Launcher$AppClassLoader@18b4aac2] 2、问题解析： 意思是：未能反射rabbitmq类包（就是添加了依赖没加载进去
Java集合List、Set和Map史上最详细讲解
qq_45087487的博客
03-04 6530
1.集合概念 集合是java中提供的一种容器，可以用来存储多个数据。 2.集合与数组的区别（集合和数组都是容器，它们有啥区别呢？） 数组的长度是固定的。集合的长度是可变的 数组中存储的是同一类型的元素，可以存储基本数据类型值。集合存储的都是对象。而且对象的类型可以不一致。在开发中一般当对象多的时候，使用集合进行存储。 3.集合框架 集合按照其存储结构可以分为两大类，分别是单列集合java.util.Collection和双列集合java.util.Map。 Collection：单列集合类的根接口，用
linux下vi编辑器方向键变成字母的解决方法
qq_45087487的博客
03-27 6234
一、现象： 最近部署系统安装linux系统后，使用vi编辑器编辑文件时，使用方向键盘时光标没有移动，而是在页面打印ABCD等字样，并且删除键盘也不起效。 二、原因： 这个问题的最终原因是linux系统默认安装的vi编辑器，vi程序默认使用【h】【j】【k】【l】来移动光标，而我们平常习惯方向键盘移动光标是vim编辑器的使用操作。 三、解决方案： 安装vim编辑器就好（两步命令）。 命令一：apt-get remove vim-common （卸载系统自带的vi编辑器） 命令二：apt-get in
定时任务之Springboot整合Quartz详解
qq_45087487的博客
08-02 6060
Springboot整合Quartz详解
Hutool Java 工具类库导出 Excel并合并数据，全网最详细！
qq_45087487的博客
09-02 5627
ps：基于HuTool工具类ExcelWriter合并单元格并且使用 jdk1.8 lambda表达式 一、原始数据模板 二、合并后的数据 按照班级名称、班级分数、小组名称、小组得分、人物名称、人物总分进行单元格合并 合并后效果： 三、导入依赖 ps：pom依赖不适合可以换其他版本 导出是项目中最常见的功能，例如考勤记录导出，账单明细导出，订单记录导出等等。导出的工具类有许多种，目前常见的有poi,easypoi,poi...,今天我要说的是基于hutool-poi的导出，hutool-poi是将p
idea引入pom文件，导入依赖后，External Libraries包为空
qq_45087487的博客
01-20 4647
idea引入pom文件，导入依赖后，External Libraries目录除了jdk，没有其他的jar包 解决方法如下（将箭头位置选择序号为8的）： 重新刷新导入maven依赖后，External Libraries目录下面jar就导出成功。结果如下： ...
JAVA使用Apache POI动态导出Word文档
最新发布
qq_45087487的博客
05-10 3745
1、需要的环境2、创建模板3、书写java类4、测试。
SpringBoot集成Freemarker模板生成Word文档，项目打成jar包到生产环境显示找不到模板文件
qq_45087487的博客
04-05 2549
2、解决方案：注入FreeMarkerConfigurer配置类，因为freemarker模板的默认目录就在resourse下的templates目录下，使用freeMarkerConfigurer.getConfiguration().getTemplate(“word.ftl”)可直接获取到对应的模板文件。本人出错的代码大概如下所示：这块代码主要是testTemplate()方法中configuration通过模板名获取模板对象而服务，所以报错也是这行代码导致线上报错。
elasticSearch7版本文档中文属性模糊查询不准确
qq_45087487的博客
02-06 2450
通过java模糊查询的api（QueryBuilders.fuzzyQuery）查询name为“已”的时候可以查询，查询为“已发布”的时候查询不出来。name":"catalog=Catalog(value=699015935012372480, displayName=/默认分组),3.1 给索引添加分词器（删除索引后，然后重新建立索引并设置分词器，如2中图所示）14:33:17)status:已发布”ps:索引中没设置分词器。ps：索引中设置分词器后。
数据结构第9章：排序算法详解
数据结构第9章排序算法总结 一、排序算法概述 排序是使用最频繁的一类算法，分为内排序和外排序两大类。内排序算法主要分为5大类，有12个算法，分别是插入排序、交换排序、选择排序、归并排序和多排序码排序。每种...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值