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

本文链接：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基数排序（桶排序）介绍

基数排序（radix sort）属于“分配式排序”（distribution sort），又称“桶子法”（bucket sort）或bin sort，顾名思义，他是通过键值的各个位的值，将要排序的元素分配至某些“桶”中，达到排序的作用
基数排序法师属于稳定性的排序，基数排序法是效率高的稳定性排序法
基数排序（Radix Sort）是桶排序的扩展
基数排序是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基数排序的说明

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