计数排序

学习基数排序之前首先学习计数排序。

计数排序假设每个元素都是在0到k之间的一个整数。

基数排序的基本思想，对于每个元素x，如果我们知道了小于x的元素的个数，就可以确定输出数组中元素x的位置，那么直接将元素x放到输出数组中。比如有3小于x的元素，那在输出数组中，x肯定位于第4个位置。

计数排序的算法用伪代码描述为：

COUNTING-SORT(A,k)
	// 初始化数组C
	for i=0 to k
		C[i]=0

	// 统计A[j]元素出现的次数，保存到C数组中
	for j=0 to A.length
		C[A[j]]=C[A[j]]+1

	// 统计小于等于A[j]元素的个数
	for k=0 to k
		C[K]=C[K-1]+C[K]

	// 将A中的元素放在B中正确的位置
	for i=A.length to 0
		B[C[A[i]]-1]=A[i]
		C[A[i]]=C[A[i]]-1

注：由于有可能有相同元素存在，所以，每次将A[i]元素放入B数组中，都要将C[A[j]]的值减一，这样当遇到下一个值等于A[j]的元素时，该元素就能放在输出数组中A[j]的前面。

计数排序的详细过程如下

计数排序的关键代码如下

public int[] countSort(int a[], int k) {
		int[] b = new int[a.length];
		int[] c = new int[k];
		for (int i = 0; i < c.length; i++) {
			c[i] = 0;
		}
		for (int i = 0; i < a.length; i++) {
			c[a[i]] += 1;
		}
		for (int i = 0; i < c.length; i++) {
			if (i != 0) {
				c[i] += c[i - 1];
			}
		}
		for (int i = a.length - 1; i >= 0; i--) {
			b[c[a[i]] - 1] = a[i];
			c[a[i]] = c[a[i]] - 1;
		}
		return b;
	}

计数排序的性能

很容易得到计数排序的时间复杂度为：T(n)=O(k+n)，因此当k小于等于n，也就是当k=O(n)，k和n同阶时，采用计数排序的时间复杂度为T(n)=O(n)

同时，计数排序也是一种稳定的排序算法。

基数排序

基数排序最初是用在打孔卡片制表机上的一种排序算法，由Herman Hollerith发明，也就是IBM的创始人。

基数排序从最低为开始来排序的，从低位到高位，按位排序，按位排序必须是稳定的。

基数排序的详细过程

基数排序算法描述为

RADIX-SORT(A,d)
	for i=1 to d
		use a stable sort to sort arrat A on digit i

在这里我们选择计数排序。考虑常规情况，对[0...9]之间的数排序，k=10，且一般有k<<n，此时能达到最好的时间复杂度O(n)

基数排序的关键代码，这里以数组排序时按照十进制每位进行比较。

/**
	 *  基数排序
	 * @param result  最终已排序的数组，共用一个节省空间
	 * @param maxLen  待排序的数组中最大的位数
	 */
	public static void radixSort(int[] a,int[] result, int maxLen) {
		int flag = 1;
		// 保存每轮要排序的位对应数组a的值
		int [] digitArr = new int[a.length];
		for(int i=0; i < maxLen; i++) {
			// 共比较的轮数
			flag *= 10;
			// b数组中对应的装着a数组中每位的数,第一轮装着各位，第二轮装着十位数...
			for (int j = 0; j < digitArr.length; j++) {
				digitArr[j]=a[j]%flag;
				digitArr[j]=digitArr[j]/(flag/10);
			}
			countSort(a, digitArr,result,10);
			// 每一轮计数排序完后刷新下一轮要排序的数组
			System.arraycopy(result, 0, a, 0,result.length);
		}
	}

调用计数排序的函数

/**
	 * 计数排序 :对数组a中的元素按某些位排序
	 * @param tmp  要参与排序的当前位的值保存在tmp中
	 * @param result  每次计数排序后的新的数组顺序
	 */
	public static void countSort(int a[], int tmp[], int result[], int k) {
		int[] c = new int[k];
		for (int i = 0; i < c.length; i++) {
			c[i] = 0;
		}
		for (int i = 0; i < tmp.length; i++) {
			c[tmp[i]] += 1;
		}
		for (int i = 0; i < c.length; i++) {
			if (i != 0) {
				c[i] += c[i - 1];
			}
		}
		for (int i = tmp.length - 1; i >= 0; i--) {
			// 和计数排序唯一的差别在于赋值的时候用真实的数据
			result[c[tmp[i]] - 1] = a[i];
			c[tmp[i]] = c[tmp[i]] - 1;
		}
	}

基数排序的性能

如果基数排序使用的稳定排序算法的时间复杂度为O(n+k)，那么基数排序的时间复杂度为T(n)=O(d(n+k))

很容易理解要循环d轮，每轮耗时为O(n+k)，于是总的耗时为O(d(n+k))

在此基础上，从2^r进制来看，此时k为2^r，并且一个b位数要比较b/r轮。于是我们得到T(n)=O((b/r)(n+2^r))

对上式求导可得其最小值。此时r=lgn，此时T(n)=O((b/lgn)n),如果再取b=lgn，这时就能达到最少的运行时间，时间复杂度为T(n)=O(n)

基数排序也是稳定的排序算法