05排序算法

排序

排序算法介绍

排序也称排序算法（Sort Algrothim)，排序是将一组与数据，按照指定的顺序进行排列的过程

排序的分类

1)内部排序：指将需要处理的所有数据都加载到内部存储器中进行排序

2)外部排序：数据量过大，无法全部加载到内存中，需要借助外部存储进行排序

常见排序的分类

1. 插入排序

   ​ 1.1、直接插入排序

   ​ 1.2、希尔排序

2. 选择排序

   ​ 2.1、简单选择排序

   ​ 2.2、堆排序

3. 交换排序

   3.1、冒泡排序

   3.2、快速排序

4. 归并排序

5. 基数排序

---

---

冒泡排序算法

基本介绍

冒泡排序（Bubble Sorting)的基本思想是：通过对待排序序列从前向后（从下标小的元素开始），依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移至后部。就像水底下的气泡一样逐渐向上冒

分析

/**
	对 3 9 -1 10 20 进行冒泡排序
	
**/

冒泡排序规则小结：

1. 一共进行数组的大小-1次大的循环( size-1)
2. 每一趟排序的次数在逐渐的减少 (size-i-1)

代码实现

package F排序;

import java.util.Arrays;

/**
 * @Author Zhou  jian
 * @Date 2020 ${month}  2020/1/3 0003  16:47
 * 冒泡排序
 */
public class BubbleSort {

    public static void main(String[] args) {

        int[] arr = {3,9,-1,10,20};
        System.out.println("原始数组"+Arrays.toString(arr));

        bubbleSort(arr);
        System.out.println("最终的排序结果为"+Arrays.toString(arr));


    }

    public static void bubbleSort(int[] arr){

        int size = arr.length;//数组的长度

        for(int i =0;i<size-1;i++){//需要排序size-1趟
			/**
			第一趟排序就是将最大的数排在最后
			第二趟排序就是将次大的数排在倒数第二个位置
			。。。。。。。。。。。 
			**/
          for(int j=0;j<size-i-1;j++){//从第一个元素开始两两对比
              
                if(arr[j]>arr[j+1]){//假如前面的数比后面的数大，则交换
                    int temp = arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
                System.out.println("第"+i+"趟;"+"第("+j+"论的排序结果为"+Arrays.toString(arr));
            }
            System.out.println("======================");
        }


    }

}

实现的结果

存在的问题:大量重复判断，重复的比较判断

代码的改进

优化

==因为在排序的过程中，各元素不断接近自己的位置，如果下一趟比较下来没有进行过交换，就说明序列有序。==因此要在排序过程中设置一个标志flag判断元素是否进行过交换，从而减少不必要的比较。

/**
     * 改进的算法
     * @param arr
     */
    public static void bubbleSort2(int[] arr){

        int size = arr.length;//数组的长度

        for(int i =0;i<size-1;i++){//需要排序size-1趟
            boolean flag = false; //用来标志是否进行交换
         for(int j=0;j<size-i-1;j++){//从第一个元素开始两两对比

                if(arr[j]>arr[j+1]){//假如
                    int temp = arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                    flag = true;
                }
                System.out.println("第"+i+"趟;"+"第("+j+"论的排序结果为"+Arrays.toString(arr));
            }
            System.out.println("======================");
            if(!flag){//没有进行交换说明已经有序,则停止冒泡
                break;
            }
        }


    }

---

性能的分析

//测试一下冒泡排序的速度O(n^2) ,给80000个数据，测试
        //创建要给80000个随机的数组
        int[] arr = new int[80000];
        for (int i=0;i<80000;i++){
            arr[i]=(int)(Math.random()*800000);//产生一个[0,800000)的随机数

        }

        Date date1 = new Date();
        SimpleDateFormat simpleDateFormat1  = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String date1Str = simpleDateFormat1.format(date1);
        System.out.println("排序前的时间是"+date1Str);

        //测试冒泡排序
        bubbleSort(arr);
        Date date2 = new Date();
        String date2Str = simpleDateFormat1.format(date2);
        System.out.println("排序后的时间是"+date2Str);

/**
	运行结果:
			排序前的时间是2020-01-03 17:56:38
              排序后的时间是2020-01-03 17:56:53  
              
              80000个数据排序大概是 8秒（不同电脑性能可能不一样)
**/

---

---

---

选择排序

基本介绍

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

​ 思想

选择排序（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-1]~arr[n-2]次中选取最小值，与arr[n-2]交换；

总共通过n-1次，得到一个按排序码从小到大排列的有序序列。

分析

 /*原始数组: 101  34 119 1
 * 第一轮排序: 1 34 119 101
 * 第二轮排序: 1 34 119 101
 * 第三轮排序 :  1 34 101 119*/

说明

1. 选择排序一共有数组大小-1轮排序

2. 每一轮排序，又是一个排序，循环的规则（代)

   ​ 2.1、先假定当前这个数是最小数

   ​ 2.2、然后和后面的每个数比较，如果发现有比当前数更小的数，就重新确定最小数，并得到下标

   ​ 2.3、当遍历到数组的最后时，就得到本轮最小数和下标

   ​ 2.4、确定本轮最小位置交换数据

   ​

代码实现

package F排序;

import java.util.Arrays;

/**
 * @Author Zhou  jian
 * @Date 2020 ${month}  2020/1/3 0003  19:47
 *
 * 原始数组: 101  34 119 1
 * 第一轮排序: 1 34 119 101
 * 第二轮排序: 1 34 119 101
 * 第三轮排序 :  1 34 101 119
 *
 *
 */
public class SelectSort {

    public static void main(String[] args) {
        int[] arr = {101,34,119,1};
        System.out.println("原始的数组为"+Arrays.toString(arr));
        selectSort(arr);
        System.out.println("排序的结果为"+Arrays.toString(arr));

    }

    public static void selectSort(int[] arr){
        //循环
        for(int i =0;i<arr.length-1;i++){
            int tempIndex = i;//记录本轮（i轮）所求最小数据的索引
            int temp = arr[i];//记录本轮最小数据
            for(int j=i;j<arr.length;j++){  //求出 从 arr[i]到末尾元素中的最小数据
                if(arr[j]<temp){//
                    tempIndex = j; //存储最小数据的索引
                    temp = arr[tempIndex]; //存储最小数据的值
                }

            }
            if(tempIndex!=i){ //加入有交换数据
                temp = arr[tempIndex];
                arr[tempIndex] = arr[i];
                arr[i]=temp;
            }
            System.out.println("第"+(i+1)+"轮排序的结果是"+ Arrays.toString(arr));
        }
    }

}

性能分析

选择排序的时间会缩短，优于冒泡排序

//测试一下选择排序的速度O(n^2) ,给80000个数据，测试 
        int[] arr = new int[80000];
        for (int i=0;i<80000;i++){
            arr[i]=(int)(Math.random()*800000);//产生一个[0,800000)的随机数
        }

        Date date1 = new Date();
        SimpleDateFormat simpleDateFormat1  = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String date1Str = simpleDateFormat1.format(date1);
        System.out.println("排序前的时间是"+date1Str);

        //测试选择排序
        selectSort(arr);
        Date date2 = new Date();
        String date2Str = simpleDateFormat1.format(date2);
        System.out.println("排序后的时间是"+date2Str);

/**
排序前的时间是2020-01-03 20:21:54
排序后的时间是2020-01-03 20:21:58 	
**/

---

---

---

插入排序

基本介绍

插入排序属于内部排序法，是对于欲排序的元素以插入的方式寻找该元素的适当位置，以达到排序的目的。

思想

把n个待排序的元素看成一个有序表和一个无序表

开始时有序表只包含一个元素，无序表中包含有n-1个元素

排序过程中每次从无序表中取出第一个元素把它的排序码依次与有序表元素的排序码进行比较，将它插入到有序表中的适当位置，使之成为新的有序表

分析

代码实现

package F排序;

import java.util.Arrays;

/**
 * @Author Zhou  jian
 * @Date 2020 ${month}  2020/1/3 0003  20:52
 *
 * 插入排序
 */
public class InsertSelect
{

    public static void main(String[] args) {
//        int[] arr = {17,3,25,14,20,9};
        int[] arr = {101,34,119,1};
        System.out.println("排序前的数组为"+ Arrays.toString(arr));

        insertSelect(arr);



    }

    //插入排序
    public static void  insertSelect(int[] array){

        for(int i =0;i<array.length;i++){//i为的元素位置
            int inserValue = array[i];//待插入的元素
            for(int j=0;j<=i;j++ ){//j为遍历的元素可能位置
                if(array[i]<array[j]){ //找到插入的索引位置
                    for(int t = i;t>j;t--){ //将该索引位置之后的元素后移
                        array[t]=array[t-1];
                    }
                    array[j] = inserValue;//将该索引处的元素插入
                }
            }
            System.out.println("第"+i+"轮为排序结果为"+Arrays.toString(array));

        }


    }
    
    
    
    
    
    
    
   //使用while循环实现，书中代码
    public static void  insertSelect2(int[] arr){


        for(int i =1;i<arr.length;i++){
            //定义待插入的数
            int insertValue = arr[i];
            int insertIndex = i-1; //即arr[i]前面这个数的下标

            //给insertVal找到插入的位置
            //说明：
            //1、insertIndex>0 保证在insertVal 找插入位置不越界
            //2、insertval<arr[insertIndex]待插入的数，还没有找到插入位置
            //3、就需要将inserttIndex后移
            while(insertIndex>=0&&insertValue<arr[insertIndex]){
                arr[insertIndex+1]=arr[insertIndex]; //
                insertIndex--;
            }
            //当退出while循环时，就说明插入的位置找到，insertIndex+1的位置
            arr[insertIndex+1] = insertValue;

        }

    }

性能分析

int[] arr = new int[80000];
        for (int i=0;i<80000;i++){
            arr[i]=(int)(Math.random()*800000);//产生一个[0,800000)的随机数
        }

        Date date1 = new Date();
        SimpleDateFormat simpleDateFormat1  = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String date1Str = simpleDateFormat1.format(date1);
        System.out.println("排序前的时间是"+date1Str);

        //测试选择排序
       insertSelect(arr);
        Date date2 = new Date();
        String date2Str = simpleDateFormat1.format(date2);
        System.out.println("排序后的时间是"+date2Str);

        insertSelect(arr);
/**
	排序前的时间是2020-01-03 21:28:55
    排序后的时间是2020-01-03 21:28:58
**/

希尔排序（对选择排序的改进)

我们看简单的插入排序可能存在的问题:

/**
数组arr = [2,3,4,5,6,1]
这时需要插入的数1（最小），这样的过程是:

[2,3,4,5,6,6]
[2,3,4,5,5,6]
[2,3,4,4,5,6]
[2,3,3,4,5,6]
[2,2,3,4,5,6]
[1,2,3,4,5,6]
结论:当需要插入的数是较小的数时，后移的次数明显增多，对效率有影响
**/

基本介绍

希尔排序是希尔于1959年提出的一种排序算法。希尔排序也是一种插入排序，它是简单插入排序经过改进之后的一个更高效的版本，也称为缩小增量排序

基本思想

希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；

随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止

分析

核心：将之前的插入排序数组拆分成若干个小的逻辑数组进行插入排序

仅仅需要对数组进行微调，无须大量移动操作即可完成整个数组的排序

首先它把较大的数据集合分割成若干个小组（逻辑上分组），然后对每一个小组分别进行插入排序，此时，插入排序所作用的数据量比较小（每一个小组），插入的效率比较高

代码实现

希尔排序交换式

        //希尔排序的第一轮排序
        //因为第一轮排序，是将十个数据分成5组
        for(int i =5;i<arr.length;i++){
            //遍历各组中所有元素（共5组，每组2各元素），步长是5
            for(int j=i-5;j>=0;j-=5){
                //如果当前元素大于加上步长后的那个元素，说明需要交换
                if(arr[j]>arr[j+5]){
                    int temp = arr[j];
                    arr[j]=arr[j+5];
                    arr[j+5]=temp;
                }
            }
        }

        System.out.println("希尔排序第一轮的结果"+ Arrays.toString(arr));




        //希尔排序的第二轮排序

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

        System.out.println("希尔排序第二轮的结果"+ Arrays.toString(arr));


        //希尔排序的第三轮排序
        //因为第三轮排序，是将2/2个数据分成1组
        for(int i =1;i<arr.length;i++){
            //遍历各组中所有元素（共1组，每组10各元素），步长是1
            for(int j=i-1;j>=0;j-=1){
                //如果当前元素大于加上步长后的那个元素，说明需要交换
                if(arr[j]>arr[j+1]){
                    int temp = arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }

        System.out.println("希尔排序第三轮的结果"+ Arrays.toString(arr));
//以上为逐步推导的方式
        





// *希尔交换式//
public static void shellSort(int[] arr) {

       
        for(int gap =arr.length/2;gap>0;gap=gap/2) {
            for (int i = gap; i < arr.length; i++) {
                //遍历各组中所有元素（共gap组），补偿是gap
                for (int j = i - gap; j >= 0; j -= gap) {
                    //如果当前元素大于加上步长后的那个元素，说明需要交换
                    if (arr[j] > arr[j + gap]) {
                        int temp = arr[j];
                        arr[j] = arr[j + gap];
                        arr[j + gap] = temp;
                    }
                }
            }
           

            System.out.println("希尔排序第轮的结果" + Arrays.toString(arr));
        }

    }
}

/**

希尔排序第1轮的结果[3, 5, 1, 6, 0, 8, 9, 4, 7, 2]
希尔排序第2轮的结果[0, 2, 1, 4, 3, 5, 7, 6, 9, 8]
希尔排序第3轮的结果[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]**/


/**
测试其对80000个随机数的排序结果：7秒
排序前的时间是2020-01-03 23:03:53
排序后的时间是2020-01-03 23:04:00
思考为什么？现在是每发现一个数据就交换，进行；两两对比因此性能下降
**/

性能较差:现在是每发现一个数据就交换，进行；两两对比因此性能下降(是一种较差的希尔排序)

---

---

希尔排序位移式

     //对交换式的希尔排序进行优化---->移位法
    public  static void shellSort2(int[] arr){

        //增量gap，并逐步缩小增量  5--->2---->1
        for(int gap=arr.length;gap>0;gap=gap/2){

            //从第gap个元素开始逐个对其所在的组进行直接插入排序
            for(int i=gap;i<arr.length;i++){
                int j = i;
                int temp = arr[j];
                if(arr[j]<arr[j-gap]){
                    while(j-gap>=0&&temp<arr[j-gap]){
                        //移动
                        arr[j]=arr[j-gap];
                        //
                        j -=gap;
                    }
                    //当退出循环后就给temp找到了weizhi
                    arr[j]=temp;
                }
            }

        }
        
    }

/**
测试其对80000个随机数的排序结果：1秒
排序前的时间是2020-01-03 23:15:51
排序后的时间是2020-01-03 23:15:51
**/

快速排序

基本介绍

快速排序是对冒泡排序的一种改进，基本思想是：

通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据比另外一部分的所有数据都要小；

然后再按此方法对两部分数据分别进行快速排序’

整个排序过程可以递归进行

以此达到整个数据变成有序序列。

分析

代码实现

package F排序;

import java.util.Arrays;

/**
 * @Author Zhou  jian
 * @Date 2020 ${month}  2020/1/4 0004  15:37
 * 快速排序
 */
public class QuickSort {

    public static void main(String[] args) {
        int[] arr ={-9,78,0,23,-567,70};
        quickSort(arr,0,arr.length-1);
    }


    public static void quickSort(int[] arr,int left,int right){
        int l = left;//左索引
        int r = right;//右索引

        //中轴
        int pivot=arr[(left+right)/2];

        int temp = 0;
        //while循环的目的是让比pivot值小放到左边
        //比pivot值大的放在右边
        while(l<r){
            //在pivot左边一致找，找到大于等于pivot，才推出
            while(arr[l]<pivot){
                l +=1;
            }

            //在pivot右边一致找，找到小等于pivot，才推出
            while(arr[r]>pivot){
                r -=1;
            }

            //如果l>=r说明pivot的左右两边的值，已经按照左边全部是小于等于pivot值，右边全部是大于pivot的值
            if(l>=r){
                break;
            }

            //交换
            temp=arr[l];
            arr[l]=arr[r];
            arr[r]=temp;

            //下面两个主要是为了防止进入死循环
            //如果交换完发现这个arr[l]==pivot值相等 前移
            if(arr[l]==pivot){
                r -=1;
            }

            //如果交换完发现这个arr[r]==pivot值相等 后移
            if(arr[r]==pivot){
                l +=1;
            }

        }

        System.out.println(Arrays.toString(arr));


        //如果l==r，必须l++,r--，否则会出现栈溢出
        if(l==r){
            l+=1;
            r-=1;
        }

        //向左递归
        if(left<r){
            quickSort(arr,left,r);
        }

        //向you递归
        if(right>l){
            quickSort(arr,l,right);
        }

    }
}

性能分析

排序前的时间是2020-01-04 16:29:23
排序后的时间是2020-01-04 16:29:23

归并排序

基本介绍

归并排序是利用 归并的思想实现的排序方法

该算法采用经典的分治策略（分治法将问题分成一些小的问题然后递归求解，而治的阶段则将分的阶段得到的个答案“修补”在一起，即分而治之）

分析

再来看看治阶段，我们需要将两个已经有序的子序列合并成一个有序序列，比如上图中的最后一次合并，要将[4,5,7,8]和[1,2,3,6]两个已经有序的子序列，合并为最终序列[1,2,3,4,5,6,7,8]，来看下实现步骤:

代码实现

package F排序;

import java.util.Arrays;

/**
 * @Author Zhou  jian
 * @Date 2020 ${month}  2020/1/4 0004  16:54
 * 归并排序
 */
public class MergeSort {

    public static void main(String[] args) {
        int[] arr ={8,4,5,7,1,3,6,2};
        int[] temp = new int[8]; //归并排序需要额外的空间
        mergeSort(arr,0,arr.length-1,temp);

        System.out.println("归并排序后结果为"+ Arrays.toString(arr));

    }

    //合并的方法

    /**
     *
     * @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;//临时数组的当前索引

        //1、先把左右两边（有序）的数据按照规则填充到temp中，直到左右两边的有序数列有一边处理完毕

        while(i<=mid && j<=right){
        //如果左边的有序序列的当前元素，小于等于右边有序序列的当前元素
            //即将左边的当前元素拷贝到temp数组的t位置
            //然后t++ i++ 移动
            if(arr[i]<=arr[j]){
                temp[t] = arr[i];
                t +=1;
                i +=1;
            }else{//反之，左边的有序序列大于右边的有序序列，则将右边有序序列的数据填充到临时数组
                temp[t] = arr[j];
                t +=1;
                j +=1;
            }

        }

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

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

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


    //分+和的方法
    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);

        }

    }

}

性能分析‘

排序前的时间是2020-01-04 18:06:50
排序后的时间是2020-01-04 18:06:50

基数排序

基本介绍

1）基数排序属于 “分配式排序，又称桶子法，顾名思义，它是通过键值的各个位的值，将要排序的元素分配至某些”桶“中，达到排序的作用

2)基数排序是属于稳定性的排序，基数排序法是效率高的稳定性排序法;基数排序是经典的空间换时间的方式，占用内存很大，当对海量数据排序时，容易造成OutOfMemoryError

3)基数排序是桶排序的扩展

4)基数排序是这样实现的：将整数按位数切割成不同的数字，然后按每个位数分别比较。;对于负数的情况，需要区别对待、

分析

基本思想

1. 将所有待比叫数值统一为同样的数位长度，数位较短的数前面补0。然后从最低位开始，依次进行一次排序。这样从最低位排序一直到最高位排序完成以后，数列就变成一个有序序列
2. 图文解释如下

第一轮排序:

(1)将每个元素的个位数取出，然后看这个数应该放在哪个对应的桶（一个于维数组）

(2)按照这个桶的顺序（一维数组的下标依次取出数据，放入原来数组)

第二轮排序

(1)将每个元素的十位数取出，然后看这个数应该放在哪个对应的桶（一个于维数组）

(2)按照这个桶的顺序（一维数组的下标依次取出数据，放入原来数组)

第三轮排序

(1)将每个元素的百位数==取出，然后看这个数应该放在哪个对应的桶（一个于维数组）

(2)按照这个桶的顺序（一维数组的下标依次取出数据，放入原来数组)

小结:

1. 排序的轮数与数组中的最高位数有关

代码

package F排序;

import java.util.Arrays;

/**
 * @Author Zhou  jian
 * @Date 2020 ${month}  2020/1/4 0004  19:01
 *
 */
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) {


        //先得到数组中最大的位数
        int max = arr[0]; //假设第一位最大
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }

        //得到最大数的位数
        int maxLength = (max + "").length();


        //第一轮（针对每个元素的个位数进行处理）
        //定义一个二维数组，表示10个桶，每个桶就是一个一维数组
        //1、二维数组包含10个一维数组
        //2、为了防止在存入数的时候，数据溢出，则每个一维数组（桶）。大小定位arr.length
        //3、基数排序是使用空间换时间的经典算法
        int[][] bucket = new int[10][arr.length];

        //为了记录每个桶中，实际存入多少个数据，我们定义一个一维数组来记录各个桶中每次放入的数据个数
        //bucketElmentCounts[0]记录的就是 bucket[0]每次放入的数据个数
        int[] bucketElmentCounts = new int[10];


        //这里使用循环
        for (int t = 0,n=1; t < maxLength; t++,n=n*10) {

            //针对每个元素对应的位进行排序，第一次是各位，第二次是十位，第三次是百位
            for (int j = 0; j < arr.length; j++) {
                //取出每个元素的个数
                int digitOfElement = arr[j]/n % 10;
                //放入到对应的桶中
                bucket[digitOfElement][bucketElmentCounts[digitOfElement]] = arr[j];
                bucketElmentCounts[digitOfElement]++;
            }
            int count = 0;
            //将桶中的元素依次取出,并将桶中的数据放入原来的数组
            for (int i = 0; i < bucket.length; i++) {
                for (int j = 0; j < bucketElmentCounts[i]; j++) {
                    arr[count] = bucket[i][j];
                    count++;
                }
                bucketElmentCounts[i] = 0;
            }

            System.out.println("桶排序第+"+(t+1)+"轮的结果为" + Arrays.toString(arr));
        }

    }


}

性能分析

排序前的时间是2020-01-04 19:38:15
排序后的时间是2020-01-04 19:38:15

常用排序算法总结和对比

相关术语解释

1. 稳定：如果a原本在b前面，而a=b，排序之后a仍然在b前面
2. 不稳定：如果a原本在b前面，而a=b，排序之后a可能在b前面也可能在b后面
3. 内排序：所有排序操作都在内存中完成
4. 外排序：由于数据太大，因此把数据放在磁盘中，而排序通过磁盘和内存的数据传输才能进行
5. 时间复杂度：一个算法执行所耗费的时间
6. 空间复杂度:运行完一个程序所需要内存的大小
7. n：数据规模
8. k:桶的个数
9. In-place:不占用额外内存
10. out-place:占用额外内存

---

---

算法对比