算法 - 排序 - 桶排序

1. 简介

桶排序(Bucket sort)是计数排序的升级版。它利用了函数的映射关系，高效与否的关键就在于这个映射函数的确定。

工作原理：假设输入数据服从均匀分布，将数据分到有限数量的桶里，每个桶再分别排序（有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排序。

9.1 算法描述

设置一个BucketSize，作为每个桶所能放置多少个不同数值

设置一个定量的数组当作空桶；
遍历输入数据，并且把数据一个一个放到对应的桶里去；
对每个不是空的桶进行排序；
从不是空的桶里把排好序的数据拼接起来。
注意，如果递归使用桶排序为各个桶排序，则当桶数量为1时要手动减小BucketSize增加下一循环桶的数量，否则会陷入死循环，导致内存溢出。

2. 算法分析

桶排序最好情况下使用线性时间O(n)，桶排序的时间复杂度，取决与对各个桶之间数据进行排序的时间复杂度，因为其它部分的时间复杂度都为O(n)。很显然，桶划分的越小，各个桶之间的数据越少，排序所用的时间也会越少。但相应的空间消耗就会增大。

排序方式：out-place

时间复杂度：

最佳情况：T(n) = O(n+k)
最差情况：T(n) = O(n2)
平均情况：T(n) = O(n+k)
空间复杂度：O(N+M)

3. 动图演示

4. 代码

    public static void main(String[] args) {
        long[] arrs = RandomArr.createLongArr(50, 0, 200);
        long[] arrs2 = Arrays.copyOf(arrs, arrs.length);
        Arrays.stream(arrs).forEach(l -> {
            System.out.print(l + " ");
        });
        System.out.println();

        bucketSort(arrs);

        Arrays.stream(arrs).forEach(l -> {
            System.out.print(l + " ");
        });
        System.out.println();
        Arrays.stream(arrs2).sorted().forEach(l -> {
            System.out.print(l + " ");
        });
    }


    /***
     * @param arrs
     */
    public static void bucketSort(long[] arrs) {

        // 取最大值、最小值
        long largest = arrs[0];
        long minimum = arrs[0];
        for (int i = 1; i < arrs.length; i++) {
            if (arrs[i] > largest) {
                largest = arrs[i];
            }
            if (arrs[i] < minimum) {
                minimum = arrs[i];
            }
        }

        // 桶数量 c (10)表示间隔 max / 10 - min / 10 + 1
        int bucketNum = (int) (largest / 10 - minimum / 10 + 1);
        List[] bucketList = new List[bucketNum];
        for (int i = 0; i < arrs.length; i++) {
            int index = (int) (arrs[i] / 10 - minimum / 10);
            if (bucketList[index] != null) {
                bucketList[index].add(arrs[i]);
            } else {
                List list = new ArrayList<>();
                list.add(arrs[i]);
                bucketList[index] = list;
            }
        }

        // 对桶内元素进行排序，并且回归到原数组
        for (int i = 0,index = 0; i < bucketList.length; i++) {
            if(bucketList[i] != null && bucketList[i].size() > 0){
                // 对桶内元素进行排序
                Collections.sort(bucketList[i]);
                for (int j = 0; j < bucketList[i].size(); j++) {
                    arrs[index] = (long) bucketList[i].get(j);
                    index++;
                }
            }
        }
    }