桶排序
核心思想是将要排序的数据分到几个有序的桶里，每个桶里的数据再单独进行排序。桶内排完序之后，再把每个桶里的数据按照顺序依次取出，组成的序列就是有序的了。
如果要排序的数据有 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) 的排序算法了。
适合使用：
桶排序比较适合用在外部排序中。所谓的外部排序就是数据存储在外部磁盘中，数据量比较大，内存有限，无法将数据全部加载到内存中。
计数排序
计数排序其实是桶排序的一种特殊情况。当要排序的 n 个数据，所处的范围并不大的时候，比如最大值是 k，我们就可以把数据划分成 k 个桶。每个桶内的数据值都是相同的，省掉了桶内排序的时间。
考生的满分是 900 分，最小是 0 分，这个数据的范围很小，所以我们可以分成 901 个桶，对应分数从 0 分到 900 分。根据考生的成绩，我们将这 50 万考生划分到这 901 个桶里。桶内的数据都是分数相同的考生，所以并不需要再进行排序。我们只需要依次扫描每个桶，将桶内的考生依次输出到一个数组中，就实现了 50 万考生的排序。因为只涉及扫描遍历操作，所以时间复杂度是 O(n)。
总结：
计数排序只能用在数据范围不大的场景中，如果数据范围 k 比要排序的数据 n 大很多，就不适合用计数排序了。而且，计数排序只能给非负整数排序，如果要排序的数据是其他类型的，要将其在不改变相对大小的情况下，转化为非负整数。
下面是用go实现的桶排序的算法，计数和桶排序应该是差不多的。
//我在这里实现的是最简单的计数排序，应该是不稳定的
func jisort(arr []int)[]int {
var res []int //这里需要注意一下，如果使用的是make([]int,len(arr))的话
//那么结果就会多一些0，因为这样直接写的话，初始化就把位置上的值默认为了0
t :=make([]int,len(arr))
for _,val :=range arr {
t[val]++
}
for index,v := range t {
for ; v > 0 ; v-- {
res = append(res,index)
}
}
return res
}
下面是第二种：
//上面是一个最简单的实践的方法，但是很方便我们去理解，它是不稳定，下面我们实现稳定的计数排序，并且下面的基数排序也会用到这个点
func jiSort(arr []int) []int {
// 数组长度
length := len(arr)
// 统计长度 0~9
bitCounts := make([]int, 10)
num:=0
for i := 0; i < length; i++ {
num =arr[i]
bitCounts[num]++
}
// 叠加（目的是增加稳定性）
// 原来是0~9，现在变成描述0~9的累加数量，这样就可以很方便的知道最终的坐标
for j := 1; j < len(bitCounts); j++ {
bitCounts[j] += bitCounts[j-1]
}
// 临时数组
res := make([]int, length)
// 将原来的数组倒序遍历一遍
for i := length - 1; i >= 0; i-- {
num = arr[i]
res[bitCounts[num]-1] = arr[i]
// 统计余数相等的个数，进行递减
bitCounts[num]--
}
return res
}
基数排序
基数排序是一种非比较型整数排序算法，其原理是将整数按位数切割成不同的数字，然后按每个位数分别比较。由于整数也可以表达字符串（比如名字或日期）和特定格式的浮点数，所以基数排序也不是只能使用于整数。
基数排序对数据的要求 基数排序对要排序的数据是有要求的，需要可以分割出独立的“位”来比较，而且位之间有递进的关系，如果 a 数据的高位比 b 数据大，那剩下的低位就不用比较了。除此之外，每一位的数据范围不能太大，要可以用线性排序算法来排序，否则，基数排序的时间复杂度就无法做到 O(n) 了。
func RadixSort(arr []int) []int {
// 最大值，确定数量级
max, _ := selectSort.SelectSortMax(arr)
// 按照数量级分段
for bit := 1; max/bit > 0; bit *= 10 {
// 每次处理一个级别的排序
arr = bitSort(arr, bit)
}
return arr
}
// 按照位数排序
func bitSort(arr []int, bit int) []int {
// 数组长度
length := len(arr)
// 统计长度 0~9
bitCounts := make([]int, 10)
for i := 0; i < length; i++ {
// 余数
num := (arr[i] / bit) % 10
// 统计余数相等的个数，进行递增
bitCounts[num]++
}
// 叠加（目的是增加稳定性）
// 原来是0~9，现在变成描述0~9的累加数量，这样就可以很方便的知道最终的坐标
for j := 1; j < len(bitCounts); j++ {
bitCounts[j] += bitCounts[j-1]
}
// 临时数组
res := make([]int, length)
// 将原来的数组倒序遍历一遍
for i := length - 1; i >= 0; i-- {
// 余数
num := (arr[i] / bit) % 10
res[bitCounts[num]-1] = arr[i]
// 统计余数相等的个数，进行递减
bitCounts[num]--
}
return res
}
