public static void countSort(int[] array) {
        //1.求當前數(shù)據(jù)的最大值和最小值
        int minVal = array[0];
        int maxVal = array[0];
        for (int i = 1; i < array.length; i++) {
            if(array[i] < minVal) {
                minVal = array[i];
            }
            if(array[i] > maxVal) {
                maxVal = array[i];
            }
        }

        //2.根據(jù)數(shù)據(jù)最大值和最小值來確定元素組巢穴數(shù)組的大小
        int[] count = new int[maxVal-minVal+1];

        //3.遍歷原來的數(shù)據(jù)進行歸巢排序
        for (int i = 0; i < array.length; i++) {
            count[array[i]-minVal]++;
        }

        //4.將元素組巢穴里已排好序的數(shù)據(jù)按順序?qū)懟豠rray
        int index = 0;//重新表示array數(shù)組的下標
        for (int i = 0; i < count.length; i++) {
            while (count[i] > 0) {
                array[index] = i+minVal;
                index++;
                count[i]--;
            }
        }
    }
}

    public static int[] bucketSort(int[] arr) {
        // 邊界條件：空數(shù)組或單個元素直接返回
        if (arr.length <= 1) {
            return arr.clone();
        }

        // Step 1: 確定數(shù)據(jù)范圍
        int minVal = Integer.MAX_VALUE;
        int maxVal = Integer.MIN_VALUE;
        for (int num : arr) {
            if (num < minVal) minVal = num;
            if (num > maxVal) maxVal = num;
        }

        // 處理所有元素相同的情況
        if (maxVal == minVal) {
            return arr.clone();
        }

        // Step 2: 初始化桶
        int bucketCount = (int) Math.sqrt(arr.length) + 1; // 桶數(shù)量=數(shù)組長度的平方根（經(jīng)驗值）
        double bucketRange = (double)(maxVal - minVal) / bucketCount;

        List<List<Integer>> buckets = new ArrayList<>(bucketCount);
        for (int i = 0; i < bucketCount; i++) {
            buckets.add(new ArrayList<>());
        }

        // Step 3: 元素分配到桶中
        for (int num : arr) {
            // 計算元素應該屬于哪個桶
            int index = (int)((num - minVal) / bucketRange);
            // 處理最大值剛好落在最后一個桶外的情況
            if (index == bucketCount) index--;
            buckets.get(index).add(num);
        }

        // Step 4: 對每個桶內(nèi)部排序
        for (List<Integer> bucket : buckets) {
            Collections.sort(bucket); // 使用內(nèi)置排序算法，決定了桶排序的穩(wěn)定性
        }

        // Step 5: 合并桶
        int[] sortedArr = new int[arr.length];
        int idx = 0;
        for (List<Integer> bucket : buckets) {
            for (int num : bucket) {
                sortedArr[idx++] = num;
            }
        }

        return sortedArr;
    }

    public static int[] radixSort(int[] arr) {
        if (arr.length <= 1) {
            return arr.clone();
        }

        // Step 1: 確定最大數(shù)的位數(shù)
        int maxNum = Integer.MIN_VALUE;
        for (int num : arr) {
            if (num > maxNum) maxNum = num;
        }

        // Step 2: 按每位進行計數(shù)排序（從低位到高位）
        int exp = 1; // 從個位開始
        while (maxNum / exp > 0) {
            // 初始化10個數(shù)字桶（0-9）
            List<List<Integer>> buckets = new ArrayList<>(10);
            for (int i = 0; i < 10; i++) {
                buckets.add(new ArrayList<>());
            }

            // 按當前位分配到桶中
            for (int num : arr) {
                int digit = (num / exp) % 10; // 提取當前位的數(shù)字
                buckets.get(digit).add(num);
            }

            // 重組數(shù)組
            int idx = 0;
            for (List<Integer> bucket : buckets) {
                for (int num : bucket) {
                    arr[idx++] = num;
                }
            }

            exp *= 10; // 處理更高位
        }

        return arr;
    }