基数排序模板

基础概念

不了解概念的话参考：

OI Wiki：基数排序
菜鸟教程：基数排序

基数排序是桶思想排序的一种。

基数排序分：

LSD（Least Significant Digit first）低位优先（以下只围绕 LSD 展开）。
MSD（Least Significant Digit first）高位优先。

针对于 MSD 理解上没有 LSD 直观，所以下文只分析 LSD。

核心思想

将要排序的元素按一定规则分桶（桶是有序的），通过从低位到高位循环入桶和出桶实现最终排序。

基数排序能实现排序的关键在于：桶是有序的，入桶和出桶是有序的。

核心步骤

先按最低位分桶。（桶之间是有序的，放入也是有序的）
依次从桶中取出元素排列出来。（桶中取数据也是有序的）
变换 1 步骤的次低位循环 1~2 步，直到最高位完成。

复杂度

要分桶，分桶个数为基数范围的个数，如 0~9 为 10 个，a~z 为 26 个（常数）。
每个桶中的元素数量不固定，所有桶的所有元素个数为 n。
放桶和从桶中取都是基于元素个数的，所以操作次数也为 n 次。

由上，所以，空间复杂度为 O(n)，时间复杂度为 O(n)，代码上该如何设计呢？

注意：桶思想排序是 O(n) 复杂度的，如果题目中需要 O(n) 复杂度实现排序，应该就要想到桶思想（桶排序、计数排序、基数排序）。

设计考虑

有以下几点考虑：

分桶方法。
桶是有序的。（这个不用多说）
向桶中放数据和取数据是有序的（LSD 下必须是 FIFO 的，才能保证最终排序）。

针对于第一条可能会想到用二维切片来实现，同样看第三条正好每个桶对应一个切片会很合适。
但由于桶内元素是伸缩变化的，如果每个桶用单独的切片来存的话，底层空间的使用量不好控制。

所以可以这样设计：

新分配出和原数列一样长度的空间作为 buf
按 buf 的范围区间进行切分桶
FIFO 的放桶取桶顺序可以用下标来控制

代码步骤（LSD）

以对一个数值数组进行排序为例，主要逻辑：

循环数列找到最大数，根据数位个数确定循环次数
从低位开始执行下方步骤
循环原数组，每个元素计算桶号，计数对应桶容量 cnt （注意在下一次循环之间重置）
确定各个桶在 buf 数组上的区间范围（buf 是原数组的一个等空间数组）
循环原数组，依次计算桶号，并放入 buf 对应桶内
替换 buf 和原数组，跳转到 2 步骤开始下一次循环

在第 4 步中获得 buf 中每个桶的最末位置比较容易，所以在第 5 步中从桶的后面向前放元素比较容易

上面的逻辑太细，以至于不好记，记下面的流程（啰嗦一下）：

确定循环次数
在同等空间的数列上划分桶（包含计数及切分区间）
再循环原数组，依次将对应桶数据放入桶（注意顺序）
进行下次循环

注意：不要想着把好几个 for range nums 的循环合并成 1 个，因为这里多少个 n 次的循环是个常数量，所以量级还是 O(n)。

go 代码实现

（当前此模板只支持正数，可进行正负分类去做）

func sortByRadix(nums []int) []int {
    n := len(nums)

    maxVal := getMax(nums...)                  // 获取最大值，用于计算循环次数
    times := 0                                 // 循环次数（最大数值的位数）
    for temp := maxVal; temp > 0; temp /= 10 { // 计算循环次数
        times++
    }

    buf := make([]int, n) // 容器 buf，用于存储每次循环后的元素顺序状态
    division := 1         // 除数，用于计算当前基数值
    cnt := [10]int{}      // 桶标号 => 前期存计数，后期作为对应桶末尾位置的偏移量

    // 核心逻辑，按次数循环
    for i := 1; i <= times; i++ {

        // 计算每个桶内元素的数量
        for _, num := range nums {
            b := (num / division) % 10
            cnt[b]++
        }

        // 转换为桶末尾在这个数列的偏移位置
        for j := 1; j < 10; j++ {
            cnt[j] += cnt[j-1]
        }

        // 将桶内元素依次放回 buf 对应位置
        for j := len(nums) - 1; j >= 0; j-- {
            b := (nums[j] / division) % 10
            cnt[b]--
            buf[cnt[b]] = nums[j]
        }

        // 重置 cnt
        for j := 0; j < 10; j++ {
            cnt[j] = 0
        }

        division *= 10
        nums, buf = buf, nums
    }

    return nums
}

func getMax(a ...int) int {
    max := a[0]
    for _, v := range a[1:] {
        if v > max {
            max = v
        }
    }
    return max
}

// 做第二道题时，再次调整了一下逻辑，代码相同
func radixSort(nums []int) {
    n := len(nums)
    if n <= 1 {
        return
    }

    max := nums[0]// 最大值
    for _, num := range nums[1:] {
        if max < num {
            max = num
        }
    }
    times := 0 // 循环次数
    for max > 0 {
        max /= 10
        times++
    }

    bCnt := [10]int{}
    division := 1
    buf := make([]int, n)
    for t := 1; t <= times; t++ {
        // 重置 bCnt
        for i := 0; i < len(bCnt); i++ {
            bCnt[i] = 0
        }
        // 桶内元素计数
        for _, num := range nums {
            b := num / division % 10
            bCnt[b]++
        }
        // 前缀和，转为偏移量
        for i := 1; i < len(bCnt); i++ {
            bCnt[i] += bCnt[i-1]
        }

        // 放桶，从后往前取 nums 数，从后往前放 buf 内的桶
        for i := n - 1; i >= 0; i-- {
            b := nums[i] / division % 10
            bCnt[b]--
            buf[bCnt[b]] = nums[i]
        }

        // 更新到原数组
        copy(nums, buf)

        division *= 10
    }
}

力扣练习

164. 最大间距（题解）
912. 排序数组（题解：基数排序练习）