小朋友学数据结构（10）：基数排序
一、基本思想
将所有待比较数值（正整数）统一为同样的数位长度，数位较短的数前面补零。然后，从最低位（即个位数）开始，依次进行一次排序。这样从最低位排序一直到最高位排序完成以后, 数列就变成一个有序序列。
与其他排序不同的是，基数排序不涉及数的交换。
基数排序是一种稳定的排序算法。
二、主要步骤
从上面的计算过程，咱们可以看出，基数排序主要有三个步骤：
1、把所有元素都分配到相应的桶中（因为整数每位数有0~9共十种可能，所以通常需要10个桶）
2、把所有桶中的元素都集合起来放回到数组中
3、依次循环上面两步，循环次数为最大元素最高位数
三、代码实现
1 import java.util.ArrayList;
2 import java.util.Arrays;
3
4 public class Sort {
5
6 public static void radixSort(int[] array) {
7 //获取最大的数
8 int max = array[0];
9 for (int i = 1; i < array.length; i++) {
10 if (array[i] > max) {
11 max = array[i];
12 }
13 }
14
15 int digitCount = 0;
16 //判断位数，位数即排序的趟数
17 while (max > 0) {
18 digitCount++;
19 max /= 10;
20 }
21
22 //二维数组list由10个一维数组list1组成;
23 ArrayList<ArrayList<Integer>> list = new ArrayList<>();
24 for (int i = 0; i < 10; i++) {
25 ArrayList<Integer> subList = new ArrayList<>();
26 list.add(subList);
27 }
28
29 //进行digitCount次分配和收集;
30 for (int i = 0; i < digitCount; i++) {
31 //分配数组元素;
32 for (int num : array) {
33 //得到数字的第i+1位数;
34 int x = num % (int)Math.pow(10, i + 1) / (int)Math.pow(10, i);
35 list.get(x).add(num);
36 System.out.println("i = " + i + ", list " + "= " + list);
37 }
38
39 int index = 0;
40
41 //重新排列数组中的元素
42 for (int k = 0; k < 10; k++) {
43 while (list.get(k).size() > 0) {
44 ArrayList<Integer> subList = list.get(k);
45 array[index] = subList.get(0);
46 // 移除数组的第0个元素
47 subList.remove(0);
48 index++;
49 }
50 }//for执行完，list中的10个数组都被清空了
51 }
52 }
53
54 public static void main(String[] args) {
55 int[] arr = {135, 242, 192, 93, 345, 11, 24, 19};
56 System.out.println("Original array: " + Arrays.toString(arr));
57 radixSort(arr);
58 System.out.println("Sorted array: " + Arrays.toString(arr));
59 }
60 }
分析
这里重点看一下第30行~第51行。
（1）i = 0时， 针对个位数进行排序
x = 135 % 10 / 1 = 5
list.get(5)这是从list中获取第6个数组（因为下标从0开始，所以get(i)对应第i+1个数组），
list.get(5).add(135)是把135放到第6个数组里。此时，list = [[], [], [], [], [], [135], [], [], [], []]
x = 242 % 10 / 1 = 2
list.get(2).add(242)是把242放到第3个数组里。此时，list = [[], [], [242], [], [], [135], [], [], [], []]
……
第32~37行的循环都执行完之后，list = [[], [11], [242, 192], [93], [24], [135, 345], [], [], [], [19]]
第42行~第50行，
k = 0时，第0个数组为空，不进入while循环
k = 1时，array[0] = 11，11被移出后，第1个数组变为空，while循环停止
k = 2时，array[1] = 242，242被移出后，第2个数组变为{192}，array[2] = 192，192被移出后，第2个数组变为空，while循环停止
k = 3时，array[3] = 93，93被移出后，第3个数组变为空，while循环停止
k = 4时，array[4] = 24，24被移出后，第4个数组变为空，while循环停止
k = 5时，array[5] = 135，135被移出后，第5个数组变为{345}，array[6] = 345，345被移出后，第5个数组变为空，while循环停止
k = 6时，第6个数组为空，不进入while循环
k = 7时，第7个数组为空，不进入while循环
k = 8时，第8个数组为空，不进入while循环
k = 9时，array[7] = 19，19被移出后，第9个数组变为空
至此，for循环结束。
此时，list = [[],[],[],[],[],[],[],[],[],[]]，array = [11, 242, 192, 93, 24, 135, 345, 19]，达到了按个位数排序的效果。
（2）i = 1时， 针对十位数进行排序，此时的array不是原始的array，而是上一步最后得到的array，即array = [11, 242, 192, 93, 24, 135, 345, 19]
11 = 135 % 100 / 10 = 1
list.get(11).add(11)是把11放到第2个数组里。此时，list = [[], [11], [], [], [], [], [], [], [], []]
x = 242 % 100 / 10 = 4
list.get(4).add(242)是把242放到第5个数组里。此时，list = [[], [11], [], [], [242], [], [], [], [], []]
……
第32~37行的循环都执行完了之后，list = [[], [11, 19], [24], [135], [242, 345], [], [], [], [], [192, 93]]
第42行~第50行循环执行完后，list = [[],[],[],[],[],[],[],[],[],[]]， array = [11, 19, 24, 135, 242, 345, 192, 93]，达到了按十位数排序的效果。
（3）i = 2时，针对百位数进行排序，array为上一步排序后的结果，即array = [11, 19, 24, 135, 242, 345, 192, 93]
第32~37行的循环都执行完了之后，list = [[11, 19, 24, 93], [135, 192], [242], [345], [], [], [], [], [], []]
第42行~第50行循环执行完后，list = [[],[],[],[],[],[],[],[],[],[]]， array = [11, 19, 24, 93, 135, 192, 242, 345]，达到了按百位数排序的效果。这也是最终的排序结果。
运行结果
Original array: [135, 242, 192, 93, 345, 11, 24, 19]
Sorted array: [11, 19, 24, 93, 135, 192, 242, 345]
四、时间复杂度
对于数组[135, 242, 192, 93, 345, 11, 24, 19]来说，
第30行代码有个for，执行了3次，因为最大的数是3位数
第32行代码有个for，执行了8次，因为总共有8个数
第42行代码有个for循环，并且第43行代码有个while循环。这两层循环累加起来，实际上还是循环8次，因为总共有8个数。
所以这个例子里，共循环了3(8 + 8)次。
咱们设数组的最大位数为d，数组有n个元素，则需要循环d(n + n) = 2d*n次。所以基数排序的时间复杂度为O(d *n）。
