数据结构与算法--第15篇（基数排序）

一，基数排序

1，简介：

基数排序： 分配式排序，又称桶子法，通过元素的个十百千等位的规则，将各个值元素分配至某些桶中，达到排序作用。基数排序属于稳定性排序（即相同值元素排序不改变原位置前后顺序）；
基数规则：

1. 将排序元素按照个十百千等规则，分别取出个十百千位的值；
2. 先按照个位，依次十百千位，位数不足在前补0；
3. 按照各值大小放到不同的桶中（数组中），相同的值按照原顺序从上到下放入；
4. 按照桶下标大小将桶的数据列出得到新的数组；
5. 个十百千位数后移，重复上述动作，直到完成排序；
6. 循环的次数由个十百千等位数决定，3位数就循环三次；
7. 定义10个二维数组作为桶；

图示：

2，代码实现：

package com.sort;

import java.util.Arrays;

/**
 * @param
 * @Author: AaNeei
 * @Date: 2019/6/17  20:56
 * @Description: 游学网
 * @throws:
 */
public class RadixSort {

    public static void main(String[] args) {
        int[] arr = {53, 3, 542, 748, 14, 214};
        sort(arr);
    }

    public static void sort(int[] arr) {
        //定义一个二维数组表示桶
        int[][] bucket = new int[10][arr.length];
        //定义一个一维数组记录每个桶元素个数
        int[] bucketElementCount = new int[10];

        for (int i = 0; i < length(arr); i++) {
            for (int j = 0; j < arr.length; j++) {
                int digitValue = arr[j] / ((int) Math.pow(10, i)) % 10;
                bucket[digitValue][bucketElementCount[digitValue]++] = arr[j];
            }
            //按照桶顺序取出
            int index = 0;
            for (int k = 0; k < bucket.length; k++) {
                //如果该桶中有元素
                if (bucketElementCount[k] != 0) {
                    for (int t = 0; t < bucketElementCount[k]; t++) {
                        arr[index++] = bucket[k][t];
                    }
                }
                //注意将bucketElementCount至为0
                bucketElementCount[k] = 0;
            }
            System.out.println(Arrays.toString(arr));
        }

    }

    public static int length(int[] arr) {
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (max < arr[i]) {
                max = arr[i];
            }
        }
        return (max + "").length();
    }
}

注：

1. 基数排序涉及到二维、一维数组，是典型的以时间换空间，速度快，但是如果数据量大的情况下，很容易出现OOM；
2. 如果数组有负数，就要考虑桶的下标负数问题，防止下标越界；