数据结构 [Java版本] 排序算法之 基数排序[桶排序]

基数排序(桶排序)介绍:

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

2.基数排序法是属于稳定性的排序，基数排序法的是效率高的稳定性排序法

3.基数排序(Radix Sort)是桶排序的扩展

4.基数排序是1887年赫尔曼·何乐礼发明的。它是这样实现的：将整数按位数切割成不同的数字，然后按每个位数分别比较。

基数排序基本思想

将所有待比较数值统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，依次进行一次排序。这样从最低位排序一直到最高位排序完成以后, 数列就变成一个有序序列。

这样说明，比较难理解，下面我们看一个图文解释，理解基数排序的步骤

基数排序

基数排序

基数排序

代码实现

package cn.icanci.datastructure.sort;

import java.util.Arrays;
import java.util.logging.Level;

/**
 * @Author: icanci
 * @ProjectName: AlgorithmAndDataStructure
 * @PackageName: cn.icanci.datastructure.sort
 * @Date: Created in 2020/3/7 13:37
 * @ClassAction: 基数排序
 */
public class RadixSort {
    public static void main(String[] args) {
        int[] arr = {53, 3, 542, 748, 14, 214};
//        radixSort(arr);
        radixSortEnd(arr);
        System.out.println(Arrays.toString(arr));
    }


    /**
     * 基数排序
     *
     * @param arr 需要排序的数组
     */
    public static void radixSortEnd(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();
        int[][] bucket = new int[10][arr.length];
        int[] bucketElementCounts = new int[10];
        for (int k = 0, n = 1; k < maxLength; k++, 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 i = 0; i < bucketElementCounts.length; i++) {
                //如果桶中国有数据 才放到原来的数组
                if (bucketElementCounts[i] != 0) {
                    //循环此桶
                    for (int j = 0; j < bucketElementCounts[i]; j++) {
                        //取出元素放到 arr
                        arr[index++] = bucket[i][j];
                    }
                }
                //第一轮 处理后 需要将每个 bucketElementCounts[i] = 0
                bucketElementCounts[i] = 0;
            }
        }

    }

    /**
     * 基数排序
     *
     * @param arr 需要排序的数组
     */
    public static void radixSort(int[] arr) {
        //第一轮(针对每个元素的个位 )
        //定义一个二维数组 表示十个桶 每个桶就是一个一维数组
        //1.二维数组 为了防止溢出 认为每个一维数组大小 arr.length
        //2.经典的空间换时间算法
        int[][] bucket = new int[10][arr.length];

        //为了记录每个桶实际存放了多少的数 所以需要记录一个一维数组来存储
        int[] bucketElementCounts = new int[10];
        //第一轮 针对每个元素的个位进行处理
        for (int j = 0; j < arr.length; j++) {
            //取出每个元素的个数
            int digitOfElement = arr[j] % 10;
            //放入到对应的桶中
            bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[j];
            bucketElementCounts[digitOfElement]++;
        }

        //按照桶的顺序取出数据放回原来数组
        int index = 0;
        for (int i = 0; i < bucketElementCounts.length; i++) {
            //如果桶中国有数据 才放到原来的数组
            if (bucketElementCounts[i] != 0) {
                //循环此桶
                for (int j = 0; j < bucketElementCounts[i]; j++) {
                    //取出元素放到 arr
                    arr[index++] = bucket[i][j];
                }
            }
            //第一轮 处理后 需要将每个 bucketElementCounts[i] = 0
            bucketElementCounts[i] = 0;
        }
        System.out.println(Arrays.toString(arr));

        //第一轮 针对每个元素的个位进行处理
        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 i = 0; i < bucketElementCounts.length; i++) {
            //如果桶中国有数据 才放到原来的数组
            if (bucketElementCounts[i] != 0) {
                //循环此桶
                for (int j = 0; j < bucketElementCounts[i]; j++) {
                    //取出元素放到 arr
                    arr[index++] = bucket[i][j];
                }
            }
            //第一轮 处理后 需要将每个 bucketElementCounts[i] = 0
            bucketElementCounts[i] = 0;
        }
        System.out.println(Arrays.toString(arr));

        //第一轮 针对每个元素的个位进行处理
        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 i = 0; i < bucketElementCounts.length; i++) {
            //如果桶中国有数据 才放到原来的数组
            if (bucketElementCounts[i] != 0) {
                //循环此桶
                for (int j = 0; j < bucketElementCounts[i]; j++) {
                    //取出元素放到 arr
                    arr[index++] = bucket[i][j];
                }
            }
            //第一轮 处理后 需要将每个 bucketElementCounts[i] = 0
            bucketElementCounts[i] = 0;
        }
        System.out.println(Arrays.toString(arr));
    }
}

打印

[3, 14, 53, 214, 542, 748]

测试八百万数据

public class RadixSort {
    public static void main(String[] args) {
        int[] numberArray = GetNumberArray.getNumberArray(8000000);
        long start = System.currentTimeMillis();
        radixSortEnd(numberArray);
        System.out.println(System.currentTimeMillis() - start + ":ms");
    }
}

测试结果

704:ms

基数排序的说明:

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