counting sort (计数排序) algorithm

假设n个输入元素中每一个均介于0~k之间，k为最大值，这里k为整数。如果k=O(n), 则计数排序的运行时间为θ(n)。

计数排序的核心思想是：对于每个元素x，统计出小于等于x元素的个数，利用该信息，就可以确定每个元素x在最终数组中的位置。比如小于等于x的元素个数有17个，则该元素的最终位置在17-1=16.

计数排序的伪代码如下:

其中数组A为输入数组，数组B为排序后输出数组，k为数组A元素中最大值，伪代码中少个数组长度的参数，自行加上。

line 4~5 统计数组A中每个元素A[j]出现次数.

line 7~8 统计数组A中小于等于i(<0i<k)的元素个数.

line 10~12 根据小于等于A[j]的个数直接定位A中每个元素的位置，因为可能有相同元素，所以每次同时递减 小于等于A[j]的个数.

根据伪代码很同意得出计数排序的运行时间为θ(n)。

计数排序一个重要的特性就是它是稳定的: 相同值元素在最终数组中的相对次序同他们在输入数组中相同。

下面是数组A[] = {2,5,3,0,2,3,0,3}数组排序的全过程示意图:

个人代码如下:

/************************************************************************/
/* author: alex                                                         */
/* time: 1/9 2014                                                      */
/************************************************************************/
#include <iostream>
using namespace std;

int count_sort(int array_src[], int array_dst[], int max_num_k, int array_length);
void print_array(int array[], int length);

int main(void)
{
	int array_src[] = {2,5,3,0,2,3,0,3};
	int array_length = sizeof(array_src)/sizeof(array_src[0]);
	int max_num_of_array_src = 5; // get max from array_src.
	int *array_dst = (int *)malloc(array_length*sizeof(int));

	if(NULL == array_dst)
	{
		cout << "array_dst malloc error !" << endl;
		return -1;
	}

	memset(array_dst, 0, array_length*sizeof(int));

	cout << "Before count sort : " << endl;
	print_array(array_src, array_length);

	count_sort(array_src, array_dst, max_num_of_array_src, array_length);

	cout << "After count sort : " << endl;
	print_array(array_dst, array_length);

	free(array_dst);
	array_dst = NULL;
	
	return 0;
}

int count_sort(int array_src[], int array_dst[], int max_num_k, int array_length)
{
	int i = 0, j = 0;
	int *p_count_array = (int *)malloc((max_num_k+1)*sizeof(int));
	if(NULL == p_count_array)
	{
		cout << "p_count_array malloc error !" << endl;
		return -1;
	}
	
	memset(p_count_array, 0 , (max_num_k+1)*sizeof(int));

	for(j = 0; j < array_length; j++)
	{
		//p_count_array contain the numbers of items that equal to array[j]
		p_count_array[array_src[j]] = p_count_array[array_src[j]] + 1;
	}

	for(i = 1; i <= max_num_k; i++)
	{
		//p_count_array contain the numbers of items that less and equal to i
		p_count_array[i] = p_count_array[i] + p_count_array[i-1];
	}

	for(j = array_length-1; j >=0; j--)
	{
		//because numbers of items that less and equal to array_src[j] is p_count_array[array_src[j]], 
		//so we can confirm the position of array_src[j], locate array_src[j] to 
		//array_dst[p_count_array[array_src[j]] -1], and subtract p_count_array[array_src[j]], then
		//the less or same items (if any) locate before witch. for example if array_src[j] = 3,
		//and p_count_array[array_src[j]] is 2(mean less and equal to 3 exist 2 items), so we can
		//locate 3 to position 2-1=1, the last less or equal items locate before it.
		array_dst[p_count_array[array_src[j]]-1] = array_src[j];
		p_count_array[array_src[j]] = p_count_array[array_src[j]] - 1;
	}

	free(p_count_array);
	p_count_array = NULL;

	return 0;
}

void print_array(int array[], int length)
{
	int i = 0;

	for(i=0; i<length; i++)
	{
		cout << array[i] << " ";
	}
	cout << endl << endl;
}

为了方便代码实现，本文下标从0下表开始，同算法导论书中表述略有出处。如有任何问题，欢迎各位指正。

因为统计计数对数据限制过多，要求最大数比总个数小，时间，空间复杂度才可控，所以实际项目中试用很少。

reference :

算法导论英文版第三版