基数排序

原理是按每一位进行对数组的排序，例如：

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

代码实现：

int GetDigit(int * parr,int size)//获取最大数的位数{                 int max = parr [0];                 for (int i = 1; i <= size;i++)                {                                 if (max < parr [i])                                {                                                max = parr[i];                                }                }                 int digit = 0;                 while (max >= 10)                {                                digit++;                                max %= 10;                }                digit++;                 return digit;}void RadixSort(int * parr,int size)//基数排序（升序）{                 assert(parr );                 int digit = GetDigit(parr , size);                 int* count = new int[10];                 int* tmp = new int[size];                 int radix = 1;                 for (int i = 0; i < digit; i++)//进行digit次排序                {                                 for (int i = 0; i < 10; i++)//用直接地址法，先将计数器置0                                {                                                count[i] = 0;                                }                                 for (int i = 0; i < size; i++) //统计每个桶中所含数字的个数                                {                                                 int d = (parr [i]/radix) % 10;                                                count[d]++;                                }                                 for (int i = 1; i < 10;i++)//统计出tmp的右边界                                {                                                count[i] = count[i - 1] + count[i];                                }                                 for (int i = size-1; i >=0;i--) //将count桶里面的数据一次拿到tmp里,从后往前扫描保证排序稳定性                                {                                                 int d = (parr [i]/radix) % 10;                                                tmp[count[d]-1] = parr[i];                                                count[d]--;                                }                                 for (int i = 0; i < size; i++) //将tmp中数一次拷贝到parr中                                {                                                 parr[i] = tmp[i];                                }                                radix *= 10; //控制按哪一位排序                }                                 delete  []count;                 delete  []tmp;}

基数排序的时间复杂度为O（n*位数）。

空间复杂度为O（n），因为new的桶是常量，不算。

因为往tmp中移入时采用从后往前扫描，所以基数排序是稳定的排序。