基数排序是一种稳定性排序，通过分配和收集元素到桶中，按照位数进行排序。它适用于整数排序，从低位开始逐位进行桶排序，最终得到有序序列。文章通过实例详细解释了基数排序的过程，并提供了Java代码实现，展示了从个位、十位到百位的排序步骤。基数排序在处理大量数据时速度快，但会占用较大内存。
目录
看这篇文章很形象
原文链接：https://blog.youkuaiyun.com/weixin_42369886/article/details/104875038
一、基数排序介绍
基数排序（radix sort）属于“分配式排序”（distribution sort），又称“桶子法”（bucket sort）或bin sort，它是通过键值的各个位的值，将要排序的元素分配至某些“桶”中，达到排序的作用
基数排序法是属于稳定性的排序，基数排序法是效率高的稳定性排序法。
基数排序(Radix Sort)是桶排序的扩展，它是这样实现的：将整数按位数切割成不同的数字，然后按每个位数分别比较。
二、基数排序基本思想
将所有待比较数值统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，依次进行一次排序。这样从最低位排序一直到最高位排序完成以后, 数列就变成一个有序序列。这样说明，比较难理解，下面我们看一个图文解释，理解基数排序的步骤。
将数组 {53, 3, 542, 748, 14, 214} 使用基数排序, 进行升序排序。
第1轮排序 [按照个位排序]:
说明： 事先准备10个数组(10个桶)， 0-9 分别对应 位数的 0-9
(1) 将 各个数，按照个位大小 放入到 对应的 各个数组中
(2) 然后从 0-9 个数组/桶中依次按照加入元素的先后顺序取出
第1轮排序后：542 53 3 14 214 748
第2轮排序 [按照十位排序]
(1) 将 各个数，按照十位大小 放入到 对应的 各个数组中
(2) 然后从 0-9 个数组/桶中依次按照加入元素的先后顺序取出
第2轮排序后： 3 14 214 542 748 53
第3轮排序 [按照百位排序]
(1) 将 各个数，按照百位大小 放入到 对应的 各个数组中
(2) 然后从 0-9 个数组/桶中依次按照加入元素的先后顺序取出
第3轮排序后：3 14 53 214 542 748 （得到了我们要的顺序）
代码实现：
public class RadixSort {
public static void main(String[] args) {
int arr[]={53, 3, 542, 748, 14, 214};
radixSort(arr);
}
public static void radixSort(int[] arr){
//先求出数组中的最大的数
int max=arr[0];
for(int i=1;i<arr.length;i++){
if(arr[i]>max){
max=arr[i];
}
}
//得到最大数是几位数
int maxLength=(max+"").length();
//定义一个二维数组，表示10个桶，每个桶就是一个数组
//为了在放入数时防止数据溢出，我们每个桶的大小为arr.length,即每个桶最多放进数组里的所有元素
int[][] bucket=new int[10][arr.length];
//定义一个一维数组来记录各个桶的每次放入的数据个数
int[] bucketElementCount=new int[10];
//第1轮：针对每个元素的个位进行排序处理
for(int j=0;j<arr.length;j++){
//取出每个元素的个位进行排序处理
int digitOfElement=arr[j]/1%10;
//放入到个位数对应的桶中
bucket[digitOfElement][bucketElementCount[digitOfElement]]=arr[j];
bucketElementCount[digitOfElement]++;
}
//按照一维数组的下标（即桶的顺序）依次取出数据，放入到原来数组
int index=0;
//遍历每一个桶，并将桶中数据放入到原数组
for(int k=0;k<bucketElementCount.length;k++){
//如果桶中有数据，才放入原来数组
if(bucketElementCount[k]!=0){
for(int m=0;m<bucketElementCount[k];m++){
arr[index++]=bucket[k][m];
}
}
//第一轮处理后，需将bucketElementCount[k]=0
bucketElementCount[k]=0;
}
System.out.println("第1轮，对个位数的排序处理 arr="+ Arrays.toString(arr));
//第2轮：针对每个元素的十位进行排序处理
for(int j=0;j<arr.length;j++){
//取出每个元素的十位进行排序处理
int digitOfElement=arr[j]/10%10;
//放入到个位数对应的桶中
bucket[digitOfElement][bucketElementCount[digitOfElement]]=arr[j];
bucketElementCount[digitOfElement]++;
}
//按照一维数组的下标（即桶的顺序）依次取出数据，放入到原来数组
index=0;
//遍历每一个桶，并将桶中数据放入到原数组
for(int k=0;k<bucketElementCount.length;k++){
//如果桶中有数据，才放入原来数组
if(bucketElementCount[k]!=0){
for(int m=0;m<bucketElementCount[k];m++){
arr[index++]=bucket[k][m];
}
}
//第2轮处理后，需将bucketElementCount[k]=0
bucketElementCount[k]=0;
}
System.out.println("第2轮，对个位数的排序处理 arr="+ Arrays.toString(arr));
//第3轮：针对每个元素的百位进行排序处理
for(int j=0;j<arr.length;j++){
//取出每个元素的十位进行排序处理
int digitOfElement=arr[j]/100%10;
//放入到个位数对应的桶中
bucket[digitOfElement][bucketElementCount[digitOfElement]]=arr[j];
bucketElementCount[digitOfElement]++;
}
//按照一维数组的下标（即桶的顺序）依次取出数据，放入到原来数组
index=0;
//遍历每一个桶，并将桶中数据放入到原数组
for(int k=0;k<bucketElementCount.length;k++){
//如果桶中有数据，才放入原来数组
if(bucketElementCount[k]!=0){
for(int m=0;m<bucketElementCount[k];m++){
arr[index++]=bucket[k][m];
}
}
//第2轮处理后，需将bucketElementCount[k]=0
bucketElementCount[k]=0;
}
System.out.println("第3轮，对个位数的排序处理 arr="+ Arrays.toString(arr));
}
}
代码简化：
public class RadixSort {
public static void main(String[] args) {
int arr[]={53, 3, 542, 748, 14, 214};
radixSort(arr);
}
public static void radixSort(int[] arr){
//先求出数组中的最大的数
int max=arr[0];
for(int i=1;i<arr.length;i++){
if(arr[i]>max){
max=arr[i];
}
}
//得到最大数是几位数
int maxLength=(max+"").length();
//定义一个二维数组，表示10个桶，每个桶就是一个数组
//为了在放入数时防止数据溢出，我们每个桶的大小为arr.length,即每个桶最多放进数组里的所有元素
int[][] bucket=new int[10][arr.length];
//定义一个一维数组来记录各个桶的每次放入的数据个数
int[] bucketElementCount=new int[10];
for(int i=0,n=1;i<maxLength;i++,n*=10){
//对每个元素的对应位进行处理
for(int j=0;j<arr.length;j++){
//取出每个元素的对应位的值
int digiOfElement=arr[j]/n%10;
//放入到对应的桶中
bucket[digiOfElement][bucketElementCount[digiOfElement]]=arr[j];
bucketElementCount[digiOfElement]++;
}
//按照这个桶的顺序即一维数组的下标一次取出数据放入原来数组
int index=0;
//遍历每一桶，并将桶中数据放入到原数组
for(int k=0;k<bucketElementCount.length;k++){
//如果桶中有数据，才放入原来数组
if(bucketElementCount[k]!=0){
for(int m=0;m<bucketElementCount[k];m++){
arr[index++]=bucket[k][m];
}
}
//每一轮处理后，需将bucketElementCount[k]=0
bucketElementCount[k]=0;
}
System.out.println("第"+(i+1)+"轮，对个位数的排序处理 arr="+ Arrays.toString(arr));
}
}
}
运行结果：
三、基数排序的说明:
(1)基数排序是对传统桶排序的扩展，速度很快。
(2)基数排序是经典的空间换时间的方式，占用内存很大, 当对海量数据排序 时，容易造成 OutOfMemoryError 。
(3)基数排序时稳定的。（注:假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，如原始数组为{1,3,2,3,5}经过排序后为{1,2,3,3,5},此时第一个3经过排序后仍然在第二个三的前面，则称这种排序算法是稳定的；否则称为不稳定的）。
(4)有负数的数组，我们不用基数排序来进行排序。
还可以参考这篇，也很形象，总结下来，1）根据个位数排序一轮，2）根据十位数再排序一轮，3)百位排序。。。。。直到排完为止。
https://blog.youkuaiyun.com/weixin_44537194/article/details/87302788
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
