1.1概述

桶排序是计数排序的升级版。它利用了函数的映射关系，高效与否的关键就在于这个映射函数的确定。
桶排序 (Bucket sort)的工作的原理：假设输入数据服从均匀分布，将数据分到有限数量的桶里，每个桶再分别排序（有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排序)

1.2描述

• 设置一个定量的数组当作空桶；
• 遍历输入数据，并且把数据一个一个放到对应的桶里去；
• 对每个不是空的桶进行排序；
• 从不是空的桶里把排好序的数据拼接起来。

1.3代码

package bucketsort;

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

/**
 * @author xgj
 */
public class BucketSort {
    public static void main(String[] args) {
        int[] res = new int[]{1,6,5,4,6,2,7,9};
        BucketSort.bucketSort(res);
        System.out.println(Arrays.toString(res));

    }

    public static void bucketSort(int[] ints) {
        //1. 构造桶
        //1.1 确定桶的个数n
        int n = ints.length;
        //1.2 声明并初始化一个List，存放链表；
        List<ArrayList<Integer>> blast = new ArrayList<>(n);
        for (int i = 0; i < n; i++) {
            blast.add(new ArrayList<Integer>(5));
        }
        //2.将数组中的元素放到桶中
        //2.1 确定元素的最值
        int max = Integer.MIN_VALUE;
        int min = Integer.MAX_VALUE;
        for (int a : ints) {
            max = Math.max(max, a);
            min = Math.min(min, a);
        }
        //2.2 确定每个元素放入桶的编号并放进去
        for (int i : ints) {
            //2.2.1 确定桶的编号
            int len = ints.length;
            //加1是为了保证index< ints.length，防止程序抛出IndexOutOfBoundsEx;
            int index = (int) ((i - min) / (max - min + 1.0) * ints.length);
            //2.2.2 放入对应的桶中
            blast.get(index).add(i);
        }
        //3.桶内排序
        for (int i = 0; i < blast.size(); i++) {
            java.util.Collections.sort(blast.get(i));
        }
        //4.合并数据
        int j = 0;
        for (ArrayList<Integer> arr : blast) {
            for (int i : arr) {
                ints[j++] = i;
            }
        }
    }
}

1.4分析

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

桶排序（BucketSort）

原文：https://www.cnblogs.com/jiezao/p/13357952.html