桶排序

桶排序
    桶排序是计数排序的升级版。它利用了函数的映射关系，高效与否的关键就在于这个映射函数的确定。为了使桶排序更加高效，我们需要做到这两点：

1. 在额外空间充足的情况下，尽量增大桶的数量

2. 使用的映射函数能够将输入的 N 个数据均匀的分配到 K 个桶中

同时，对于桶中元素的排序，选择何种比较排序算法对于性能的影响至关重要。

1. 什么时候最快

当输入的数据可以均匀的分配到每一个桶中。

 

2. 什么时候最慢

当输入的数据被分配到了同一个桶中。

 

3. 示意图

4. Java 代码实现

    /**
     * 桶排序
     *
     * @param arr
     */
    public static void bucketSort(Integer[] arr) {
        System.out.println("bucketSort===");
        PrintUtil.printArr(arr);

        /**
         * 每个桶的容量
         */
        int bucketSize = 5;

        int len = arr.length;

        // find min max
        int minValue = arr[0];
        int maxValue = arr[0];
        for (int value : arr) {
            if (value < minValue) {
                minValue = value;
            } else if (value > maxValue) {
                maxValue = value;
            }
        }

        /**
         * 所需桶的个数
         */
        int bucketCount = (int) Math.floor((maxValue - minValue) / bucketSize) + 1;
        Integer[][] buckets = new Integer[bucketCount][0];

        /**
         * 利用映射函数将数据分配到各个桶中
         * eg: 4 2 3     7 5 6    12 10 9
         */

        for (int i = 0; i < len; i++) {
            int index = (int) Math.floor((arr[i] - minValue) / bucketSize);
            // 新值插入桶中，并更新数组
            buckets[index] = arrAppend(buckets[index], arr[i]);
        }

        int arrIndex = 0;
        for (Integer[] bucket : buckets) {
            if (bucket.length <= 0) {
                // 桶中无值
                continue;
            }
            // 对每个桶进行排序，这里使用了插入排序
            insertionSort(bucket);

            for (int value : bucket) {
                // 重新写入值
                arr[arrIndex++] = value;
            }
        }

        // after
        PrintUtil.printArr(arr);
    }

    /**
     * 自动扩容，并保存数据
     *
     * @param arr
     * @param value
     */
    private static Integer[] arrAppend(Integer[] arr, int value) {
        arr = Arrays.copyOf(arr, arr.length + 1);
        arr[arr.length - 1] = value;
        return arr;
    }