基数排序

举一个简单的例子，比如以下数组：

{23,43,56,12,767,123,54}

先找到数组里最大的一个数，这里是767，三位数，故要进行三次筛选，从个位数开始，依次到百位：

第一次排序过后为：

{12,23,43,123,54,56,767}//注意尾数相同的数的顺序，比如23和43，必须和之前的相同

第二次排序后为：

{12,23,123,43,54,56,767}

第三次排序后为：

{12,23,43,54,56,123,767}//因为两位数的百位为0，12相当于012

至此，排序结束，仅仅遍历数组三次而已。

以下代码方便大家理解，实际上并不是最优的方法，但思想就是基数排序：

#include<iostream>
#include<vector>
#include<time.h>
#include<algorithm>
#define MAX 20
void print(int *a, int length)
{
	for(int i = 0; i < length; i++)
	{
		std::cout << a[i] << " ";
	}
	std::cout << std::endl;
}

/*
它是一个稳定的排序算法(stable)
*/
void radixSort(int *a, int length)
{
	int exp = 1;
	int max = a[0];
    std::vector<std::vector<int> > bucket(10);
	int *b = new int[length];		
	for(int i = 1; i < length; i++)
	{
		max < a[i] ? max = a[i] : 1;//找最大值 
	}
	while( max / exp > 0)
	{
		for(int i = 0; i < length; i++)
		{
			bucket[a[i]/exp % 10].push_back(a[i]);//push_back保证了排序的稳定性 
		}
		int k = 0;
		for(int i = 0; i < 10; i++)
		{
            for(int j = 0; j < bucket[i].size(); j++)
                a[k++] = bucket[i].at(j);
            bucket[i].clear();
        }
        
		exp *= 10;		
	}

}
int main()
{
	int num[MAX];
	clock_t start, end;
	for(int i = 0; i < MAX; i++)
	{
		num[i] = rand();
	}

	print(num ,MAX);
	start = clock();
	radixSort(num, MAX);
	end = clock();
	std::cout << "Time is: " << (double)(end - start)/CLOCKS_PER_SEC << std::endl;
	print(num, MAX);
	system("pause");
}

下面的代码比上面那个快大约10倍，不过思想是一样的，可以和STL的排序算法比较一下，速度其实差不多：

#include<iostream>
#include<time.h>
#include<algorithm>
#define MAX 110000
void print(int *a, int length)
{
	for(int i = 0; i < length; i++)
	{
		std::cout << a[i] << " ";
	}
	std::cout << std::endl;
}

/*
它是一个稳定的排序算法(stable)
*/
void radixSort(int *a, int length)
{
	int exp = 1;
	int max = a[0];
	int *b = new int[length];		
	for(int i = 1; i < length; i++)
	{
		max < a[i] ? max = a[i] : 1;//找最大值 
	}
	while( max / exp > 0)
	{
		int bucket2[10] = {0};
		for(int i = 0; i < length; i++)
		{
			bucket2[(a[i]/exp)%10]++;//记录每一个的数量 
		}
		for(int i = 1; i < 10; i++)
			bucket2[i] += bucket2[i-1];
		for(int i = length - 1; i >= 0; i--)//从后开始，保证稳定性 
		{
			b[--bucket2[(a[i]/exp)%10]] = a[i];
		}
		for(int i = 0; i < length; i++)
			a[i] = b[i];
		exp *= 10;		
	}

}
int main()
{
	int num[MAX];
	clock_t start, end;
	for(int i = 0; i < MAX; i++)
	{
		num[i] = rand();
	}

	//print(num ,MAX);
	start = clock();
	radixSort(num, MAX);
//	std::sort(num, num+MAX); 
	end = clock();
	std::cout << (double)(end - start)/CLOCKS_PER_SEC << std::endl;
	//print(num, MAX);
	system("pause");
}

不过，由于排序的方式，基数排序有一定的局限性，不能用在任何地方，比如一般浮点数的排序。它的时间复杂度为O（n*k），n为待排序的元素个数，k为最大元素的位数。