基数排序

基数排序

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

2、基本过程

第一步

假设原来有一串数值如下所示：

73, 22, 93, 43, 55, 14, 28, 65, 39, 81

首先根据个位数的数值，在走访数值时将它们分配至编号0到9的桶子中：

0

1 81

2 22

3 73 93 43

4 14

5 55 65

6

7

8 28

9 39

第二步

接下来将这些桶子中的数值重新串接起来，成为以下的数列：

81, 22, 73, 93, 43, 14, 55, 65, 28, 39

接着再进行一次分配，这次是根据十位数来分配：

0

1 14

2 22 28

3 39

4 43

5 55

6 65

7 73

8 81

9 93

第三步

接下来将这些桶子中的数值重新串接起来，成为以下的数列：

14, 22, 28, 39, 43, 55, 65, 73, 81, 93

这时候整个数列已经排序完毕；如果排序的对象有三位数以上，则持续进行以上的动作直至最高位数为止。

3、代码实现

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

//找最大数的位数
int FindMaxNum(int arr[],int len)
{
	int maxnum = arr[0];
	for(int i = 1;i < len;i++)
	{
		if(arr[i] > maxnum)
		{
			maxnum = arr[i];
		}
	}

	int count = 0;
	while(maxnum != 0)
	{
		maxnum /= 10;
		count++;
	}
	return count;
}

int FindNumDigit(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 digitnum = FindNumDigit(arr[i],digit);
		bucket[digitnum][count[digitnum]] = arr[i];
		count[digitnum]++;
	}

	int index = 0;
	for(int i = 0;i < 10;i++)
	{
		for(int j = 0;j < count[i];j++)
		{
			arr[index++] = bucket[i][j];
		}
	}
}

void RadixSort(int arr[],int len)
{
	//创建“桶”
	int **bucket = (int **)malloc(sizeof(int *)*10);//10就是0-9数字
	for(int i = 0;i < 10;i++)
	{
		bucket[i] = (int *)malloc(sizeof(int)*len);
	}

	//找到数组中最大数
	int maxnum = FindMaxNum(arr,len);

	for(int i = 0;i < maxnum;i++)
	{
		Radix(arr,bucket,len,i);
	}

	for(int i = 0;i < 10;i++)
	{
		free(bucket[i]);
	}
	free(bucket);
}

void Show(int arr[],int len)
{
	for(int i = 0;i < len;i++)
	{
		printf("%d ",arr[i]);
	}
	printf("\n");
}

int main()
{
	int arr[] = {12,67,0,34,76,23,19,90,45,29,5,9};
	int len = sizeof(arr) / sizeof(arr[0]);

	RadixSort(arr,len);
	Show(arr,len);

	return 0;
}

运行结果：