用Java写算法之八：桶排序

前面的排序都是比较常规的排序，但下面这个排序也许就不是那么常规了，它就是桶排序。

算法概述/思路

桶排序的思想近乎完全的分治思想。假设如今须要对一亿个数进行排序。咱们能够将其等长地分到10000个虚拟的“桶”里面，这样，平均每一个桶只有10000个数。若是每一个桶都有序了，则只须要依次输出为有序序列便可。具体思路是这样的：

1.将待排数据按一个映射函数f(x)分为连续的若干段。理论上最佳的分段方法应该使数据平均分布；实际上，一般采用的方法都作不到这一点。显然，对于一个已知输入范围在【0，10000】的数组，最简单的分段方法莫过于x/m这种方法，例如，f(x)=x/100。

“连续的”这个条件很是重要，它是后面数据按顺序输出的理论保证。

2.分配足够的桶，按照f(x)从数组起始处向后扫描，并把数据放到合适的桶中。对于上面的例子，若是数据有10000个，则咱们须要分配101个桶（由于要考虑边界条件：f(x)=x/100会产生【0，100】共101种状况），理想状况下，每一个桶有大约100个数据。

3.对每一个桶进行内部排序，例如，使用快速排序。注意，若是数据足够大，这里能够继续递归使用桶排序，直到数据大小降到合适的范围。

4.按顺序从每一个桶输出数据。例如，1号桶【112，123，145，189】，2号桶【234，235，250，250】，3号桶【361】，则输出序列为【112，123，145，189，234，235，250，250，361】。

5.排序完成。

代码实现

public static void bucketSort(int[] arr){
    //分桶，这里采用映射函数f(x)=x/10。
    //输入数据为0~99之间的数字
    int bucketCount =10;
    Integer[][] bucket = new Integer[bucketCount][arr.length];  //Integer初始为null,以与数字0区别。
    for (int i=0; i<arr.length; i++){
        int quotient = arr[i]/10;   //这里便是使用f(x)
        for (int j=0; j<arr.length; j++){
            if (bucket[quotient][j]==null){
                bucket[quotient][j]=arr[i];
                break;
            }
        }
    }
    //小桶排序
    for (int i=0; i<bucket.length; i++){
            //insertion sort
            for (int j=1; j<bucket[i].length; ++j){
                if(bucket[i][j]==null){
                    break;
                }
                int value = bucket[i][j];
                int position=j;
                while (position>0 && bucket[i][position-1]>value){
                    bucket[i][position] = bucket[i][position-1];
                    position--;
                }
                bucket[i][position] = value;
            }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
    }
    //输出
    for (int i=0, index=0; i<bucket.length; i++){
        for (int j=0; j<bucket[i].length; j++){
            if (bucket[i][j]!=null){
                arr[index] = bucket[i][j];
                index++;
            }
            else{
                break;
            }
        }
    }
}

实现难点

上面的代码并不长，可是却很差写。我在实现过程当中主要遇到了如下问题：

1.最重要的问题：如何得知每一个小桶须要多大？

显然，N个数平均分到M个桶，每一个桶的容量应该是N/M，但实际数据不可能这么平均。解决办法无非是增长桶的容量。那么，咱们应该增长到多少？

方案一：设定一个固定比例，例如使用10倍于平均的容量。这在不少时候可以解决问题，但遇到极端数据的时候容易出现问题。

方案二：极端增长空间大小，使得每一个桶固定装一个数，这须要限制输入数据不重复。可是，若是输入数据没有范围限制，咱们必须申请Integer.MAX_VALUE字节数据，而这必然会致使内存过大，引起Requested array size exceeds VM limit异常。但若是咱们知道其数据范围，例如[1,100000]，则是能够接受的方案。而且这样能够省去排序的步骤，能够达到线性复杂度，效率很高。

方案三：也就是示例中的代码，实际上性能并很差。它是把每一个小桶都作到和原始数组同样大，以牺牲不少空间来换取算法在极限状况下的健壮性。

2.如何克服Java数组的初始值？

若是是数值型数组，在分桶的时候容易因为建立数组时系统赋予的0值而给排序形成混乱，干扰结果。这里有两种状况：

A：若是输入数据明确不为零，则所受影响不大。只须要在输出和排序时注意判断，排除0值就好了。

B：若是数据可能为零，例如上述代码，这里的解决办法是申请Integer数组。因为系统初始值为null，咱们能够更明确地绕开0值。

算法性能/复杂度

桶排序的时间复杂度能够从每一步分开分析。

1.分桶的过程，遍历每一个元素、计算f(x)，将x放到桶中，共3n次计算，显然是O(n)复杂度；

2.最后输出也是O(n)复杂度；

3.关键是小桶内排序的过程：即便使用先进的比较排序算法，也不可绕开O(n㏒n)的下限。所以，每一个小桶的内部复杂度为n(k㏒k)，总得复杂度为∑(ki*㏒ki)[i=1...m]，其中m为桶的个数，ki为每一个桶的元素数。尽可能减小桶内数据的数量是提升效率的惟一办法(由于基于比较排序的最好平均时间复杂度只能达到O(N*logN)了)。所以，有两种方法：

1）使用更为平均的划分，使得不至于某个小桶的数据极多；

2）使用更多的桶，以减小每一个桶数据的数量。极限情况下，每一个桶只有一个数据，这样就彻底没有比较操做。可是，在数据极多的状况下，这样是很是不现实的，会形成严重的空间消耗。这时候就须要权衡时空间复杂度了。

总结起来，设数据共有N个，桶有M个，则桶排序平均复杂度为：

O(N)+O(N)+O((N/M)*㏒(N/M))=O(N+N*(logN-logM))=O(N+N*logN-N*logM)

最优情形下，桶排序的时间复杂度为O(n)。

桶排序的空间复杂度一般是比较高的，额外开销为O(N+M)（由于要维护M个数组的引用）。

算法稳定性

能够看出，在分桶和从桶依次输出的过程是稳定的。可是，因为咱们在第3步使用了其余算法，因此，桶排序的稳定性依赖于这一步。若是咱们使用了快排，显然，算法是不稳定的。

算法适用场景

桶排序在数据量很是大，而空间相对充裕的时候是很实用的，能够大大下降算法的运算数量级。此外，在解决一些特殊问题的时候，桶排序可能会起到意想不到的结果。参考资料中列出了一种。

参考资料

1.桶排序 http://hxraid.iteye.com/blog/647759