学习随记四十九——计数排序

注：我测试所用数据都是可以比较大小的类型且无重复元素，且排序按照升序排列。

前言：计数排序是一种线性时间复杂度的排序算法，前面的插入排序，归并排序，快速排序等等都是属于比较排序，而计数排序不是比较出来的是算出来的。

1、计数排序的算法描述

  为了避免空间的过多浪费，先遍历一遍待排序数组，找出其中的最大值和最小值，则计数数组的长度等于最大值减最小值加1（数组从0开始计数），将计数数组置0。然后遍历待排序数组，待排序数组的各个位置上的元素与最小值的差值即为该元素在计数数组中的对应位置，每遇到待排序数组的一个元素则在计数数组中其对应位置单元上加1，对应单元的数值对应待排序数组中这个数出现了几次。待排序数组遍历结束再遍历计数数组，将计数数组各个单元上代表的元素依次覆盖待排序数组，排序即完成。

2、计数排序的函数实现

  先遍历一遍待排序数组找出最大和最小值，计数数组的长度则为最大值和最小值的差值加一（数组从0开始计数），将计数数组置0。再次遍历一遍待排序数组，遇到一个元素，其与最小值的差值则为其在计数数组中的对应下标，该单元的数值表示在待排序数组中这个元素出现了几次，所以将该单元数值加一。然后，再遍历一遍计数数组，若下标对应的单元数值不为0，则进行循环，每次将这个单元数值减一，直到这个单元数值为0为止，每次将该单元数值（对应下标元素在待排序数组中出现了几次）与该下标的值减一（该下标的值减一表示与最小元素的的相对位置，因为数组从0开始计数比正常计数多一个，所以要减一）的和作为该单元对应的数值在待排序数组中的下标，值为最小值加当前下标，所以若出现了多个相同元素则每次这个元素在待排序数组中的下标减一再赋值，直到计数数组中的对应下标单元值为0，遍历完成则排序完成。

void CountSort(ElementType a[],int length){
	int i,max=a[0],min=a[0];
	for(i=0;i<length;i++){
		if(a[i]>max)max=a[i];
		if(a[i]<min)min=a[i];
	}
	int tmp_length=max-min+1;
	ElementType b[tmp_length];
	memset(b,0,sizeof(b));	//快速置0 
	for(i=0;i<length;i++) b[a[i]-min]++;	//a[i]与min元素的相对位置 
	for(i=0;i<tmp_length;i++) for(;b[i]>0;b[i]--) a[i-1+b[i]]=min+i;
}

3、计数排序的分析

3.1 时间复杂度分析

  在找最大值和最小值的过程中花费了O(n)的时间，计数时也花费了O(n)的时间，赋值时花费了O(k)的时间，总的来说平均时间复杂度为O(N)，且比较稳定.

3.2 运行实例分析

  在这里我生成一个从1——N的随机数数组，N的选取为10000，1000000，1000000，太小了运行时间太短，注意要在main函数外面声明数组，main函数中声明的数组长度不能太大，因为main函数里面是局部变量放在堆栈段，局部变量太大会导致栈溢出。
生成随机数组的函数：

void Randomize(ElementType a[],int length){
	memset(num,0,sizeof(a));		//将数组快速置0 
	srand((ElementType)time(NULL));
	for(int i=0;i<length;i++) a[i]=i+1;
	for(int i=length-1;i>0;i--) Swap(&a[i],&a[rand()%i]);
}void Swap(ElementType* a,ElementType* b){
	ElementType temp=*a;
	*a=*b;
	*b=temp;
}

不同数组长度下的10次运行平均时间：

10000	100000	1000000	10000000
0（运行时间太短不显示）	0	0.0142	0.156

注：当计数数组长度超过10万后也要放在函数外面声明，不然会导致栈溢出

4、整体代码

#include<stdio.h>
#include<time.h>
#include<stdlib.h>
#include<string.h>
typedef int ElementType;
const int N=10000;
ElementType num[N];
ElementType b[N];
void Swap(ElementType*,ElementType*);
void Randomize(ElementType [],int);
void CountSort(ElementType [],int);
int main(void){
	clock_t start=0,finish=0;
	Randomize(num,N);
	start=clock();
	CountSort(num,N);
	finish=clock();
	//for(int i=0;i<N;i++) printf("%d\n",num[i]);
	printf("time is:\n%lf",(double)(finish-start)/CLOCKS_PER_SEC);
	return 0;
}
void CountSort(ElementType a[],int length){
	int i,max=a[0],min=a[0];
	for(i=0;i<length;i++){
		if(a[i]>max)max=a[i];
		if(a[i]<min)min=a[i];
	}
	int tmp_length=max-min+1;
	//ElementType b[tmp_length];
	memset(b,0,sizeof(b));	//快速置0 
	for(i=0;i<length;i++) b[a[i]-min]++;	//a[i]与min元素的相对位置 
	for(i=0;i<tmp_length;i++) for(;b[i]>0;b[i]--) a[i-1+b[i]]=min+i;
}
void Randomize(ElementType a[],int length){
	memset(a,0,sizeof(a));		//将数组快速置0 
	srand((ElementType)time(NULL));
	for(int i=0;i<length;i++) a[i]=i+1;
	for(int i=length-1;i>0;i--) Swap(&a[i],&a[rand()%i]);
}
void Swap(ElementType* x,ElementType* y){
	ElementType temp=*x;
	*x=*y;
	*y=temp;
}

总结

  计数排序不是比较出来的是算出来的，所以计数排序可以脱离比较排序最坏情况下O(nlogN)的时间复杂度，达到常数级别的时间复杂度，在一定情况下计数排序非常快，但是计数排序是一种以空间换时间的排序方法，因为最大值与最小值的差值可能非常大，那么中间许多空间就都被浪费了，你也可以对计数排序的计数数组长度做出适当优化以减少空间浪费。总的来说，计数排序是一种比较稳定的常数级别的排序算法，可以根据对空间与时间的需求来决定使用与否。