桶排序

基本思想：

        基数排序（radix sort）属于“分配式排序”（distribution sort），又称“桶子法”（bucket sort），它是通过每个数的各个位数，将要排序的元素分配至某些“桶”中，以达到排序的作用，基数排序法是属于稳定性的排序，其时间复杂度为O (nlog(r)m)，其中r为所采取的基数，而m为堆数。

图解：

代码实现：

int FindMaxDigit(int arr[], int len)
{
	int maxnumber = arr[0];//找到最大的数
	for (int i = 1; i < len; ++i)
	{
		if (arr[i] > maxnumber)
		{
			maxnumber = arr[i];
		}
	}
	//求最大的数 有几位
	int count = 0;
	while (maxnumber != 0)
	{
		maxnumber /= 10;
		count++;
	}
	return count;
}
/*
digit :
0   个位	num  /10^0 %10;
1   十位	num / 10^1 %10;
2	百位	num / 10^2 %10;
……
double pow(double,int)  double的int次方
(int)pow(10.0,digit);
*/
int FindNumberDigit(int num, int digit)
{
	return num / (int)pow(10.0, digit) % 10;
} 

void Radix(int arr[], int **bucket,
	int len, int digit)
{
	int count[10] = { 0 };//每个桶中现有的元素的个数
	//依次获取每个数每个位的数字，放到对应数的桶中
	for (int i = 0; i < len; ++i)
	{
		int digitnumber = FindNumberDigit(arr[i], digit);
		bucket[digitnumber][count[digitnumber]] = arr[i];
		count[digitnumber]++;
	}
	int index = 0;
	//把每个桶（按0~9顺序）中数据拷回原数组
	for (int j = 0; j < 10; ++j)
	{
		for (int k = 0; k < count[j]; ++k)
		{
			arr[index++] = bucket[j][k];
		}
	}
}

void RadixSort(int arr[], int len)
{
	int** bucket = (int **)malloc(sizeof(int*)* 10);//定义10个桶，每个桶有len-1个数据，∴二级指针开辟
	for (int j = 0; j < 10; ++j)
	{
		bucket[j] = (int *)malloc(sizeof(int)*len);//初始化每个桶，每个桶有数据个数len-1个
	}
	int maxdigit = FindMaxDigit(arr, len);
	for (int i = 0; i < maxdigit; ++i)
	{
		Radix(arr,bucket,len,i);
	}
	for (int j = 0; j < 10; ++j)
	{
		free(bucket[j]);
	}
	free(bucket);
}
void RadixShow(int arr[], int len)
{
	for (int i = 0; i < len; ++i)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
}
int main()
{
	int arr[] = { 265, 3, 16, 13, 1332, 1, 36, 6, 66, 81, 78, 0};
	int len = sizeof(arr) / sizeof(arr[0]);
	RadixSort(arr, len);
	RadixShow(arr, len);
	return 0;
}

总结：

时间复杂度：平均O(d(r+n))，最好O(d(n+rd))，最坏O(d(r+n))

空间复杂度：O(1)

稳定