三种时间复杂度是 O(n) 的排序算法：桶排序、计数排序、基数排序。因为这些排序算法的时间复杂度是线性的，所以我们把这类排序算法叫作线性排序（Linear sort）。之所以能做到线性的时间复杂度，主要原因是，这三个算法是非基于比较的排序算法，都不涉及元素之间的比较操作。
桶排序（Bucket sort）
首先，我们来看桶排序。桶排序，顾名思义，会用到“桶”，核心思想是将要排序的数据分到几个有序的桶里，每个桶里的数据再单独进行排序。桶内排完序之后，再把每个桶里的数据按照顺序依次取出，组成的序列就是有序的了。
桶排序的时间复杂度为什么是 O(n) 呢？我们一块儿来分析一下。
如果要排序的数据有 n 个，我们把它们均匀地划分到 m 个桶内，每个桶里就有 k=n/m 个元素。每个桶内部使用快速排序，时间复杂度为 O(k * logk)。m 个桶排序的时间复杂度就是 O(m * k * logk)，因为 k=n/m，所以整个桶排序的时间复杂度就是 O(n*log(n/m))。当桶的个数 m 接近数据个数 n 时，log(n/m) 就是一个非常小的常量，这个时候桶排序的时间复杂度接近 O(n)。
桶排序看起来很优秀，那它是不是可以替代我们之前讲的排序算法呢？
答案当然是否定的。为了让你轻松理解桶排序的核心思想，我刚才做了很多假设。实际上，桶排序对要排序数据的要求是非常苛刻的。
首先，要排序的数据需要很容易就能划分成 m 个桶，并且，桶与桶之间有着天然的大小顺序。这样每个桶内的数据都排序完之后，桶与桶之间的数据不需要再进行排序。
其次，数据在各个桶之间的分布是比较均匀的。如果数据经过桶的划分之后，有些桶里的数据非常多，有些非常少，很不平均，那桶内数据排序的时间复杂度就不是常量级了。在极端情况下，如果数据都被划分到一个桶里，那就退化为 O(nlogn) 的排序算法了。
桶排序比较适合用在外部排序中。所谓的外部排序就是数据存储在外部磁盘中，数据量比较大，内存有限，无法将数据全部加载到内存中。
计数排序（Counting sort）
计数排序其实是桶排序的一种特殊情况。当要排序的 n 个数据，所处的范围并不大的时候，比如最大值是 k，我们就可以把数据划分成 k 个桶。每个桶内的数据值都是相同的，省掉了桶内排序的时间。
计数排序的算法思想就是这么简单，跟桶排序非常类似，只是桶的大小粒度不一样。不过，为什么这个排序算法叫“计数”排序呢？“计数”的含义来自哪里呢？
想弄明白这个问题，我们就要来看计数排序算法的实现方法。我还拿考生那个例子来解释。为了方便说明，我对数据规模做了简化。假设只有 8 个考生，分数在 0 到 5 分之间。这 8 个考生的成绩我们放在一个数组 A[8] 中，它们分别是：2，5，3，0，2，3，0，3。
考生的成绩从 0 到 5 分，我们使用大小为 6 的数组 C[6] 表示桶，其中下标对应分数。不过，C[6] 内存储的并不是考生，而是对应的考生个数。像我刚刚举的那个例子，我们只需要遍历一遍考生分数，就可以得到 C[6] 的值。
下面我们在创建大小的为6的数组D[6]，跟C[6]一样，下标代表分数，而存储的值是分数对应的排序后数组的索引，D[6]中的值，是根据C[6]推算出来的。
再创建一个空数组E[8]，长度为原数组，作为存储排序后结果的数组。然后遍历原数组，根据E[D[分数]] = 分数，负值完D[分数]+1。遍历结束，排序就完成了。
代码如下：
func countSort(nums []int) []int {
min := nums[0]
max := nums[0]
//求出数组中的最大值和最小值
for _, item := range nums {
if item < min {
min = item
}
if item > max {
max = item
}
}
//求每个数字出现的次数
count := make([]int, max-min+1)
for _, item := range nums {
count[item-min]++
}
//计算每个值在新排序数组中的索引位置
countArr := make([]int, max-min+1)
for i, _ := range count {
if i == 0 {
countArr[i] = 0
} else {
countArr[i] = countArr[i-1] + count[i-1]
}
}
//生成新的数组
res := make([]int, len(nums))
for _, item := range nums {
idx := countArr[item-min]
res[idx] = item
//计算下一个索引位置
countArr[item-min]++
}
return res
}
这种算法的空间复杂度为n。
还有一种思路上比较简单的方法，但这种方法的空间复杂度为2n。
func countSort2(nums []int) []int {
min := nums[0]
max := nums[0]
//求出数组中的最大值和最小值
for _, item := range nums {
if item < min {
min = item
}
if item > max {
max = item
}
}
//将数据插入二维数组中
count := make([][]int, max-min+1)
for _, item := range nums {
count[item - min] = append(count[item - min], item)
}
//合并二维数组
res := make([]int, 0)
for _, item := range count {
res = append(res, item...)
}
return res
}
计数排序只能用在数据范围不大的场景中，如果数据范围 k 比要排序的数据 n 大很多，就不适合用计数排序了。而且，计数排序只能给非负整数排序，如果要排序的数据是其他类型的，要将其在不改变相对大小的情况下，转化为非负整数。
基数排序（Radix sort）
我们再来看这样一个排序问题。假设我们有 10 万个手机号码，希望将这 10 万个手机号码从小到大排序，你有什么比较快速的排序方法呢？
我们之前讲的快排，时间复杂度可以做到 O(nlogn)，还有更高效的排序算法吗？桶排序、计数排序能派上用场吗？手机号码有 11 位，范围太大，显然不适合用这两种排序算法。针对这个排序问题，有没有时间复杂度是 O(n) 的算法呢？现在我就来介绍一种新的排序算法，基数排序。
刚刚这个问题里有这样的规律：假设要比较两个手机号码 a，b 的大小，如果在前面几位中，a 手机号码已经比 b 手机号码大了，那后面的几位就不用看了。
根据每一位来排序，我们可以用刚讲过的桶排序或者计数排序，它们的时间复杂度可以做到 O(n)。如果要排序的数据有 k 位，那我们就需要 k 次桶排序或者计数排序，总的时间复杂度是 O(k*n)。当 k 不大的时候，比如手机号码排序的例子，k 最大就是 11，所以基数排序的时间复杂度就近似于 O(n)。
基数排序对要排序的数据是有要求的，需要可以分割出独立的“位”来比较，而且位之间有递进的关系，如果 a 数据的高位比 b 数据大，那剩下的低位就不用比较了。除此之外，每一位的数据范围不能太大，要可以用线性排序算法来排序，否则，基数排序的时间复杂度就无法做到 O(n) 了。
代码：
// 基数排序函数
func radixSort(arr []int) {
if len(arr) <= 1 {
return
}
// 获取数组中的最大值
maxVal := arr[0]
for _, num := range arr {
if num > maxVal {
maxVal = num
}
}
// 计算最大值的位数
maxDigit := int(math.Floor(math.Log10(float64(maxVal)))) + 1
// 初始化桶
buckets := make([][]int, 10)
for i := range buckets {
buckets[i] = make([]int, 0)
}
// 进行基数排序
for digit := 0; digit < maxDigit; digit++ {
// 分配元素到桶中
for _, num := range arr {
bucketIndex := getDigit(num, digit)
buckets[bucketIndex] = append(buckets[bucketIndex], num)
}
// 收集桶中的元素
index := 0
for _, bucket := range buckets {
for _, num := range bucket {
arr[index] = num
index++
}
// 清空桶
bucket = bucket[:0]
}
}
}
// 获取指定数字的指定位数的值
func getDigit(num, digit int) int {
divisor := int(math.Pow10(digit))
return (num / divisor) % 10
}
