【算法】计数排序、桶排序、基数排序

算法系列八：非比较排序

一、计数排序

1.实现

1.1步骤

1.2代码

2.性质

2.1稳定性

2.1.1从前往后前始版：

2.1.2从后往前末始版：

2.2复杂度

2.2.1时间复杂度

2.2.2空间复杂度

二、桶排序

1.实现

1.1步骤

1.2代码

2.稳定性

三、基数排序

1.原理

2.代码

鸽巢原理

鸽子归巢，待排序数据归到有序组群中按大小归进有序组群来排，数越大，归到的有序组就在越后的，数越小，归到的有序组就在越前的

  • 如果有序组以一个元素一个元素划分的，实现的是元素组归巢排序，即计数排序
  • 如果有序组按范围多个元素为一组划分的，实现的是范围组归巢排序，即桶排序

一、计数排序

1.实现

1.1步骤

  1. 开辟数据范围内的所有元素都有各自对应的元素组巢穴，范围内一共有多少种个数据，就开辟每种个数据都有对应的多大的数组，比如90(max) - 10(min) = 80(种个数据)
  2. 归巢时，通过该数据-数据范围内的最小值得到所归巢的下标，然后在数组元素巢中计数表示归巢
  3. 因为巢内只有一种个数据直接就是有序的，所以所有数据归完巢在巢层面有序时所有数据就已经有序了，最后将它们按顺序地赶出巢加回去即得原来有序的数据

1.2代码

  1.     public static void countSort(int[] array) {
  2.         //1.求当前数据的最大值和最小值
  3.         int minVal = array[0];
  4.         int maxVal = array[0];
  5.         for (int i = 1; i < array.length; i++) {
  6.             if(array[i] < minVal) {
  7.                 minVal = array[i];
  8.             }
  9.             if(array[i] > maxVal) {
  10.                 maxVal = array[i];
  11.             }
  12.         }
  13.  
  14.         //2.根据数据最大值和最小值来确定元素组巢穴数组的大小
  15.         int[] count = new int[maxVal-minVal+1];
  16.  
  17.         //3.遍历原来的数据进行归巢排序
  18.         for (int i = 0; i < array.length; i++) {
  19.             count[array[i]-minVal]++;
  20.         }
  21.  
  22.         //4.将元素组巢穴里已排好序的数据按顺序写回array
  23.         int index = 0;//重新表示array数组的下标
  24.         for (int i = 0; i < count.length; i++) {
  25.             while (count[i] > 0) {
  26.                 array[index] = i+minVal;
  27.                 index++;
  28.                 count[i]--;
  29.             }
  30.         }
  31.     }
  32. }

2.性质

2.1稳定性

将每个数据都归到巢中完成有序时，根据巢中有序来的元素的计数个数，可以将巢改装成装每种个元素有序排的始位置，通过对应顺序遍历原数组将数据正确稳定地放在排好序的各自位置上，能实现稳定的排序，所以计数排序是稳定的排序

2.1.1从前往后前始版：

原本巢中装的是鸽子的计数数量，现在巢里面改装成装种个鸽子从前往后的起始位置来进行排序：

2.1.2从后往前末始版：

 巢里面改装成装种个鸽子从后往前的起始位置来进行排序：

2.2复杂度

2.2.1时间复杂度

找最大最小值确定范围种个数据遍历原数组用了n，原数组数据每个去归巢用了n，范围x种个元素巢每个去赶，所以时间复杂度为2n + x，即O(n+x)

2.2.2空间复杂度

范围x种个数据需要开辟x个元素巢的数组，所以空间复杂度为O(x)

二、桶排序

1.实现

1.1步骤

  1. 开辟数据范围内所有元素都有对应的范围数组组巢穴，将所有数据入范围组巢穴先进行第一轮巢穴外的排好序，此时巢外已经有序了
  2. 再进行第二轮各自巢穴内的排好序，此时就巢外、巢内都有序所有数据都有序了
  3. 最后按顺序地将它们从数组巢中赶出即得有序的数据

1.2代码

  1.     public static int[] bucketSort(int[] arr) {
  2.         // 边界条件：空数组或单个元素直接返回
  3.         if (arr.length <= 1) {
  4.             return arr.clone();
  5.         }
  6.  
  7.         // Step 1: 确定数据范围
  8.         int minVal = Integer.MAX_VALUE;
  9.         int maxVal = Integer.MIN_VALUE;
  10.         for (int num : arr) {
  11.             if (num < minVal) minVal = num;
  12.             if (num > maxVal) maxVal = num;
  13.         }
  14.  
  15.         // 处理所有元素相同的情况
  16.         if (maxVal == minVal) {
  17.             return arr.clone();
  18.         }
  19.  
  20.         // Step 2: 初始化桶
  21.         int bucketCount = (int) Math.sqrt(arr.length) + 1; // 桶数量=数组长度的平方根（经验值）
  22.         double bucketRange = (double)(maxVal - minVal) / bucketCount;
  23.  
  24.         List> buckets = new ArrayList<>(bucketCount);
  25.         for (int i = 0; i < bucketCount; i++) {
  26.             buckets.add(new ArrayList<>());
  27.         }
  28.  
  29.         // Step 3: 元素分配到桶中
  30.         for (int num : arr) {
  31.             // 计算元素应该属于哪个桶
  32.             int index = (int)((num - minVal) / bucketRange);
  33.             // 处理最大值刚好落在最后一个桶外的情况
  34.             if (index == bucketCount) index--;
  35.             buckets.get(index).add(num);
  36.         }
  37.  
  38.         // Step 4: 对每个桶内部排序
  39.         for (List bucket : buckets) {
  40.             Collections.sort(bucket); // 使用内置排序算法，决定了桶排序的稳定性
  41.         }
  42.  
  43.         // Step 5: 合并桶
  44.         int[] sortedArr = new int[arr.length];
  45.         int idx = 0;
  46.         for (List bucket : buckets) {
  47.             for (int num : bucket) {
  48.                 sortedArr[idx++] = num;
  49.             }
  50.         }
  51.  
  52.         return sortedArr;
  53.     }

2.稳定性

稳定性取决于在第二轮巢内开始排相同大小的元素时所用的排序方法是否具有稳定性

三、基数排序

1.原理

  1. 先进行个位排序，能实现个位一位数有序
  2. 个位有序下，再进行十位优先排序，能实现十位个位两位数有序
  3. 十个位有序下，再进行百位优先排序，能实现百位十位个位三位数有序

2.代码

  1.     public static int[] radixSort(int[] arr) {
  2.         if (arr.length <= 1) {
  3.             return arr.clone();
  4.         }
  5.  
  6.         // Step 1: 确定最大数的位数
  7.         int maxNum = Integer.MIN_VALUE;
  8.         for (int num : arr) {
  9.             if (num > maxNum) maxNum = num;
  10.         }
  11.  
  12.         // Step 2: 按每位进行计数排序（从低位到高位）
  13.         int exp = 1; // 从个位开始
  14.         while (maxNum / exp > 0) {
  15.             // 初始化10个数字桶（0-9）
  16.             List> buckets = new ArrayList<>(10);
  17.             for (int i = 0; i < 10; i++) {
  18.                 buckets.add(new ArrayList<>());
  19.             }
  20.  
  21.             // 按当前位分配到桶中
  22.             for (int num : arr) {
  23.                 int digit = (num / exp) % 10; // 提取当前位的数字
  24.                 buckets.get(digit).add(num);
  25.             }
  26.  
  27.             // 重组数组
  28.             int idx = 0;
  29.             for (List bucket : buckets) {
  30.                 for (int num : bucket) {
  31.                     arr[idx++] = num;
  32.                 }
  33.             }
  34.  
  35.             exp *= 10; // 处理更高位
  36.         }
  37.  
  38.         return arr;
  39.     }
注：本文转载自blog.csdn.net的Brookty的文章"https://blog.csdn.net/2401_86112610/article/details/147339315"。版权归原作者所有，此博客不拥有其著作权，亦不承担相应法律责任。如有侵权，请联系我们删除。
复制链接
相关推荐
发表评论

评论记录：

未查询到任何数据！