[算法导论]计数排序

计数排序假设 n 个输入元素中的每一个元素都是在 0 到 k 区间的一个整数，其中 k 为某个整数。

当 k = O(n) 时， 排序的运行时间为 Θ(n)

基本思想： 对于每一个输入元素 x ， 确定小于 x 的元素个数。 

利用这一信息，就可以直接把 x 放在它在输出数组中的位置上了。

伪算法：

CountingSort( A , B, k )
      let C[0..k] be a new array
      for i = 0 to k           // 初始化数组。另 C中的元素都为 0 
            C[i] = 0
      for  j = 1  to  A.length  // 以 A数组 中的值为 数组 C 的下标，每访问 C 其对应的下标上的数组值加 1 
            C[j] = C[A[j]]+1    
      for  i = 1 to  k
            C[i] = C[i] + C[i+1]  // 循环累加 
      for  j = A.length downto  1
            B[C[A[j]]] = A[j]     // 如果 A 中各项互异对每一 A[j] 值来说，  C[A[j]] 就是 A[j] 在输出数组中的最终正确位置 
            C[A[j]]  =  C[A[j]]  -1   // 但所有元素不可能中总是互异的。所以，每当 把 A[j] 的值放入输出数组后， 就把 C[A[j]] 的值减一
    

代码如下：

#include "iostream"
#include "malloc.h"

void CountingSort(int A[], int ALength, int B[], int BLength, int k);


int main(void)
{
	int A[11] = { -1,2,3,1,4,5,1,6,2,6,7 };
	int B[11] = { 0 };

	CountingSort(A, 10, B, 10, 10);

	for (int i = 0; i < 11; i++)
	{
		std::cout << B[i] << " ";
	}
	system("pause");
	return 0;
}

// A B 下标从1开始
void CountingSort(int A[], int ALength, int B[], int BLength, int k)
{
	int *C = (int*)malloc(sizeof(int)*(k+1));
	for (int i = 0; i <= k; i++)
	{
		C[i] = 0;
	}
	for (int j = 1; j <= ALength; j++)
	{
		C[A[j]] = C[A[j]] + 1;
	}
	for (int i=1 ; i<=k; i++)
	{
		C[i] = C[i] + C[i - 1];
	}
	for (int j=ALength ; j>=1; j--)
	{
		B[C[A[j]]] = A[j];
		C[A[j]] = C[A[j]] - 1;
	}
}