一、基本思想

将所有待比较数值（正整数）统一为同样的数位长度，数位较短的数前面补零。然后，从最低位（即个位数）开始，依次进行一次排序。这样从最低位排序一直到最高位排序完成以后, 数列就变成一个有序序列。
与其他排序不同的是，基数排序不涉及数的交换。
基数排序是一种稳定的排序算法。

 

8.png

二、主要步骤

从上面的计算过程，咱们可以看出，基数排序主要有三个步骤：
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）。