分配排序之"计数排序"

    假设,有20个随机整数,取值范围是0到10,需要对其排序。可能第一反应是使用快速排序啊,快排的时间复杂度是O(nlog n)!但是,可不可以比O(nlog n)更快呢?这就是这篇文章要介绍的计数排序(从名字上来看,就是计算数字出现频次的排序方法,非常的见名知意)。

计排的实现

  因为取值范围是0到10(整数的值在0,1,2,3,4,5,6,7,8,9,10里),共有11个数值,所以需要11个坑,我们定义一个长度是12的数组array,每个元素的初始值是0,然后对20个随机整数进行循环,对应的元素值加1。最后,输出array,就是排好序的。

  比如有20个整数,分别是 9,2,8,5,1,8,6,9,5,8,1,5,8,3,4,7,0,6,2,10

  初始化数组array

数组下标 0 1 2 3 4 5 6 7 8 9 10
频率 0 0 0 0 0 0 0 0 0 0 0

  要排序的随机整数,第一个值是9,那数组下标是9的分布值加1,所以array变成

数组下标 0 1 2 3 4 5 6 7 8 9 10
频率 0 0 0 0 0 0 0 0 0 1 0

  第二个值是2,数组下标是2的分布值加1

数组下标 0 1 2 3 4 5 6 7 8 9 10
频率 0 0 1 0 0 0 0 0 0 1 0

  后面的以此类推。最终输出array,元素的值是几,就输出几次。这个数组显然是有序的了。   

数组下标 0 1 2 3 4 5 6 7 8 9 10
频率 1 2 2 1 1 3 2 1 4 2 1

  代码如下

def sort(array):
    # 1.获取数组内的最大值和最小值,来确定数组的size
    max = array[0]
    min = array[0]
    for i in array:
        if i > max:
            max = i
        if i < min:
            min = i

    # 2.定义定长数组,数组的元素初始值是0(这里偷懒使用了列表生成式)
    sort_array = [0 for i in range(max - min + 1)]

    # 3.计数
    for i in array:
        sort_array[i - min] = sort_array[i - min] + 1

    # 4.获得排序后的数组
	sortArray = [0 for i in array]
	index = 0
	for i, value in enumerate(countArray):
		for j in range(1, value + 1):
			sortArray[index] = i + min
			index = index + 1
	return sortArray

if __name__ == "__main__":
    array = [9, 2, 8, 5, 1, 8, 6, 9, 5, 8, 1, 5, 8, 3, 4, 7, 0, 6, 2, 10]
    sort_array = sort(array)
    print(sort_array)

  下面是输出结果

[0, 1, 1, 2, 2, 3, 4, 5, 5, 5, 6, 6, 7, 8, 8, 8, 8, 9, 9, 10]

Process finished with exit code 0

  从代码实现来看,也不复杂,甚至很简单。

优化版的计排

  上面的算法,因为有一个双重fou循环,还可以在优化下。

  假设考试是十分制的,共有20个同学,同学的考试成绩是上面的那20个数(9, 2, 8, 5, 1, 8, 6, 9, 5, 8, 1, 5, 8, 3, 4, 7, 0, 6, 2, 10),考试获得9分的有两个同学,那到底谁是第二、谁是第三呢?

上面的表格,需要升级一下,频率一栏,需要变成“分布值”了,它的值是上一格的值和自身的值之和

数组下标 0 1 2 3 4 5 6 7 8 9 10
分布值 1 3(1+2) 5(3+2) 6(5+1) 7(6+1) 10(7+3) 12(10+2) 13(12+1) 17(13+4) 19(17+2) 20(19+1)

然后对分布值数组输出,第一个是下标10的,遍历之后分布值表格的下标10的分布值就减1,它是第一名(总人数-分布值+1)

数组下标 0 1 2 3 4 5 6 7 8 9 10
分布值 1 3 5 6 7 10 12 13 17 19 19(20-1)

假如获得9分的是张三和李四,遍历张三之后,表格下标9的值减1,它是第二名(2 = 20-19 +1)

数组下标 0 1 2 3 4 5 6 7 8 9 10
分布值 1 3 5 6 7 10 12 13 17 18(19-1) 19

李四是第三名(3 = 20 -18 + 1)

数组下标 0 1 2 3 4 5 6 7 8 9 10
分布值 1 3 5 6 7 10 12 13 17 17(18-1) 19

这样的话,相同分数的同学,就分出分数排名了。

def sort2(array):
    # 1.获取数组内的最大值和最小值,来确定数组的size
    max = array[0]
    min = array[0]
    for i in array:
        if i > max:
            max = i
        if i < min:
            min = i

    # 2.定义定长数组,数组的元素初始值是0(这里偷懒使用了列表生成式)
    countArray = [0 for i in range(max - min + 1)]

    # 3.计数
    for i in array:
        countArray[i - min] = countArray[i - min] + 1

    # 4.计数的数组变形
    sum = 0
    for i,value in enumerate(countArray):
        sum = sum + value
        countArray[i] = sum

    # 5.获得排序后的数组
    sortArray = [0 for i in array]
    for i in array:
        sortArray[countArray[i - min] - 1] = i
        countArray[i - min] = countArray[i - min] - 1

    return sortArray


if __name__ == "__main__":
    array = [9, 2, 8, 5, 1, 8, 6, 9, 5, 8, 1, 5, 8, 3, 4, 7, 0, 6, 2, 10]
    sort_array = sort2(array)
    print(sort_array)

复杂度

  假设array元素有N个,取值范围是M。

时间复杂度:3N(步骤1、步骤3、步骤5) + M(步骤4),去掉系数,时间复杂度是O(N+M)

空间复杂度:只考虑统计数组,那就是M

计排的缺陷

  1. 数组的元素有小数。比如有一个元素是1.001,这种创建统计数组的话,那代价就太大太大了。
  2. 数组内的元素跨度大。假如有十个数,最大是1000,最小是1,使用计排的话,得创建1000个长度的数组,这显然也不合适的。

你可能感兴趣的:(数据结构,计数排序,计排,什么是计数排序?)