基数排序(桶排序)

第一步

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

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

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

LSD的基数排序适用于位数小的数列，如果位数多的话，使用MSD的效率会比较好。MSD的方式与LSD相反，是由高位数为基底开始进行分配，但在分配之后并不马上合并回一个数组中，而是在每个“桶子”中建立“子桶”，将每个桶子中的数值按照下一数位的值分配到“子桶”中。在进行完最低位数的分配后再合并回单一的数组中。

java实现

[java] view plain copy

1. public static int getMax(int[] list) {  
2. <span style="white-space:pre">        </span>int max = list[0];  
3. <span style="white-space:pre">        </span>for (int i = 1; i < list.length; i++) {  
4. <span style="white-space:pre">            </span>if (max < list[i]) {  
5. <span style="white-space:pre">                </span>max = list[i];  
6. <span style="white-space:pre">            </span>}  
7. <span style="white-space:pre">        </span>}  
8. <span style="white-space:pre">        </span>return max;  
9. <span style="white-space:pre">    </span>}  

[java] view plain copy

1. // 基数排序  
2.     public static void radixSort(int[] list) {  
3.         // 获得列表中的最大数  
4.         int max = getMax(list);  
5.         System.out.println("最大值是：" + max);  
6.         //获得最大位数  
7.         int d = 1;  
8.         while (true) {  
9.             max = max / 10;  
10.             if (max == 0)  
11.                 break;  
12.             d++;  
13.         }  
14.         System.out.println("最大值位数是：" + d);  
15.   
16.         int k = 1;  
17.         int rate = 1;  
18.   
19.         while (k <= d) {  
20.             int m = 0;  
21.             int[][] tmplist = new int[10][list.length];//数组的第一维表示可能的余数0-9  
22.             int[] order = new int[10];  
23.             for (int i = 0; i < list.length; i++) {  
24.                 int tmpkey = (list[i] / rate) % 10;  
25.                 tmplist[tmpkey][order[tmpkey]] = list[i];  
26.                 //相同余数的放到同一桶的下一个坑里  
27.                 order[tmpkey] = order[tmpkey] + 1;  
28.             }  
29.             //将排序后的数组重新填入原list  
30.             for (int j = 0; j < order.length; j++) {  
31.   
32.                 for (int i = 0; i < order[j]; i++) {  
33.                     list[m] = tmplist[j][i];  
34.                     m++;  
35.                 }  
36.   
37.             }  
38.             k++;  
39.             rate = rate * 10;  
40.             print(list);  
41.         }  
42.   
43.     }