基础算法----计数排序(Counting Sort)

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

一 算法简介

计数排序是将待排序序列中的元素作为索引存储在额外的数组空间中，而该元素的出现的次数作为值存储在数组空间中，通过遍历额外的数组排序

计数排序不是一个基于比较的排序算法，是一个以空间换时间的算法

局限性：
1) 由于计数排序需要创建长度为k(待排序序列的最大值)的数组，k过大场景严重浪费了空间，时间复杂度也随之升高
2) 由于计数排序是根据原序列的元素作为新数组的索引来存放，数组索引只能是整数。 所以当待排序序列的元素不是整数时，计数排序并不适用

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

一) 时间复杂度

时间复杂度是T(n) = O(n+k)
其中
n：序列中元素个数
k：待排序序列的最大值

基于比较的排序的时间复杂度在理论上的下限是O(nlog₂n)
当O(k)<O(nlog₂n)时，快于任何比较排序算法
当O(k)>O(nlog₂n)时，效率不如比较排序算法

二) 空间复杂度

需要额外申请空间数组，所以空间复杂度是 S(n) = O(k)
其中
k：待排序序列的最大值

三 算法稳定性

相同的元素的相对次序不会改变，计数排序是一种稳定的排序算法

四 实现

一) 步骤

1) 根据待排序序列中的最大元素，申请额外空间
2) 遍历待排序序列，将待排序序列中每一个元素的值作为索引，元素出现的次数作为值，记录到申请的额外空间中
3) 遍历额外空间中的数据，重新排序

二) 过程图

使用 {4, 3, 5, 4, 2, 6, 1, 7, 3, 10} 演示从小到大的排序过程

三) 代码实现

func CountingSort(arr []int) {
 
    maxValue := 0
    length := len(arr)
    //获取最大值
    for i := 0; i < length; i++ {
        if arr[i] > maxValue {
            maxValue = arr[i]
        }
    }
 
 	//把元素和元素出现的次数分配到对应的位置
    countArr := make([]int, maxValue+1)
    for i := 0; i < length; i++ {
        countArr[arr[i]] += 1
    }
 
 	//重新排序
    for i, j := 0, 0; i <= maxValue; i++ {
        for countArr[i] > 0 {
            arr[j] = i
            j++
            countArr[i]--
        }
    }
 
    return
}