基数排序

1.算法介绍

　　按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优先级排序。最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前。

2.算法原理

　　两种多关键码排序方法：

　　多关键码排序按照从最主位关键码到最次位关键码或从最次位到最主位关键码的顺序逐次排序，分两种方法：

　　最高位优先(Most Significant Digit first)法，简称MSD 法：

　　　　1）先按k1 排序分组，将序列分成若干子序列，同一组序列的记录中，关键码k1 相等。

　　　　2）再对各组按k2 排序分成子组，之后，对后面的关键码继续这样的排序分组，直到按最次位关键码kd 对各子组排序后。

　　　　3）再将各组连接起来，便得到一个有序序列。扑克牌按花色、面值排序中介绍的方法一即是MSD 法。

　　最低位优先(Least Significant Digit first)法，简称LSD 法：

　　　　1) 先从kd 开始排序，再对kd-1进行排序，依次重复，直到按k1排序分组分成最小的子序列后。

　　　　2) 最后将各个子序列连接起来，便可得到一个有序的序列, 扑克牌按花色、面值排序中介绍的方法二即是LSD 法。

　　以LSD为例，假设原来有一串数值如下所示：

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

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

　　1 81

　　2 22

　　3 73 93 43

　　4 14

　　5 55 65

　　8 28

　　9 39

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

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

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

　　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

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

　　LSD的基数排序适用于位数小的数列，如果位数多的话，使用MSD的效率会比较好。

　　MSD的方式与LSD相反，是由高位数为基底开始进行分配，但在分配之后并不马上合并回一个数组中，而是在每个“桶子”中建立“子桶”，将每个桶子中的数值按照下一数位

　　的值分配到“子桶”中。在进行完最低位数的分配后再合并回单一的数组中。

3.源代码

 1 void testBS()
 2 {
 3     inta[] = {2, 343, 342, 1, 123, 43, 4343, 433, 687, 654, 3};
 4     int *a_p = a;
 5     //计算数组长度
 6     intsize = sizeof(a) / sizeof(int);
 7     //基数排序
 8     bucketSort3(a_p, size);
 9     //打印排序后结果
10     inti;
11     for(i = 0; i < size; i++)
12     {
13         printf("%d
", a[i]);
14     }
15     intt;
16     scanf("%d", t);
17 }
18 //基数排序
19 void bucketSort3(int *p, intn)
20 {
21     //获取数组中的最大数
22     intmaxNum = findMaxNum(p, n);
23     //获取最大数的位数，次数也是再分配的次数。
24     intloopTimes = getLoopTimes(maxNum);
25     inti;
26     //对每一位进行桶分配
27     for(i = 1; i <= loopTimes; i++)
28     {
29         sort2(p, n, i);
30     }
31 }
32 //获取数字的位数
33 int getLoopTimes(intnum)
34 {
35     intcount = 1;
36     inttemp = num / 10;
37     while(temp != 0)
38     {
39         count++;
40         temp = temp / 10;
41     }
42     returncount;
43 }
44 //查询数组中的最大数
45 int findMaxNum(int *p, intn)
46 {
47     inti;
48     intmax = 0;
49     for(i = 0; i < n; i++)
50     {
51         if(*(p + i) > max)
52         {
53             max = *(p + i);
54         }
55     }
56     returnmax;
57 }
58 //将数字分配到各自的桶中，然后按照桶的顺序输出排序结果
59 void sort2(int *p, intn, intloop)
60 {
61     //建立一组桶此处的20是预设的根据实际数情况修改
62     intbuckets[10][20] = {};
63     //求桶的index的除数
64     //如798个位桶index=(798/1)%10=8
65     //十位桶index=(798/10)%10=9
66     //百位桶index=(798/100)%10=7
67     //tempNum为上式中的1、10、100
68     inttempNum = (int)pow(10, loop - 1);
69     inti, j;
70     for(i = 0; i < n; i++)
71     {
72         introw_index = (*(p + i) / tempNum) % 10;
73         for(j = 0; j < 20; j++)
74         {
75             if(buckets[row_index][j] == NULL)
76             {
77                 buckets[row_index][j] = *(p + i);
78                 break;
79             }
80         }
81     }
82     //将桶中的数，倒回到原有数组中
83     intk = 0;
84     for(i = 0; i < 10; i++)
85     {
86         for(j = 0; j < 20; j++)
87         {
88             if(buckets[i][j] != NULL)
89             {
90                 *(p + k) = buckets[i][j];
91                 buckets[i][j] = NULL;
92                 k++;
93             }
94         }
95     }
96 }

4.时间复杂度

　　O (nlog(r)m)，其中r为所采取的基数，而m为堆数

5.稳定性分析

　　基数排序基于分别排序，分别收集，所以是稳定的。