基础算法----基数排序(Radix Sort)

算法稳定性，时间复杂度，空间复杂度等算法基础知识： 经典算法----基础知识
冒泡排序： 基础算法----冒泡排序
选择排序： 基础算法----选择排序
插入排序： 基础算法----插入排序
快速排序： 基础算法----快速排序
希尔排序： 基础算法----希尔排序
归并排序： 基础算法----归并排序
计数排序： 基础算法----计数排序
桶排序： 基础算法----桶排序
基数排序： 基础算法----基数排序
堆排序： 基础算法----堆排序

一 算法简介

将所有待比较数值统一为同样的数位长度，数位较短的数前面补零，然后按位数依次比较

基数排序是一种以空间换时间的算法

最高位优先法(Most Significant Digit first,MSD)
从高位到低位依次比较排序

最低位优先法(Least Significant Digit first,LSD)
从低位到高位依次比较排序

二 时间复杂度，空间复杂度

一) 时间复杂度

基数排序的时间复杂度为：T(n) = O(k(n+r)) = O(k*n)

其中：
k：最高位数
n：序列中的元素个数
r：基数，即存放元素的桶的数量。如基数为10，即10进制，即最多需要10个桶来存放序列中的元素
根据最高位数共进行k次分配和重新排序，每一次分配时间复杂度：O(n)，每一次重新排序时间复杂度：O(r)

二)空间复杂度

基数排序的空间复杂度为 S(n) = O(n+r)

其中：
n：序列中的元素个数
r：基数，即存放元素的桶的数量

三 算法稳定性

基数排序是一种稳定的排序算法

四 实现

一) 步骤

1) 获取待排序列中所有元素的最大值，最高位数就是最大值的位数
2) 从最低位开始，依次进行排序
3) 重复步骤2)，直到最高位排序完成

二) 过程图

使用 {41, 30, 53, 6, 22, 601, 1, 774, 3180, 1369} 演示从低位到高位的从小到大顺序排序过程

最大值3180，最高位为千位，总共按位比较4次

1) 个位

2) 十位

3) 百位

4) 千位

三) 代码实现

func RadixSort(arr []int) {

	if len(arr) <= 1 {
		return
	}

	//获取最大值
	maxValue := arr[0]
	for i := 1; i < len(arr); i++ {
		if arr[i] > maxValue {
			maxValue = arr[i]
		}
	}

	//每位有十个桶来存储元素
	bucketCount := 10
	//最大值的位数控制比较次数
	for n := 1; maxValue/n > 0; n *= bucketCount {
		//按位把元素分配到对应的桶
		bucketArr := make([][]int, bucketCount)
		for i := 0; i < len(arr); i++ {
			bucketIndex := (arr[i] / n) % bucketCount
			if len(bucketArr[bucketIndex]) == 0 {
				bucketArr[bucketIndex] = make([]int, 0)
			}
			bucketArr[bucketIndex] = append(bucketArr[bucketIndex], arr[i])
		}
		
		//按位重新排序
		for i, j := 0, 0; i < len(tmpArr); i++ {
			for _, val := range tmpArr[i] {
				arr[j] = val
				j++
			}
		}
	}

	return
}