排序——非基于比较的排序

本专栏和大家分享关于排序的算法,其中有插入排（直接插入排序和希尔排序）、选择排序（直接选择排序和堆排）、交换排序（冒泡排序和快速排序）、归并排序以及其他非基于比较的排序

本文与大家分享非基于比较的排序

目录

计数排序

步骤：

基数排序

具体步骤如下

桶排序

感谢您的访问！！期待您的关注！！！

---

计数排序

步骤：

1. 统计相同元素出现次数

2. 根据统计的结果将序列回收到原来的序列中

当数据基本集中在某一个范围时，推荐使用计数排序

本质就是

我们对原数组进行遍历,每次将count[arr[i] - min]++,最后就会得到:

实际上我们在上面对count赋值的操作就已经将数组排序好了,此时,count数组的下标 + min 就是原来在array里面的元素,下标对应的值就是该元素出现的个数

 public static void countSort(int[] array){
         int max = array[0];
         int min = array[0];
         for (int i = 1; i < array.length; i++) {
             if(max < array[i]){
                 max = array[i];
             }
             if(min > array[i]){
                 min = array[i];
             }
         }
         int[] count = new int[max - min + 1];
         for (int i = 0; i < array.length; i++) {
             count[array[i] - min]++;
         }
 ​
         int k = 0;
         for(int i = 0; i < count.length; i++){
             while(count[i] != 0){
                 array[k++] = i + min;
                 count[i]--;
             }
         }
     }

时间复杂度：O(范围+N)

其中范围=max - min,最好集中一点

空间复杂度：O(范围)

稳定性：稳定

---

基数排序

具体步骤如下

假设我们有如上图所示的数组,我们需要准备10个容器

首先,我们要根据数组每一个元素的个位上的数字,将元素放到对应的容器里面

再按顺序出来

此时就会发现,所有的数据已经"根据个位"排好序了,那么我们就按照"十位"的数字再次进行同样的操作

再按照个位:

最终得到的就是有序的

 public class RadixSort {
     public static void radixSort(int[] array){
         int max = array[0];
         for(int i = 0; i < array.length; i++){
             if(max < array[i]){
                 max = array[i];
             }
         }
         int count = (int)Math.log10(max) + 1;
         Queue<Integer>[] lists = new LinkedList[10];
         for(int i = 0; i < 10; i++){
             lists[i] = new LinkedList<>();
         }
         for(int i = 0; i < count; i++){
             for (int j = 0; j < array.length; j++) {
                 int k = (i == 0 ? array[j] % 10 : (array[j] / (int)Math.pow(10,i) % 10));
                 lists[k].offer(array[j]);
             }
             int index = 0;
             for(int j = 0; j < lists.length;j++){
                 int n = lists[j].size();
                 while(n != 0){
                     n--;
                     array[index++] = lists[j].poll();
                 }
             }
         }
     }
 }

---

桶排序

实际上是计数排序的优化版

假设我们的数组是这样的,在桶排序里面,我们需要建立多个桶,每个桶存放一定范围的数据,再针对每个通进行排序,最后再把桶里的数据拿出来

我们首先要考虑的是桶的个数,假设我们每个桶放10个元素,在上面的数据中,最大值max = 821.最小值min=28,我们可以利用公式(max - min) / 10 + 1,得到桶的个数

接下来我们即利用元素与下标的映射关系将元素放到对应的桶里面去,映射关系为index = (array[i] - min) / 10,

再针对每个桶进行排序,再将桶里的元素拿出来即可

代码:

 public class BucketSort {
     public static void bucketSort(int[] array){
         int max = array[0];
         int min = array[0];
         for (int x : array){
             max = Math.max(x,max);
             min = Math.min(x,min);
         }
         int n = (max - min) / 10 + 1; //每个桶放10个元素
         List<Integer>[] lists = new ArrayList[n];
         for(int i = 0; i < n; i++){
             lists[i] = new ArrayList<>();
         }
         for(int i = 0; i < array.length; i++){
             int index = (array[i] - min) / 10;
             lists[index].add(array[i]);
         }
         for(int i = 0; i < n; i++) {
             Collections.sort(lists[i]);
         }
         int k = 0;
         for(int i = 0; i < n; i++){
             int size = lists[i].size();
             for(int x : lists[i]){
                 array[k++] = x;
             }
         }
     }
 }

感谢您的访问！！期待您的关注！！！