基数排序
基数排序（桶排序）介绍：
1）基数排序（radix sort）属于“分配式排序”（distribution sort），又称“桶子法”（bucketsort）或bin sort，顾名思义，它是通过键值的各个位的值，将要排序的元素分配至某些“桶”中，达到排序的作用
2）基数排序法 是属于稳定性的排序，基数排序法的是效率高的稳定性排序法
3）基数排序（Radix Sort）是桶排序的扩展
4）基数排序是1887年赫尔曼●何乐礼发明的。它是这样实现的：将整数按位数切割成不同的数字，然后按每个位数分别比较。
基数排序基本思想
将所有待比较数值统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，依次进行一次排序。这样从最低位排序一直到最高位排序完成以后，数列就变成一个有序序列。
package com.zx.ds.ds0810;
import java.util.Arrays;
public class RadixSort {
public static void sort(int array[]){
int bucket[][]=new int[10][array.length];
int bucketElementCounts[]=new int[10];
//逐步推演
//按个位排序
for(int i=0;ipackage com.zx.ds.ds0810;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
public class RadixSort2 {
public static void sort(int array[]) {
//定义一个二维数组，表示10个桶, 每个桶就是一个一维数组
//说明
//1. 二维数组包含10个一维数组
//2. 为了防止在放入数的时候，数据溢出，则每个一维数组(桶)，大小定为arr.length
//3. 明确，基数排序是使用空间换时间的经典算法
int bucket[][] = new int[10][array.length];
//为了记录每个桶中，实际存放了多少个数据,我们定义一个一维数组来记录各个桶的每次放入的数据个数
//可以这里理解
//比如：bucketElementCounts[0] , 记录的就是 bucket[0] 桶的放入数据个数
int bucketElementCounts[] = new int[10];
//1. 得到数组中最大的数的位数
int max = array[0];
for (int i = 0; i < array.length; i++) {
if (array[i] > max) {
max = array[i];
}
}
//得到最大数是几位数
int maxLength = (max + "").length();
for (int t = 0,n=1; t < maxLength; t++,n*=10) {
//(针对每个元素的对应位进行排序处理)， 第一次是个位，第二次是十位，第三次是百位..
for (int i = 0; i < array.length; i++) {
//取出每个元素的对应位的值
int digitOfElement = array[i] /n % 10;
//放入到对应的桶中
bucket[digitOfElement][bucketElementCounts[digitOfElement]] = array[i];
bucketElementCounts[digitOfElement]++;
}
//按照这个桶的顺序(一维数组的下标依次取出数据，放入原来数组)
int index = 0;
//遍历每一桶，并将桶中是数据，放入到原数组
for (int i = 0; i < bucketElementCounts.length; i++) {
//如果桶中，有数据，我们才放入到原数组
if (bucketElementCounts[i] != 0) {
//循环该桶即第k个桶(即第k个一维数组), 放入
for (int j = 0; j < bucketElementCounts[i]; j++) {
array[index] = bucket[i][j];
index++;
}
}
//第i+1轮处理后，需要将每个 bucketElementCounts[k] = 0 ！！！！
bucketElementCounts[i] = 0;
}
//System.out.println(Arrays.toString(array));
}
}
public static void main(String[] args) {
int array[]={53,3,542,748,14,214};
// sort(array);
// System.out.println(Arrays.toString(array));
//---1---
//[542, 53, 3, 14, 214, 748]
//---2---
//[3, 14, 214, 542, 748, 53]
//---3---
//[3, 14, 53, 214, 542, 748]
//[3, 14, 53, 214, 542, 748]
sort(array);
System.out.println(Arrays.toString(array));
int big[] = new int[80000000];
for (int i = 0; i < big.length; i++) {
big[i] = (int) (Math.random() * 8000000);
}
int temp2[]=new int[big.length];
Date date = new Date();
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String dateToStr = simpleDateFormat.format(date);
System.out.println("before sort: " + dateToStr);
sort(big);
Date date2 = new Date();
SimpleDateFormat simpleDateFormat2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String dateToStr2 = simpleDateFormat2.format(date2);
System.out.println("after sort: " + dateToStr2);
//[3, 14, 53, 214, 542, 748]
//before sort: 2020-08-10 14:45:33
//after sort: 2020-08-10 14:45:33
// 测试8000 0000数据时会报错 需要的内存太大
// Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
// at com.zx.ds.ds0810.RadixSort2.sort(RadixSort2.java:11)
// at com.zx.ds.ds0810.RadixSort2.main(RadixSort2.java:70)
}
}
| 排序法 | 平均时间 | 最差情形 | 稳定度 | 额外空间 | 备注 | 80000随机数排序时间(s) |
|---|---|---|---|---|---|---|
| 冒泡 | O(n²) | O(n²) | 稳定 | O(1) | n小时较好 | 13 |
| 选择 | O(n²) | O(n²) | 不稳定 | O(1) | n小时较好 | 4 |
| 插入 | O(n²) | O(n²) | 稳定 | O(1) | 大部分已排序时较好 | 2 |
| 希尔 | O(nlogn) | O(n的s次方) 1| 不稳定 |
O(1) |
s是所选分组 |
1 |
|
| 快速 | O(nlogn) | O(n²) | 不稳定 | O(nlogn) | n大时较好 | 不到1 |
| 归并 | O(nlogn) | O(nlogn) | 稳定 | O(n) | n大时较好 | 不到1 |
| 基数 | O(NXk) | O(NXk) | 稳定 | O(N+k) | 不到1 | |
注：
1）基数排序是对传统桶排序的扩展，速度很快.
2）基数排序是经典的空间换时间的方式，占用内存很大，当对海量数据排序时，容易造成OutOfMemoryError。
3）基数排序时稳定的。[注：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的：否则称为不稳定的
4）有负数的数组，我们不用基数排序来进行排序，如果要支持负数，参考：htps:/i-hamess com/zh-CN/q/e98fa9
常用排序算法的总结和比较
相关术语解释：
1）稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面；
2）不稳定：如果a原本在b的前面，而a=b，排序之后a可能会出现在b的后面：.
3）内排序：所有排序操作都在内存中完成；
4）外排序：由于数据太大，因此把数据放在磁盘中，而排序通过磁盘和内存的数据传输才能进行；
5）时间复杂度：一个算法执行所耗费的时间。
6）空间复杂度：运行完一个程序所需内存的大小。
7）n：数据规模
8）k:“桶”的个数
9）In-place：不 占用额外内存
10）Out-place：占用额外内存