Algorithms

相关概念

    计算排序 Counting Sort 有别于 '比较' 排序(通过比较元素大小等到排序结果的算法的统称). 
    计算排序假设 n 个输元素中的每一个都是在 0 到 k(整数) 区间内的一个整数. 
    
    计算排序 Counting Sort 算法的基本思想是: 
        对集合中的每一个元素 x , 统计小于 x 的元素的个数. 利用这个信息, 就可以找到元素 x 在集合中的适合的位置 index. 
        例如, 在整个集合中 有 4 个元素小于 6, 则元素 6 应该被放在集合的第五(4+1)个位置上.
        
    计数排序的一个重要性质是 -  计数排序是稳定的： 具有相同的元素值在输出数组中的相对次序与它们在输入数组中的相对次序相同. 
    也就是说, 输入中的两个相同的数来说, 先出现的数也会先出现在输出数组中。这种稳定性只有当进行排序的数据还附带卫星数据时才比较重要.
    
    计数排序的稳定性很重要的另一个原因是： 计数排序经常会被用作基数排序算法的的一个子过程.

Python programming

def counting_sort(A, B, k): # [2,5,3,0,2,3,0,3]   k = max(A) + 1
    n = len(A)
    c = [0 for x in range(k)]   # c 是一个 container 用来负责计算, 元素初始化为 0
    
    for i in range(n):
        c[A[i]] = c[A[i]] + 1

    print(111,c)      # 这步骤中 c[i] 存储是是 集合A中元素大小为 i 的元素数量.

    for j in range(1,k):
        c[j] = c[j] + c[j-1]

    print(222, c) # 这步骤中 c[i] 存储是是 集合A中元素大小 小于等于 i 的元素数量.
    
    for l in range(1, n+1):    
        print('Steps : ', n - l)    # 倒序处理结合 A 中的没一个元素.
        print('Indexs : ',  A[n - l], c[A[n - l]] - 1 )
        B[c[A[n - l]] - 1] = A[n - l]   # c[A[n - l]] - 1 是元素 A[n - l] 应该的被排序到置. 这里是通过关联关系：'c[i] 存储是是 集合A中元素大小 小于等于 i 的元素数量' 实现的. 这里减 1 的运算是为了'对齐', 因为 python 的 list 的 index 是 0 base 的. 
        print('B', B)         # 集合 B 是存储排序结果的 container
        c[A[n-l]] = c[A[n-l]] - 1  # 将 c[A[n-l]] - 1 为下一次循环做准备.  因为 A[n-l] 已经被存到了集合 B 中, 这个时候 小于等于 A[n-l] 的元素个数减少了1.
        print('C', c)
    return B

if __name__ == '__main__':

    A = [2,5,3,0,2,3,0,3]
    B=[0,0,0,0,0,0,0,0]
    k = 6                              #  k = max(A) + 1
    print('Before : ', A)
    counting_sort(A,B,k)
    print('After : ', B)

打印结果:
Before :  [2, 5, 3, 0, 2, 3, 0, 3]
111 [2, 0, 2, 3, 0, 1]         # c[i] 存储是是 集合A中元素大小为 i 的元素数量.
222 [2, 2, 4, 7, 7, 8]         # c[i] 存储是是 集合A中元素大小 小于等于 i 的元素数量.
Steps :  7                         # 倒序处理 A 的每一个元素.
Indexs :  3 6                     # 先处理 A[-1] = 3,  3 应该放到 B[6] = 3 的位置上. 因为 c[3] = 7 = 6+1 =  c[A[n - l]] - 1
B [0, 0, 0, 0, 0, 0, 3, 0]     #  B[6] = 3
C [2, 2, 4, 6, 7, 8]             # 更新 c[3] = c[A[n - l]] 的值为下一次循环做准备. c[A[n-l]] = c[A[n-l]] - 1
Steps :  6                          # 第二次 for 循环.
Indexs :  0 1
B [0, 0, 0, 0, 0, 0, 3, 0]
C [1, 2, 4, 6, 7, 8]
Steps :  5
Indexs :  3 5
B [0, 0, 0, 0, 0, 3, 3, 0]
C [1, 2, 4, 5, 7, 8]
Steps :  4
Indexs :  2 3
B [0, 0, 0, 2, 0, 3, 3, 0]
C [1, 2, 3, 5, 7, 8]
Steps :  3
Indexs :  0 0
B [0, 0, 0, 2, 0, 3, 3, 0]
C [0, 2, 3, 5, 7, 8]
Steps :  2
Indexs :  3 4
B [0, 0, 0, 2, 3, 3, 3, 0]
C [0, 2, 3, 4, 7, 8]
Steps :  1
Indexs :  5 7
B [0, 0, 0, 2, 3, 3, 3, 5]
C [0, 2, 3, 4, 7, 7]
Steps :  0
Indexs :  2 2
B [0, 0, 2, 2, 3, 3, 3, 5]
C [0, 2, 2, 4, 7, 7]
After :  [0, 0, 2, 2, 3, 3, 3, 5]

Reference,

　　1. Introduction to algorithms