【java数据结构】其他非基于比较排序
- 一、计数排序
- 二、基数排序
- 三、桶排序
博客最后附有整篇博客的全部代码！！！
一、计数排序
场景：集中在某个范围内的一组数据
思路：
- 找到这组序列的最大值和最小值，通过最大值和最小值来确定数组大小
- 遍历原数组，存储每个元素出现的次数
- 将每个元素直接赋值给原数组
时间复杂度：O（N+范围）
空间复杂度：O（范围）
稳定性：稳定
public static void countingSort(int[] arr) {
if (arr == null || arr.length == 0) {
return; // 如果数组为空或长度为0，直接返回
}
// 找到数组中的最大值和最小值
int maxValue = arr[0];
int minValue = arr[0];
for (int num : arr) {
if (num > maxValue) {
maxValue = num;
}
if (num < minValue) {
minValue = num;
}
}
// 计数数组的大小为最大值和最小值的差值加1
int range = maxValue - minValue + 1;
int[] countArray = new int[range];
// 统计每个元素出现的次数
for (int num : arr) {
countArray[num - minValue]++;
}
int index = 0;
for(int i = 0; i < countArray.length; i++) {
while(countArray[i]!=0){
arr[index++] = i+minValue;
countArray[i]--;
}
}
}
二、基数排序
思想：
基数排序是桶排序的扩展，他的基本思想是：将整数按位切割成不同的数字，然后按每个位数分别比较。
具体做法是：将所有待比较数值统一为同样的位数长度，数位较短的数前边补零。然后，从最低位开始，依次进行一次排序，这样从最低位排序一直到最高位排序完成后，就变成一个有序数列。
（k是最大值的位数， r 是基数，即每一位可能的数字范围（通常是 0 到 9，因此 r=10））
时间复杂度：O(k⋅(n+r))，在 k 是常数时简化为 O(n)
空间复杂度：O(n+r)，在 r 是常数时简化为 O(n)
稳定性：稳定的
通过一个实例更好的帮你理解：
给定一组未排序列，首先获取最大值，并且获取最大值的位数（作用：创建数组和循环次数）
int max = arr[0];
for (int i = 0; i < arr.length; i++) {
if (arr[i] > max) {
max = arr[i];
}
}
//获取最大值的位数
int count = 0;
while(max>=10){
max=max/10;
count++;
}
count=count+1;
基数排序核心代码就是接下来的两个循环：
//申请所需要的内存空间
//nums用来存储元素
int[][] nums = new int[10][arr.length - 1];
//numsCount是用来计数
int[] numsCount = new int[10];
int n = 1;
for (int h = 0; h < count; h++) {
for (int i = 0; i < arr.length; i++) {
int element = arr[i] / n % 10;
nums[element][numsCount[element]] = arr[i];
numsCount[element]++;
}
int index = 0;
for (int k = 0; k < numsCount.length; k++) {
if (numsCount[k] != 0) {
for (int i = 0; i < numsCount[k]; i++) {
arr[index] = nums[k][i];
index++;
}
}
numsCount[k] = 0;
}
n = n * 10;
}
第一步，先除1再除10取余，得到的数对应到新创建的nums的数组下标，numsCount++，最后再将nums数组中的元素按照顺序取出。
第二步，先除10再除10取余，按照上面的步骤进行。
第三步，先除100再除10取余，按照上面的步骤进行。
这里的步数取决于你最大值的位数，我这里最大值是100，所以有三步。
三、桶排序
思路：
-
桶排序是计数排序的扩展版本，计数排序可以看成每个桶只存储相同元素，而桶排序每个桶存储一定范围的元素，通过映射函数，将待排序数组中的元素映射到各个对应的桶中，对每个桶中的元素进行排序，最后将非空桶中的元素逐个放入原序列中。
-
桶排序需要尽量保证元素分散均匀，否则当所有数据集中在同一个桶中时，桶排序失效。
public static void bucketSort(int[] arr) {
if (arr == null || arr.length == 0) {
return; // 如果数组为空或长度为0，直接返回
}
// 找到数组中的最大值和最小值
int maxValue = arr[0];
int minValue = arr[0];
for (int num : arr) {
if (num > maxValue) {
maxValue = num;
}
if (num < minValue) {
minValue = num;
}
}
int bucketCount = (maxValue - minValue) / arr.length + 1;
//创建桶
List<List<Integer>> bucket = createBucket(bucketCount);
//将元素放入桶中
for (int value : arr) {
int index = (value - minValue) / arr.length;
bucket.get(index).add(value);
}
//排序并合并
sortAndMerge(bucket, arr, minValue);
}
private static void sortAndMerge(List<List<Integer>> bucket, int[] arr, int minValue) {
//先对每个桶用计数排序进行排序
for (int i = 0; i < bucket.size(); i++) {
countingSort2(bucket.get(i));
}
int index = 0;
for (int i = 0; i < bucket.size(); i++) {
for (int j = 0; j < bucket.get(i).size(); j++) {
arr[index++] = bucket.get(i).get(j);
}
}
}
private static List<List<Integer>> createBucket(int bucketCount) {
List<List<Integer>> bucket = new ArrayList<List<Integer>>(bucketCount);
for (int i = 0; i < bucketCount; i++) {
bucket.add(new ArrayList<>());
}
return bucket;
}
public static void countingSort2(List<Integer> list) {
if (list == null || list.size() == 0) {
return; // 如果链表为空或长度为0，直接返回
}
// 找到链表的最大值和最小值
int maxValue = list.get(0);
int minValue = list.get(0);
for (int num : list) {
if (num > maxValue) {
maxValue = num;
}
if (num < minValue) {
minValue = num;
}
}
// 计数链表的大小为最大值和最小值的差值加1
int range = maxValue - minValue + 1;
int[] countArray = new int[range];
// 统计每个元素出现的次数
for (int num : list) {
countArray[num - minValue]++;
}
list.clear();
int index = 0;
for (int i = 0; i < countArray.length; i++) {
while (countArray[i] != 0) {
list.add(i + minValue);
countArray[i]--;
}
}
}
桶的大小以及多少是根据自己的需求而定，我这里只是为完成桶排序而随便设置的桶的数量。**int bucketCount = (int) Math.sqrt(array.length);**一般情况下是这样确定桶的数量，这样得出来的数据分布比较均匀。int range = max - min + 1;int bucketCount = range / 10; 这里也可以自己定义桶的范围大小。
此篇博客的全部代码！！！
