go实现桶排序，基数排序，计数排序

桶排序和计数排序
实现原理: 这里直接说一个例子，更容易理解，就是我们要把一百万个数进行排序，我们可以先把这些数分组到一个一个桶里面，如果数都是随机的，比如说范围是1到无限大，那么这个时候我们就需要自己设一点范围，比如1到一万，一万到千万～～将这些数分到桶里之后，我们只需要将桶里面的数进行排序，里面的数排序完之后，拿出来就直接都是排好序了的。

我在查资料的时候发现，计数排序就是桶排序的简单版本，例子： 我要查一百万个人的分数，那么我们的分数只有1到100，那么我们可以给每一个分数都划为一个桶，这个时候，就是计数排序

//我在这里实现的是最简单的计数排序，应该是不稳定的
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
}

桶排序的复杂度：n+k（k是他的数据范围）
它是一个稳定的排序算法

计数排序的复杂度是：n
它是一个稳定的排序算法

基数排序:
有的时候，我们可能会为电话号码排序，可能会为一段英文字符排序，那么这个时候，我们就需要使用到基数排序。例子：
当我们给3位数数字排序的时候，可以先给最后一个位置排序，再给前面一个的位置排序，一直到这个数排序完，那么这里的基数排序，实际上就是用计数排序作为排序的方法

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
}

基数排序的时间复杂度：k(n+m)
空间复杂度为：n+m
它是一个稳定的排序算法