计数排序

计数排序是一个非基于比较的排序算法。它的优势在于对一定范围内的整数排序时，它的复杂度为$O(n+k)$（其中k是整数的范围），快于任何比较排序算法。当然，这是一种牺牲空间换取时间的做法，而且当$O(k)>O(nlogn)$的时候其效率反而不如基于比较的排序。

基本思路

1. 找出原数组中最大的元素，即为max
2. 创建一个新的数组count_list，其长度是max+1，其元素默认值都为0
3. 遍历原数组中的元素，以原数组中的元素作为count_list数组的索引，以原数组中的元素出现的次数作为count_list中的元素值。
4. 创建结果数组result，遍历count_list，找出其中元素值大于0的元素，将其对应的索引作为元素值填充到result数组中，每处理一次，count中的该元素值应减一，直到该元素值不大于0。
5. 返回结果数组result

基础代码实现

def countSort(arr):
    max_num = max(arr)
    count_list = [0] * (max_num+1)
    for i in arr:
        count_list[i] += 1
    
    result = []
    for i, j in enumerate(count_list):
        while j != 0:
            result.append(i)
            j -= 1

    return result

if __name__ == "__main__":
    arr = [3,6,8,4,2,6,7,3,0]
    res = countSort(arr)
    print(res)

优化一

以上的代码实现能够解决一般的情况，但是有个缺点，就是存在浪费空间的问题。设想如果一个长度为10的数组最大值为99，其最小值为90。按照上面的方式，得创建一个长度为100的数组，但实际上真正使用到的空间只有后面的90-99。这样就浪费了前面0-89的空间了。因此不能再用这样的方式来判断计数数组的长度。我们使用原数组中最大值-最小值+1作为计数数组的长度，这样就可以有效地减少不必要的空间。注意在使用原数组的值来作为计数数组的索引时要先减去最小值再来当计数数组的索引。

代码实现

def countSort(arr):
    max_num = max(arr)
    min_num = min(arr)
    count_list = [0] * (max_num - min_num + 1)
    # 对计数数组中的各个元素赋值，注意需要数组arr中的元素减去最小值再当作计数数组的索引
    for i in arr:
        count_list[i - min_num] += 1

    result = []
    for i, j in enumerate(count_list):
        while j != 0:
            result.append(i + min_num)
            j -= 1
    
    return result

if __name__ == "__main__":
    arr = [3,6,8,4,2,6,7,3,0]
    res = countSort(arr)
    print(res)

优化二

以上的优化已经适用于大部分情况了，但上面的代码实现的计数排序属于不稳定排序。举个例子，在现实业务中，我们可能需要对学生的分数进行排名，而分数有时候会有同分的情况，对于上面的代码，它只能够记录有两个一样的分数，而不能真正区分哪个排在前，哪个排在后。

name	score
A	90
B	99
C	95
D	94
E	95

如上面的一份成绩表，按以上的代码实现的话，计数数组中的数据会是这样的：

1	0	0	0	1	2	0	0	0	1
0	1	2	3	4	5	6	7	8	9

索引为5的位置上元素值为2，即有两个相同的分数，可以看出这里仅仅只是记录了有两个相同的分数，至于哪个是C的成绩哪个是E的成绩并不清楚。
我们可以这样来解决，从计数数组中的第2个元素开始，每个元素都加上前面所有元素之和，这样相加的目的是让统计数组存储得元素值等于相应整数的最终排序位置的序号。变型之后的统计数组如下：

1	0+1	0+1	0+1	1+1	2+2	0+4	0+4	0+4	1+4
0	1	2	3	4	5	6	7	8	9

例如下标是9的元素值为5，代表原始数列的整数9，最终的排序在第5位。再例如下标是5的元素值为4，代表原始数列的整数5，最终排序在第4位，然后将4-1=3，即下次再遇到相同整数时，其最终排序在第3位。以此类推。

代码实现：

def countSort(arr):
    max_num = max(arr)
    min_num = min(arr)
    count_list = [0] * (max_num - min_num + 1)
    # 对计数数组中的各个元素赋值
    for i in arr:
        count_list[i - min_num] += 1
    # 统计数组变形，从第二个元素开始加上前面的元素之和
    for i in range(1,len(count_list)):
        count_list[i] += count_list[i-1]
    
    result = [0] * len(arr)

    for i in range(len(arr)-1,-1,-1):
        # 因为数组中下标从0开始，所以这里result的下标需要-1
        result[count_list[arr[i]-min_num]-1] = arr[i]
        count_list[arr[i]-min_num] -= 1

    return result

if __name__ == "__main__":
    arr = [3,6,8,4,2,6,7,3,1]
    res = countSort(arr)
    print(res)

复杂度分析

• 时间复杂度：$O(n+m)$，n为原始数组长度，m为计数数组长度。
• 空间复杂度：$O(n+m)$，n为结果数组的长度，m为计数数组长度。如果不计结果数组，则复杂度为$O(m)$