计数排序、桶排序、基数排序

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Sort {
    // 打印函数
    public static void print(int[] numbers) {
        for (int i = 0; i < numbers.length; i++) {
            System.out.print(numbers[i] + " ");
        }
        System.out.println();
    }

    /**
     * 基数排序
     */
    public static void radixSort(int[] numbers) {
        int n = 1;
        int k = 0;
        int len = numbers.length;

        int max = numbers[0];
        for (int i = 0; i < len; i++) {
            if (max < numbers[i]) {
                max = numbers[i];
            }
        }

        // 计算出需要比较到位数
        int times = 0;
        while (max != 0) {
            times++;
            max /= 10;
        }

        // 二维数组的行为按0-9形成的桶，len取number.length是保证桶能够放下所有的数字
        int[][] bucket = new int[10][len];
        // 用于保存每个桶里元素的个数
        int[] order = new int[10];
        while (n <= times) {
            for (int num : numbers) {
                int digit = num / (int) Math.pow(10, n - 1) % 10;
                bucket[digit][order[digit]] = num;
                order[digit]++;
            }

            for (int i = 0; i < len; i++) {
                // 如果桶里有数据，从上到下遍该桶历并保存到原数组中
                if (order[i] != 0) {
                    for (int j = 0; j < order[i]; j++) {
                        numbers[k] = bucket[i][j];
                        k++;
                    }
                }
                order[i] = 0; //将桶里计数器置0，用于下一位排序
            }
            n++;
            k = 0;
        }
    }

    /**
     * 基数排序
     * 时间复杂度为O(nlog(r)m)，其中r为所采取的基数，而m为堆数
     */
    public static int[] RadixSort(int[] array) {
        if (array == null || array.length < 2)
            return array;
        // 1.先算出最大数的位数；
        int max = array[0];
        for (int i = 1; i < array.length; i++) {
            max = Math.max(max, array[i]);
        }
        int maxDigit = 0;
        while (max != 0) {
            max /= 10;
            maxDigit++;
        }
        int mod = 10, div = 1;
        ArrayList<ArrayList<Integer>> bucketList = new ArrayList<ArrayList<Integer>>();
        for (int i = 0; i < 10; i++)
            bucketList.add(new ArrayList<Integer>());
        for (int i = 0; i < maxDigit; i++, mod *= 10, div *= 10) {
            for (int j = 0; j < array.length; j++) {
                int num = (array[j] % mod) / div;
                bucketList.get(num).add(array[j]);
            }
            int index = 0;
            for (int j = 0; j < bucketList.size(); j++) {
                for (int k = 0; k < bucketList.get(j).size(); k++)
                    array[index++] = bucketList.get(j).get(k);
                bucketList.get(j).clear();
            }
        }
        return array;
    }

    /**
     * 桶排序
     * 被排序的数组内的数值是均匀分配的时候，桶排序时间复杂度（Ο(n)）
     */
    public static List<Integer> BucketSort(List<Integer> array, int bucketSize) {
        if (array == null || array.size() < 2)
            return array;
        int max = array.get(0), min = array.get(0);
        // 找到最大值最小值
        for (int i = 0; i < array.size(); i++) {
            if (array.get(i) > max)
                max = array.get(i);
            if (array.get(i) < min)
                min = array.get(i);
        }
        int bucketCount = (max - min) / bucketSize + 1;
        ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketCount);
        ArrayList<Integer> resultArr = new ArrayList<>();
        for (int i = 0; i < bucketCount; i++) {
            bucketArr.add(new ArrayList<Integer>());
        }
        for (int i = 0; i < array.size(); i++) {
            bucketArr.get((array.get(i) - min) / bucketSize).add(array.get(i));
        }
        for (int i = 0; i < bucketCount; i++) {
            if (bucketCount == 1)
                bucketSize--;
            List<Integer> temp = BucketSort(bucketArr.get(i), bucketSize);
            for (int j = 0; j < temp.size(); j++)
                resultArr.add(temp.get(j));
        }
        return resultArr;
    }

    /**
     * 计数排序
     * 空间换时间
     * 时间复杂度为Ο(n+k)（其中k是整数的范围）
     */
    public static int[] CountingSort(int[] array) {
        if (array.length == 0) return array;
        int bias, min = array[0], max = array[0];
        for (int i = 1; i < array.length; i++) {
            if (array[i] > max)
                max = array[i];
            if (array[i] < min)
                min = array[i];
        }
        bias = 0 - min;
        int[] bucket = new int[max - min + 1];
        Arrays.fill(bucket, 0);
        for (int i = 0; i < array.length; i++) {
            bucket[array[i] + bias]++;
        }
        int index = 0, i = 0;
        while (index < array.length) {
            if (bucket[i] != 0) {
                array[index] = i - bias;
                bucket[i]--;
                index++;
            } else
                i++;
        }
        return array;
    }

    public static void main(String[] args) {
        int[] numbers = new int[]{278, 109, 63, 930, 589, 184, 505, 269, 8, 83};
        List<Integer> list = new ArrayList<>();
        list.add(278);
        list.add(109);
        list.add(298);
        list.add(28);
        //桶排序测试
        System.out.println(BucketSort(list, 100));
        //计数排序测试
        CountingSort(numbers);
        print(numbers);

        //基数排序测试
        radixSort(numbers);
        print(numbers);
    }
}