【java数据结构】其他非基于比较排序

博客最后附有整篇博客的全部代码！！！

一、计数排序

场景：集中在某个范围内的一组数据

思路：

1. 找到这组序列的最大值和最小值，通过最大值和最小值来确定数组大小
2. 遍历原数组，存储每个元素出现的次数
3. 将每个元素直接赋值给原数组

时间复杂度：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; 这里也可以自己定义桶的范围大小。

此篇博客的全部代码！！！