15. 基数排序，以及性能测试（桶排序）

1. 什么是基数排序

2. 基数排序的做法

• 第一轮，排个位
  
• 第二轮，排十位

• 第三轮，排百位

3.代码实现

package com.qin.sort;

import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;

//基数排序是十分占用内存资源的
public class RadixSort {

    public static void main(String[] args) {
        
        int[] arr = {53,3,542,748,14,214};
        radixSort2(arr);
        
        //性能测试
        // 80000000 * 11 * 4 / 1024 / 1024 / 1024 = 3.3G
        int[] arr1 = new int[80000];
        int[] temp1 = new int[arr1.length];
        for (int i = 0; i < 80000; i++) {
            arr1[i] = (int)(Math.random()*80000000);
        }
        Date date1 = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String format1 = simpleDateFormat.format(date1);
        radixSort2(arr1);
        Date date2= new Date();
        String format2 = simpleDateFormat.format(date2);
        System.out.println("运行前"+format1);
        System.out.println("运行后"+format2);

    }

    public static void radixSort(int[] arr){

        //第一轮排序，针对每个元素的个位 第一轮542, 53, 3, 14, 214, 748
        //定义一个二维数组表示10个桶
        //说明
        //1.二维数组包含了10个一维数组
        //2.为了防止再放入数的时候，数据溢出，我们认为每个一维数组的大小认为arr.length
        //3.很明显，基数排序使用空间换时间的经典算法
        int [][] bucket = new int[10][arr.length];
        //为了记录每个桶实际存放了几个数据，我们使用一个一维数组来表示
        //打个比方 bucketElementCount[0]的值表示的就是第0个桶里面有多少个数据
        int [] bucketElementCount = new int[10];
        for (int i = 0; i < arr.length; i++) {
            //去除每个元素的个位
            int digitOfElement = arr[i] % 10;
            //放入到桶中
            // bucket[digitOfElement][bucketElementCount[digitOfElement]]
            // 打个比方，现在插入个位为1的数据
            // 那么 digitOfElement = 1; 我们插入下标为1的桶
            // 那么 bucketElementCount[digitOfElement] = bucketElementCount[1]
            bucket[digitOfElement][bucketElementCount[digitOfElement]] = arr[i];
            bucketElementCount[digitOfElement]++;

        }
        //按照这个桶的顺序（一维数组的小标依次取出数据，放入原来的数组）
        int index = 0;
        //遍历每一个桶，并将桶中的数据放入到原数组
        for (int i = 0; i < 10; i++) {
            //如果桶中有数据，我们就放入
            if (bucketElementCount[i]!=0){ //如果不等于0 ，说明里面是有数据的
                //循环该桶即第i个桶
                for (int j = 0; j < bucketElementCount[i] ; j++) {
                    //取出元素放入到arr中
                    arr[index] = bucket[i][j];
                    index++;
                }
            }
            //重要 在每一轮处理后，需要将每个bucketElementCount[i] = 0;
            bucketElementCount[i] = 0;
        }
        System.out.println("第一轮对个位的排序处理"+ Arrays.toString(arr));


        //第二轮 3, 14, 214, 542, 748, 53
        for (int i = 0; i < arr.length; i++) {
            //去除每个元素的十位
            int digitOfElement = arr[i] /10 % 10;
            bucket[digitOfElement][bucketElementCount[digitOfElement]] = arr[i];
            bucketElementCount[digitOfElement]++;

        }
        //按照这个桶的顺序（一维数组的小标依次取出数据，放入原来的数组）
        index = 0;
        //遍历每一个桶，并将桶中的数据放入到原数组
        for (int i = 0; i < 10; i++) {
            //如果桶中有数据，我们就放入
            if (bucketElementCount[i]!=0){ //如果不等于0 ，说明里面是有数据的
                //循环该桶即第i个桶
                for (int j = 0; j < bucketElementCount[i] ; j++) {
                    //取出元素放入到arr中
                    arr[index] = bucket[i][j];
                    index++;
                }
            }
            //重要 在每一轮处理后，需要将每个bucketElementCount[i] = 0;
            bucketElementCount[i] = 0;
        }
        System.out.println("第二轮对十位的排序处理"+ Arrays.toString(arr));



        //第三轮
        for (int i = 0; i < arr.length; i++) {
            //去除每个元素的十位
            int digitOfElement = arr[i] /100 % 10;
            bucket[digitOfElement][bucketElementCount[digitOfElement]] = arr[i];
            bucketElementCount[digitOfElement]++;

        }
        //按照这个桶的顺序（一维数组的小标依次取出数据，放入原来的数组）
        index = 0;
        //遍历每一个桶，并将桶中的数据放入到原数组
        for (int i = 0; i < 10; i++) {
            //如果桶中有数据，我们就放入
            if (bucketElementCount[i]!=0){ //如果不等于0 ，说明里面是有数据的
                //循环该桶即第i个桶
                for (int j = 0; j < bucketElementCount[i] ; j++) {
                    //取出元素放入到arr中
                    arr[index] = bucket[i][j];
                    index++;
                }
            }
            //重要 在每一轮处理后，需要将每个bucketElementCount[i] = 0;
            bucketElementCount[i] = 0;
        }
        System.out.println("第三轮对百位的排序处理"+ Arrays.toString(arr));


    }

    public static void radixSort2(int[] arr){

        //得到数组中最大的位数
        int max = arr[0]; //假设第一个数最大
        int temp = 0;
        for (int i = 1; i < arr.length; i++) {
            if (max<arr[i]){
                max = arr[i];
            }
        }
        //得到最大的数，是几位数
        int maxLength = (max+"").length();

        //这里我们使用循环将代码处理一下
        int [][] bucket = new int[10][arr.length];
        int [] bucketElementCount = new int[10];

        for (int k = 0, n = 1; k < maxLength ; k++,n*=10) {
            //针对每个元素对应的位数，第一次是个位，第二次是十位，第三次是百位
            for (int i = 0; i < arr.length; i++) {
                int digitOfElement = arr[i] / n % 10;
                bucket[digitOfElement][bucketElementCount[digitOfElement]] = arr[i];
                bucketElementCount[digitOfElement]++;
            }
            //按照这个桶的顺序（一维数组的小标依次取出数据，放入原来的数组）
            int index = 0;
            //遍历每一个桶，并将桶中的数据放入到原数组
            for (int i = 0; i < 10; i++) {
                //如果桶中有数据，我们就放入
                if (bucketElementCount[i]!=0){ //如果不等于0 ，说明里面是有数据的
                    //循环该桶即第i个桶
                    for (int j = 0; j < bucketElementCount[i] ; j++) {
                        //取出元素放入到arr中
                        arr[index] = bucket[i][j];
                        index++;
                    }
                }
                //重要 在每一轮处理后，需要将每个bucketElementCount[i] = 0;
                bucketElementCount[i] = 0;
            }
            //System.out.println("第"+(k+1)+"轮对个位的排序处理"+ Arrays.toString(arr));

        }





    }

}

结果

4.注意事项