1、计数排序
1.1、介绍
计数排序（Counting Sort）不是基于比较的排序算法，是一种特殊的桶排序。其核心在于将输入的数据转化为键存储在额外开辟的数据空间中。
计数排序只能用在数据范围不大的场景中，如果数据范围 k 比数据要排序的数据 n 大很多，就不适合计数排序了。而且，计数排序只能给非负整数排序，如果要排序的数据是其他类型的，要将其在不改变相对大小的数据情况下，转换化为非负整数。
1.2、分析
- 找出
arr[]中最大和最小的元素- 统计数组中每个值为
i的元素出现的次数，存入bucket[i]位置- 对所有的计数累加：
bucket[i]++- 填充目标数组：将每个元素
j放入arr[i]中，每放一个元素就将bucket[j]--; i++
1.3、实现
/**
* @description: 计数排序
* @author: erlang
* @since: 2020-11-13 21:31
*/
public class CountSort {
public static void countSort(int[] arr) {
if (arr == null || arr.length < 2) {
return;
}
int max = 0;
for (int cur : arr) {
max = Math.max(cur, max);
}
int[] bucket = new int[max + 1];
for (int cur : arr) {
bucket[cur]++;
}
int i = 0;
for (int j = 0; j < bucket.length; j++) {
while (bucket[j]-- > 0) {
// 每放入一次 i++
arr[i++] = j;
}
}
}
public static void main(String[] args) {
ArraySortUtils.testSort(CountSort::countSort, 100, 100, false);
}
}
2、基数排序
2.1、介绍
基数排序（Radix Sort）对要排序的数据是有要求的，需要可以分割出独立的位来比较，而且位之间有递进的关系，如果 a 数据的高位比 b 数据大，那剩下的低位就不用比较了。除此之外，每一位的数据范围不能太大，要可以用线性排序算法来排序，否则，基数排序的时间复杂度就无法做到 O(N) 了。
2.2、分析
- 取得
arr[]中的最大数，并取得位数digit- 从最低位开始取每个位组成
radix数组- 对
radix进行计数排序或桶排序
2.3、实现
import java.util.Arrays;
/**
* @description: 基数排序
* @author: erlang
* @since: 2020-11-13 21:51
*/
public class RadixSort {
/**
* 基数排序
*
* @param arr 待排序数组，非负
*/
public static void radixSort(int[] arr) {
if (arr == null || arr.length < 2) {
return;
}
radixSort(arr, 0, arr.length - 1, maxBits(arr));
}
/**
* 从 left 到 right 的排序
*
* @param arr 待排序的数组
* @param left 待排序的右边界
* @param right 待排序的左边界
* @param digit 最大数的位数
*/
public static void radixSort(int[] arr, int left, int right, int digit) {
if (left >= right) {
return;
}
// 十进制的数，以 10 为基底
int radix = 10;
int[] count = new int[radix];
int[] help = new int[right - left + 1];
// 有多少位，就循环多少次
for (int d = 0; d < digit; d++) {
for (int i = left; i <= right; i++) {
// 求当前位 d 在 count[] 中的索引
int index = index(arr[i], d);
// 计算当前位 d 的数字有多少个
count[index]++;
}
for (int i = 1; i < radix; i++) {
// count[0] 当前位 d 是 0 的数字有多少个
// count[1] 当前位 d 是 0, 1 的数字有多少个
// count[2] 当前位 d 是 0, 1, 2 的数字有多少个
// ...
// count[9] 当前位 d 是 0, 1, 2, 3 ... 9 的数字有多少个
count[i] += count[i - 1];
}
// 将 arr 中 left 到 right 范围在 help 中排好序
for (int i = right; i >= left; i--) {
// 求当前位 d 在 count[] 中的索引
int index = index(arr[i], d);
help[--count[index]] = arr[i];
}
// 将 left 到 right 范围排好序的数据 copy 到原数组中
for (int i = left, j = 0; i <= right; i++, j++) {
arr[i] = help[j];
}
Arrays.fill(count, 0);
}
}
public static int index(int x, int d) {
return ((x / (int) Math.pow(10, d)) % 10);
}
public static int maxBits(int[] arr) {
int max = 0;
for (int cur : arr) {
max = Math.max(max, cur);
}
int res = 0;
while (max != 0) {
res++;
max /= 10;
}
return res;
}
public static void main(String[] args) {
ArraySortUtils.testSort(RadixSort::radixSort, 100, 100, false);
}
}
3、工具类
ArraySortUtils
import java.util.Arrays;
import java.util.function.Consumer;
/**
* @description: 数组排序工具
* @author: erlang
* @since: 2020-08-29 10:49
*/
public class ArraySortUtils {
public static void swap(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
public static int[] generateRandomArray(int maxSize, int maxValue) {
return generateRandomArray(maxSize, maxValue, true);
}
/**
* 随机生成待测试的数组
*
* @param maxSize 数组最大长度
* @param maxValue 数组中最大的值
* @param flag 数组中是否允许有负数
* @return 返回生成的数组
*/
public static int[] generateRandomArray(int maxSize, int maxValue, boolean flag) {
int[] arr = new int[(int) ((maxSize + 1) * Math.random())];
for (int i = 0; i < arr.length; i++) {
arr[i] = (int) ((maxValue + 1) * Math.random());
if (flag) {
arr[i] -= (int) (maxValue * Math.random());
}
}
return arr;
}
/**
* 输出数组的元素
*
* @param arr 数组
*/
public static void printArray(int[] arr) {
System.out.println("");
System.out.println("+++++++++++++++++++++++++++++++++++++++++++++++++++START");
for (int value : arr) {
System.out.print(value + " ");
}
System.out.println("");
System.out.println("+++++++++++++++++++++++++++++++++++++++++++++++++++END");
}
public static void comparator(int[] arr) {
Arrays.sort(arr);
}
/**
* 重新复制一个新数组
*
* @param arr 待复制的数组
* @return 返回复制的新数组
*/
public static int[] copyArray(int[] arr) {
if (arr == null) {
return null;
}
int[] res = new int[arr.length];
System.arraycopy(arr, 0, res, 0, arr.length);
return res;
}
/**
* 比较两个数组的元素是否相等
*
* @param arr1 待比较的数组 1
* @param arr2 待比较的数组 2
* @return 返回校验结果 true/false
*/
public static boolean isEqual(int[] arr1, int[] arr2) {
if (arr1 == null && arr2 == null) {
return true;
}
if (arr1 == null || arr2 == null) {
return false;
}
if (arr1.length != arr2.length) {
return false;
}
for (int i = 0; i < arr1.length; i++) {
if (arr1[i] != arr2[i]) {
return false;
}
}
return true;
}
/**
* 测试排序方法的排序结果是否正确
*
* @param consumer 回调用户自定义的排序方法
* @param maxSize 数组最大长度
* @param maxValue 数组中最大的数，即 0 - maxValue
*/
public static void testSort(Consumer<int[]> consumer, int maxSize, int maxValue) {
testSort(consumer, maxSize, maxValue, true);
}
public static void testSort(Consumer<int[]> consumer, int maxSize, int maxValue, boolean flag) {
int testTime = 5000;
boolean succeed = true;
for (int i = 0; i < testTime; i++) {
// 生成新数组
int[] arr1 = ArraySortUtils.generateRandomArray(maxSize, maxValue, flag);
// 复制新数组
int[] arr2 = copyArray(arr1);
// 回调用户自定义的排序方法，对 arri1 排序
consumer.accept(arr1);
// 使用系统自带的排序方法，对 arr2 排序
comparator(arr2);
// 比较两种处理结果是否一致
if (!isEqual(arr1, arr2)) {
succeed = false;
printArray(arr1);
printArray(arr2);
break;
}
}
// 输出测试结果
System.out.println(succeed ? "Nice!" : "Fail!");
}
}
3、小结
计数排序和基数排序，对要排序的数据都有比较苛刻的数据要求，应用不是非常广泛。但是如果数据特征比较符合这些算法的要求，应用这些算法，会非常的搞笑，线性时间复杂度可以达到 O(N)。
计数排序是一种特殊的桶排序，都是针对范围不大的数据，将数据划分成不同的桶来实现排序。计数排序要求数据可以划分成高低位，位之间有递进关系。比较两个数，我们只需比较高位，高位相同的再去比较低位。而且每一位的数据范围不能太大，因为基数排序算法需要借助桶排序或者计数排序来完成每一位的排序工作。
