排序算法——计数排序

计数排序

计数排序是一种基于分配而非基于比较的排序算法，因此不受比较排序时间复杂度下限nlogn的限制。

其主要思想是：对于一个待排序列中的任意一个元素，只要确定了有多少个小于该元素的值，即可确定该元素的位置。例如，要找出待排序列中x的位置，且该序列中只有6个元素小于x，则x的位置即为7。

计数排序对待排序列的数据有一定的要求：待排序列中的元素必须为整数。（根据《算法导论》的计数排序，其数据要求只能为自然数，但经过改进，负数也可以进行计数排序。）

计数排序算法时间复杂度为O(n+k),k为整数的范围。

计数排序的基本过程：
1、遍历待排序列，找出最大值和最小值，并构造辅助排序序列，长度为MAX-MIN+1；
2、待排序列MIN对应辅助序列中下标为0的位置，MAX对应辅助序列下标为MAX-1的位置，其余元素在辅助序列中也一一对应；
3、遍历待排序列，遇到一个元素，就在辅助序列中的对应位置+1；
4、遍历辅助序列，得到有序序列。

计数排序是一种以空间换时间的算法，若数据较为分散，则辅助序列的长度必然会很大，增大了空间复杂度。

伪代码

COUNTINGSORT(A,B,k)
//A.length = n,B.length=n,k=MAX-MIN+1
	let C[0...k] be a new array
	for i = 0 to k
		C[i] = 0
	for j = 1 to A.length
		C[A[j]] = C[A[j]]+1
	//C[i] now contains the number of elements equal to i.
	for i =1 to k
		C[i] = C[i] + C[i-1]
	//C[i] now contains the number of elements less than or equal to i.
	for j = A.length downto 1
		B[C[A[j]]]=A[j]
		C[Aj]]=C[A[j]]-1

伪代码出自《算法导论》原书第3版，机械工业出版社，Thomas H.Cormen Charles E.Leiserson著
该伪代码与我的实际实现代码略有出入，但结果都是基本相同的。

例

若存在序列：A={7, 50, 1, 4, 32, 7, 9, 5, 25, 6}，利用计数排序进行排序。
1、MIN=1，MAX=50
2、开辟50-1+1=50个辅助空间C并初始化为0，构造输出排序序列B；
3、根据辅助空间的下标对应待排序列，进行对应相加，即结果为C[6]=2,C[49]=1,C[0]=1,C[3]=1,C[31]=1,C[8]=1,C[4]=1,C[24]=1,C[5]=1;
3、从C[1]开始，C[i]+=C[i-1]，结果为C[0]=1,C[3]=2,C[4]=3,C[5]=4,C[6]=6,C[8]=7,C[24]=8,C[31]=9,C[49]=10;
4、从A的最后一个元素6开始:
6:C[6-1]=4 → B[4-1]=6,C[5]–;
25:C[25-1]=8 → B[8-1]=25,C[24]–;
5:C[5-1]=3 → B[3-1]=5,C[4]–；
9:C[9-1]=7 → B[7-1]=9,C[8]–；
7:C[7-1]=6 → B[6-1]=7,C[6]–；
32:C[32-1]=9 → B[9-1]=32,C[31]–；
4:C[4-1]=2 → B[2-1]=4,C[3]–；
1:C[1-1]=1 → B[1-1]=1,C[0]–；
50:C[50-1]=10 → B[10-1]=50,C[49]–；
7:C[7-1]=5 → B[5-1]=7,C[6]–；（C[6]在第5步计算上一个7时已减1）
5、遍历输出B，得到排序序列：1 4 5 6 7 7 9 25 32 50。

gif制作来源于VisuAlgo https://visualgo.net/zh/sorting
排序数组为{9,3,1,7,8,3,5,2,4,6}

代码

#include <iostream>
#include <vector>
#define N 10
using namespace std;

void CountingSort(int a[], int length) {
	vector<int> b(length, 0);
	int MAX = a[0], MIN = a[0];
	for (int i = 0; i < length; i++) {	//遍历得到最大值和最小值
		if (a[i] > MAX)
			MAX = a[i];
		if (a[i] < MIN)
			MIN = a[i];
	}
	int k = MAX - MIN + 1;	//辅助数组长度
	vector<int> c(k, 0);

	for (int j = 0; j < length; j++)
		c[a[j] - MIN]++;
	for (int i = 1; i < k; i++)
		c[i] += c[i - 1];

	for (int i = length - 1; i >= 0; i--) {
		b[c[a[i] - MIN] - 1] = a[i];
		c[a[i] - MIN]--;
	}

	for (int i = 0; i < length; i++)
		a[i] = b[i];

}


int main() {
	int a[N] = { -3,-5,2,6,10,7,1,10,-3,0 };
	int length = sizeof(a) / sizeof(a[0]);
	CountingSort(a, length);

	for (int i = 0; i < N; i++)
		cout << a[i] << " ";
	cout << endl;

	system("pause");
	return 0;
}