《排序算法系列7》基数排序(桶排序)

1 思想

桶排序是计数排序的升级版。它利用了函数的映射关系，高效与否的关键就在于这个映射函数的确定。桶排序 (Bucket sort)的工作的原理：假设输入数据服从均匀分布，将数据分到有限数量的桶里，每个桶再分别排序（有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排）。

2 算法描述

• 设置一个定量的数组当作空桶；
• 遍历输入数据，并且把数据一个一个放到对应的桶里去；
• 对每个不是空的桶进行排序；
• 从不是空的桶里把排好序的数据拼接起来。 

3 举例

假设10个数为：64、8、216、512、27、729、0、1、342、126

第一趟桶式排序（个位）：

将数组中的每个数按照个位数字的大小依次存入编号为0~9的桶,存完之后,从桶中依次取出数据,每个桶中的数据按照先存入的先取出,后存入的后取出的规则来读取,然后将读取的数据存入数组

第二趟桶式排序（十位）：

将数组中的每个数按照十位数字的大小依次存入编号为0~9的桶,存完之后,从桶中依次取出数据,每个桶中的数据按照先存入的先取出,后存入的后取出的规则来读取,然后将读取的数据存入数组

第三趟桶式排序（百位）：

将数组中的每个数按照百位数字的大小依次存入编号为0~9的桶,存完之后,从桶中依次取出数据,每个桶中的数据按照先存入的先取出,后存入的后取出的规则来读取,然后将读取的数据存入数组

此时发现第三轮过后数组 {0,1,8,27,64,126,216,342,512,729} 已经是有序的了,也就得到我们想要的结果了

4 基数排序(桶排序)代码推导

　　public static void main(String[] args) {
        int[] arr = { 58, 3, 542, 748, 14, 214 };
        radixSort(arr);
　　}
　　// 基数排序方法
    public static void radixSort(int[] arr) {
        // 第1轮 (针对每个元素的个位进行排序处理)

        // 定义一个二维数组,表示10个桶,每个桶都是一个一维数组
        // 1 二维数组包含10个一维数组
        // 2为了防止在放入数的时候,数据溢出,则每一个一维数组 大小定义为arr.length
        // 3很明确 基数排序用空间换时间的经典算法
        int[][] bucket = new int[10][arr.length];

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

        for (int j = 0; j < arr.length; j++) {
            // 取出每个元素的个位的值
            int digitOfElement = arr[j] / 1 % 10;
            bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[j];
            bucketElementCounts[digitOfElement]++;
        }

        // 按照这个桶的顺序(一位数组的下标 取出数据,放入原理的数据)
        int index = 0;
        for (int k = 0; k < bucketElementCounts.length; k++) {
            // 如果桶中有数据 才放入到原数组
            if (bucketElementCounts[k] != 0) {
                // 循环该桶 即第K个桶 放入
                for (int l = 0; l < bucketElementCounts[k]; l++) {
                    arr[index] = bucket[k][l];
                    index++;
                }
            }
            // 第1轮处理后,需要将每个bucketElementCounts[k] = 0 清零
            bucketElementCounts[k] = 0;
        }
        // [542, 3, 14, 214, 58, 748]
        System.out.println("第一轮结果" + Arrays.toString(arr));

        // 第2轮 (针对每个元素的个位进行排序处理)
        for (int j = 0; j < arr.length; j++) {
            // 取出每个元素的十位的值
            int digitOfElement = arr[j] / 10 % 10;
            bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[j];
            bucketElementCounts[digitOfElement]++;
        }

        // 按照这个桶的顺序(一位数组的下标 取出数据,放入原理的数据)
        index = 0;
        for (int k = 0; k < bucketElementCounts.length; k++) {
            // 如果桶中有数据 才放入到原数组
            if (bucketElementCounts[k] != 0) {
                // 循环该桶 即第K个桶 放入
                for (int l = 0; l < bucketElementCounts[k]; l++) {
                    arr[index] = bucket[k][l];
                    index++;
                }
            }
            bucketElementCounts[k] = 0;
        }
        // [3, 14, 214, 542, 748, 58]
        System.out.println("第二轮结果" + Arrays.toString(arr));

        // 第3轮 (针对每个元素的个位进行排序处理)
        for (int j = 0; j < arr.length; j++) {
            // 取出每个元素的百位的值
            int digitOfElement = arr[j] / 100 % 10;
            bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[j];
            bucketElementCounts[digitOfElement]++;
        }

        // 按照这个桶的顺序(一位数组的下标 取出数据,放入原理的数据)
        index = 0;
        for (int k = 0; k < bucketElementCounts.length; k++) {
            // 如果桶中有数据 才放入到原数组
            if (bucketElementCounts[k] != 0) {
                // 循环该桶 即第K个桶 放入
                for (int l = 0; l < bucketElementCounts[k]; l++) {
                    arr[index] = bucket[k][l];
                    index++;
                }
            }
            bucketElementCounts[k] = 0;
        }
        // [3, 14, 58, 214, 542, 748]
        System.out.println("第三轮结果" + Arrays.toString(arr));
    }

 5 通过循环实现基数排序(桶排序)

 1　　 public static void main(String[] args) {
        int[] arr = { 58, 3, 542, 748, 14, 214 };
        radixSort2(arr);
　　}
　　public static void radixSort2(int[] arr) {
        // 1 得到数组中最大的数的位数
        int max = arr[0];// 假设第一位就是最大数
        for (int i = 1; i < arr.length-1; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }
        // 2 得到最大数是几位数
        int maxLength = (max + "").length();

        int[][] bucket = new int[10][arr.length];
        int[] bucketElementCounts = new int[10];

        for (int i = 0,n = 1; i < maxLength; i++,n *= 10) {
            for (int j = 0; j < arr.length; j++) {
                // 取出每个元素的个位的值
                int digitOfElement = arr[j] / n % 10;
                bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[j];
                bucketElementCounts[digitOfElement]++;
            }

            // 按照这个桶的顺序(一位数组的下标 取出数据,放入原理的数据)
            int index = 0;
            for (int k = 0; k < bucketElementCounts.length; k++) {
                // 如果桶中有数据 才放入到原数组
                if (bucketElementCounts[k] != 0) {
                    // 循环该桶 即第K个桶 放入
                    for (int l = 0; l < bucketElementCounts[k]; l++) {
                        arr[index] = bucket[k][l];
                        index++;
                    }
                }
                // 第1轮处理后,需要将每个bucketElementCounts[k] = 0 清零
                bucketElementCounts[k] = 0;
            }
            //System.out.println("第" + i + "次排序结果为" + Arrays.toString(arr));
        }
    }

6 时间复杂度

7 时间复杂度测试

// 基数(桶)排序
    public static void main(String[] args) {
        speedTest(80000);
    }

    /**
       * 创建一个随机数组 然后调用排序方法 得到时间
     * 
     * @param number 创建的随机数组个数
     */
    public static void speedTest(int number) {
        int[] arr = new int[number];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int) (Math.random() * 800000);
        }

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

        // 调用上面的基数排序方法
        radixSort2(arr);

        Date date2 = new Date();
        String time2 = simpleDateFormat.format(date2);
        System.out.println("排序后的时间为:" + time2);
    }

时间复杂度测试结果

8万个数据测试结果大约不需要1秒

80万个数据测试结果大约不需要1秒

 800万个数据测试结果大约不需要1秒

8000万个数据测试结果会超出虚拟机内存  因为基数排序是典型的拿空间换时间的排序