一、简介
基数排序(radix sort)属于“分配式排序”(distribution sort),又称“桶子法”(bucket sort)或bin sort,顾名思义,它是透过键值的部份资讯,将要排序的元素分配至某些“桶”中,藉以达到排序的作用,基数排序法是属于稳定性的排序,其时间复杂度为O (nlog®m),其中r为所采取的基数,而m为堆数,在某些时候,基数排序法的效率高于其它的稳定性排序法。
该算法具有稳定性。所谓稳定性,即在待排序序列中,存在多个相同的数,a = b 。
经过排序,这俩的相对次序保持不变,即a 仍然在b 的前面,这样的排序算法就具有稳定性。
二、原理
逐层从低位到高位(个位、十位…),把每个位数上的数据按升序排列。
三、例子:
将53,3,542,748,14,214按升序排序。
一共有10个桶(一维数组),下标0 ~ 9.
1、思路
将上面的数据放入arr数组中,并设置十个桶,下标0 ~ 9。第一轮排序时,依次取出这些数的个位上的数字(比如53的个位3,就放入下标为3的桶中),待所有数据的个位都提取并放入对应的桶之后,执行下一步:依次遍历所有桶,并取出桶中数据放入原来数组,完成后便开始第二轮排序;从更新后的arr数组中,提取十位数字,重复上列操作;第三轮亦同理。
第一轮排序:先取出个位上的数字,放入对应的桶中。
第二轮排序:同理,取出十位数,若缺位例如3,没有十位,则补零为03,再放入对应的桶中。
第三轮排序:同理,取出百位数,因为待排序数组最高位数是百位(748),所以只需要三轮排序。
这个最大位数怎么确定的呢?有个小技巧:
int max = arr[0];// 假设第一个数就是最大数
for (int i = 1; i < arr.length; i++) {
if (arr[i] > max) {
max = arr[i];
}
}
int maxlength = (max + "").length();
2、分布推导:
package com.huey.sort;
import java.util.Arrays;
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) {
// 定义一个二维数组,表示10个桶,每个桶就是一个一维数组
// 1、二维数组包含10个一维数组
// 2、为了防止在放入数的时候,数据溢出,则每个一维数组(桶),大小定义为arr.length
// 3、基数排序是使用空间换时间的经典算法
int[][] bucket = new int[10][arr.length];
// 为了记录每个桶中,实际存放了多少个数据,定义一个一维数组来记录各个桶的每次放入的数据个数
// 理解:
// 例如:bucketElementCounts[0],记录的就是 bucket[0] 桶的放入数据个数
int[] bucketElementCounts = new int[10];
// ===============================================================
// 第1轮(针对每个元素的个位进行排序处理)
for (int j = 0; j < arr.length; j++) {
// 取出每个元素的个位的值
int digitOfElement = arr[j] % 10;
// 放入到对应的桶中
bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[j];
// 例:53放在下标为3的桶,digitOfElement等于3,表示放在下标为3的桶中。
//bucketElementCounts[digitOfElement]表示第3个桶放入的数据个数。所以,整句话意思是:
//将arr[j](53)放到下标为3的桶中,这个下标为3的桶的第一个位置存放53.
//当结束了再把这个下标++,用来存放下个数据。
bucketElementCounts[digitOfElement]++;// 用来存放下一个
}
// 按照这个桶的顺序(一维数组的下标依次取出数据,放入原来数组)
int index = 0;
// 遍历每一个桶,并将桶中的数据,放入原来数组
for (int k = 0; k < bucketElementCounts.length; k++) {
// 如果桶中有数据,我们才放入到原数组
if (bucketElementCounts[k] != 0) {
// 循环该桶即第k个桶(即第k个一维数组),放入
for (int l = 0; l < bucketElementCounts[k]; l++) {
// 取出元素放入arr
arr[index++] = bucket[k][l];
}
}
// 第1轮处理后,需要将每个bucketElementCounts[k] = 0!!!!!!!!
bucketElementCounts[k] = 0;
}
System.out.println("第1轮:" + Arrays.toString(arr));
// ===============================================================
// 第2轮(针对每个元素的十位进行排序处理)
for (int j = 0; j < arr.length; j++) {
// 取出每个元素的十位的值
int digitOfElement = arr[j] / 10 % 10;// 748/10 => 74%10 => 4
// 放入到对应的桶中
bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[j];// 例:53放在下标为3的桶
bucketElementCounts[digitOfElement]++;// 用来存放下一个
}
// 按照这个桶的顺序(一维数组的下标依次取出数据,放入原来数组)
index = 0;
// 遍历每一个桶,并将桶中的数据,放入原来数组
for (int k = 0; k < bucketElementCounts.length; k++) {
// 如果桶中有数据,我们才放入到原数组
if (bucketElementCounts[k] != 0) {
// 循环该桶即第k个桶(即第k个一维数组),放入
for (int l = 0; l < bucketElementCounts[k]; l++) {
// 取出元素放入arr
arr[index++] = bucket[k][l];
}
}
// 第2轮处理后,需要将每个bucketElementCounts[k] = 0!!!!!!!!
bucketElementCounts[k] = 0;
}
System.out.println("第2轮:" + Arrays.toString(arr));
// ===============================================================
// 第3轮(针对每个元素的百位进行排序处理)
for (int j = 0; j < arr.length; j++) {
// 取出每个元素的百位的值
int digitOfElement = arr[j] / 100 % 10;// 748/100 => 7%10 => 7
// 放入到对应的桶中
bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[j];// 例:53放在下标为3的桶
bucketElementCounts[digitOfElement]++;// 用来存放下一个
}
// 按照这个桶的顺序(一维数组的下标依次取出数据,放入原来数组)
index = 0;
// 遍历每一个桶,并将桶中的数据,放入原来数组
for (int k = 0; k < bucketElementCounts.length; k++) {
// 如果桶中有数据,我们才放入到原数组
if (bucketElementCounts[k] != 0) {
// 循环该桶即第k个桶(即第k个一维数组),放入
for (int l = 0; l < bucketElementCounts[k]; l++) {
// 取出元素放入arr
arr[index++] = bucket[k][l];
}
}
}
System.out.println("第3轮:" + Arrays.toString(arr));
}
}
3、经推导,得到最终代码:
package com.huey.sort;
import java.util.Arrays;
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) {
// 根据前面的推导过程,可以得到最终代码
// 1.得到数组中最大的数的位数
int max = arr[0];// 假设第一个数就是最大数
for (int i = 1; i < arr.length; i++) {
if (arr[i] > max) {
max = arr[i];
}
}
// 得到最大数是几位数【妙啊】
int maxlength = (max + "").length();
// 定义一个二维数组,表示10个桶,每个桶就是一个一维数组
// 1、二维数组包含10个一维数组
// 2、为了防止在放入数的时候,数据溢出,则每个一维数组(桶),大小定义为arr.length
// 3、基数排序是使用空间换时间的经典算法
int[][] bucket = new int[10][arr.length];
// 为了记录每个桶中,实际存放了多少个数据,定义一个一维数组来记录各个桶的每次放入的数据个数
// 理解:
// 例如:bucketElementCounts[0],记录的就是 bucket[0] 桶的放入数据个数
int[] bucketElementCounts = new int[10];
// 这里使用循环将代码处理
for (int i = 0, n = 1; i < maxlength; i++, n *= 10) {// 【妙啊】
// 针对每个元素对应位进行排序处理,第一次个位,后面十位、百位
for (int j = 0; j < arr.length; j++) {
// 取出每个元素对应位进行排序处理
int digitOfElement = arr[j] / n % 10;
// 放入到对应的桶中
bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[j];// 例:53放在下标为3的桶
bucketElementCounts[digitOfElement]++;// 用来存放下一个
}
// 按照这个桶的顺序(一维数组的下标依次取出数据,放入原来数组)
int index = 0;
// 遍历每一个桶,并将桶中的数据,放入原来数组
for (int k = 0; k < bucketElementCounts.length; k++) {
// 如果桶中有数据,我们才放入到原数组
if (bucketElementCounts[k] != 0) {
// 循环该桶即第k个桶(即第k个一维数组),放入
for (int l = 0; l < bucketElementCounts[k]; l++) {
// 取出元素放入arr
arr[index++] = bucket[k][l];
}
}
// 第i+1轮处理后,需要将每个bucketElementCounts[k] = 0!!!!!!!!
bucketElementCounts[k] = 0;
}
System.out.println("第" + (i + 1) + "轮:" + Arrays.toString(arr));
}
}
}
输出结果:
速度测试:
8百万:0.5s左右
5千万:2 ~ 3s.
8千万,报错:堆溢出,不是电脑内存,得看你给 jvm 的堆分配了多少内存空间。
大约需要3GB。
80000000 * 10 * 4 / 1024 / 1024 / 1024 = 3GB