一种简单的实现是得到数组C，C[i]表示数组A中值为i的元素个数。
C = { 2, 0, 2, 3, 0, 1 }就表示两个0，两个2，三个3，一个5。
然后将这些数字依次存到数组B中。
#include <stdio.h>
#include <stdlib.h>
void printArray(int[], int);
void counting_sort(int A[], int B[], int len, int k)
{
int* C = calloc(k + 1, sizeof(int));
int j;
for (j = 0; j < len; j++)
C[A[j]] += 1;
// 保存C[i]个元素i到数组B[j]中。
int i;
for (i = 0, j = 0; i <= k; i++)
while (C[i]-- > 0)
B[j++] = i;
}
int main(void)
{
int A[8] = { 2, 5, 3, 0, 2, 3, 0, 3 };
int B[8];
int k = 5;
counting_sort(A, B, 8, k);
printArray(B, 8);
return 1;
}
void printArray(int array[], int len)
{
int i;
for (i = 0; i < len; i++)
printf("%d,", array[i]);
printf("\n");
}
这样简单的实现可以处理简单的整型数组的排序，但是对于有卫星数据的对象来说，
直接遍历数组C输出结果的方法是行不通的。不能直接创建新的元素当做结果，
而需要挪到输入数组A中的元素。
《算法导论》中的实现如下：保证结果与输入数组中元素的关联，以及稳定性。
// A = { 2, 5, 3, 0, 2, 3, 0, 3 }, len = 8, k = 5
void counting_sort(int A[], int B[], int len, int k)
{
// 输入数范围是[0, k]，数组C大小是k+1
int* C = calloc(k + 1, sizeof(int));
// C[i]表示数组A中值为i的元素个数
// C = { 2, 0, 2, 3, 0, 1 }
int j;
for (j = 0; j < len; j++)
C[A[j]] += 1;
// C[i]表示数组A中小于等于值为i的元素个数
// 即C[A[j]] - 1即为元素应在B中的下标
// C = { 2, 2, 4, 7, 7, 8 }
int i;
for (i = 1; i <= k; i++)
C[i] += C[i - 1];
// 从len - 1到0遍历数组A，保证稳定性
for (j = len - 1; j >= 0; j--) {
B[C[A[j]] - 1] = A[j];
C[A[j]] -= 1;
}
}
习题8.2-4，先使用计数排序花费n+k时间得到数组C，
然后区间[a, b]内的数字个数就是C[b] - C[a-1]。（a=0时，C[0] = 0）
例如上面例子中A = { 2, 5, 3, 0, 2, 3, 0, 3 }，
C = { 2, 2, 4, 7, 7, 8 }，[0, 5] = C[5] - 0 = 8
[1, 3] = C[3] - C[1-1] = 7 - 2 = 5。
