桶排序和基数排序区别（算法+代码）

之前一直分不清桶排序和基数排序，现在拿出来这两比较一下

1、算法思路：

桶排序

桶排序(Bucket Sort)假设输入数据服从均匀分布，然后将输入数据均匀地分配到有限数量的桶中，然后对每个桶再分别排序，对每个桶再使用插入排序算法，最后将每个桶中的数据有序的组合起来。假设输入是由一个随机过程生成，该过程将元素均匀的分布在一个区间[a,b]上，在[a,b]之间放置一定数量的桶，由于桶排序和计数排序一样均对输入的数据进行了某些假设限制，因此比一般的基于比较的排序算法复杂度低。

基数排序

基数排序假设输入数据属于一个小区间内的整数，对每一位上进行进桶，出桶；根据关键字中各位的值，通过对排序的N个元素进行若干趟“分配”与“收集”来实现排序的。 

2、实现过程

桶排序过程

1.初始化装入连续区间元素的n个桶，每个桶用来装一段区间中的元素。

2.遍历待排序的数据，将其映射到对应的桶中，保证每个桶中的元素都在同一个区间范围中。

3.对每个桶进行排序，最终将所有桶中排好序的元素连起来。

图来自https://blog.csdn.net/cauchyweierstrass/article/details/49919559

扫描二维码关注公众号，回复： 183896 查看本文章

桶排序其中也蕴含着分治的策略，联想之前的计数排序，基数排序就像是桶排序的一个特例，一个数据一个桶。并且和散列(哈希，hash)似乎也有千丝万缕的关系。

基数排序实现过程

是根据关键字中各位的值，通过对排序的N个元素进行若干趟“分配”与“收集”来实现排序的。 

设有一个初始序列为: R {50, 123, 543, 187, 49, 30, 0, 2, 11, 100}。

我们知道，任何一个阿拉伯数，它的各个位数上的基数都是以0~9来表示的。

所以我们不妨把0~9视为10个桶。 

我们先根据序列的个位数的数字来进行分类，将其分到指定的桶中。例如：R[0] = 50，个位数上是0，将这个数存入编号为0的桶中。

分类后，我们在从各个桶中，将这些数按照从编号0到编号9的顺序依次将所有数取出来。

这时，得到的序列就是个位数上呈递增趋势的序列。 

按照个位数排序： {50, 30, 0, 100, 11, 2, 123, 543, 187, 49}。

接下来，可以对十位数、百位数也按照这种方法进行排序，最后就能得到排序完成的序列。

3、程序实现

桶排序的实现

[java]  view plain  copy

1. public int[] buketSort(int[] array, int backetSize) {  
2.     int[] result = new int[array.length];  
3.     Node[] bucket = new Node[backetSize];  
4.     for (int i = 0; i < bucket.length; i++) {  
5.         bucket[i] = new Node(); // 带头结点  
6.     }  
7.     for (int i = 0; i < array.length; i++) {  
8.         int bucketIndex = hash(array[i]);  
9.         Node node = new Node(array[i]);  
10.         Node p = bucket[bucketIndex];  
11.         if (p.next == null) {// 没有元素  
12.             p.next = node;  
13.         } else {// 已经有一个元素  
14.             while (p.next != null && p.next.data <= node.data) {  
15.                 p = p.next;  
16.             } // 跳出循环时候 该值小于下一个元  
17.             node.next = p.next;  
18.             p.next = node;  
19.         }  
20.     }  
21.     int j = 0;  
22.     for (int i = 0; i < bucket.length; i++) // 确定次数  
23.         for (Node p = bucket[i].next; p != null; p = p.next) // n/m  
24.             result[j++] = p.data;  
25.     return result;  
26. }  
27.   
28. private int hash(int value) {  
29.     return value / 10;  
30. }  

基数排序实现

public class RadixSort {  
    public int getDigit(int x, int d) {  
        int a[] = {  
                1, 1, 10, 100  
        }; //第一个没有用到，给多少都可以，保险给1， 本实例中的最大数是百位数，所以只要到100就可以了  
        return ((x / a[d]) % 10);  
        //187/10取得的值是18，所以再对10取余就可以获得其十位上的值  
    }  
   
    public void radixSort(int[] list, int begin, int end, int digit) {  
        final int radix = 10; // 基数，定义为常量  
        int i = 0, j = 0;  
        int[] count = new int[radix]; // 存放各个桶的数据统计个数，10个桶  
        int[] bucket = new int[end - begin + 1];//list中的数量  
   
        // 按照从低位到高位的顺序执行排序过程  
        for (int d = 1; d <= digit; d++) {  
   
            // 置空各个桶的数据统计  
            for (i = 0; i < radix; i++) {  
                count[i] = 0;  
            }  
   
            // 统计各个桶将要装入的数据个数  
            for (i = begin; i <= end; i++) {  
                j = getDigit(list[i], d);  
                count[j]++;  
            }//对应的桶计数++，这里只是得到了每个桶会放的个数  
   
            // count[i]表示第i个桶的右边界索引  
            for (i = 1; i < radix; i++) {  
                count[i] = count[i] + count[i - 1];  
            }  
   
            // 将数据依次装入桶中  
            // 这里要从右向左扫描，保证排序稳定性  
            for (i = end; i >= begin; i--) {  
                j = getDigit(list[i], d); // 求出关键码的第k位的数字， 例如：576的第3位是5  
                bucket[count[j] - 1] = list[i]; // 放入对应的桶中，count[j]-1是第j个桶的右边界索引  
                count[j]--; // 对应桶的装入数据索引减一  
            }  
   
            // 将已分配好的桶中数据再倒出来，此时已是对应当前位数有序的表  
            for (i = begin, j = 0; i <= end; i++, j++) {  
                list[i] = bucket[j];  
            }  
        }  
    }  
   
    public int[] sort(int[] list) {  
        radixSort(list, 0, list.length - 1, 3);  
        return list;  
    }  
   
    // 打印完整序列  
    public void printAll(int[] list) {  
        for (int value : list) {  
            System.out.print(value + "\t");  
        }  
        System.out.println();  
    }  
   
    public static void main(String[] args) {  
        int[] array = {  
                5, 23, 534, 187, 49, 30, 0, 21, 1, 100  
        };  
         
        RadixSort radix = new RadixSort();  
        System.out.print("排序前:\t\t");  
        radix.printAll(array);  
        radix.sort(array);  
        System.out.print("排序后:\t\t");  
        radix.printAll(array);  
     
    }  
}  

4、算法分析

桶排序

时间消耗包括两部分一部分为初始化桶，连接排好序的桶，其时间复杂度为O(n) 一般有m<n  (m个桶)

另一部分为对桶中的元素进行排序：每个桶里面有ni个元素，对ni个元素进行插入排序的耗时为O(ni^2)。

于是T(n)=O(n)+∑O(ni^2)，平均意义下认为ni=n/m，于是有T(n)=O(n)+n*O((n/m)^2)=O(n^2/m)+O(n)

当n=m时，T(n)=O(n)+O(n)=O(n)

对于每个桶采用其他的排序算法：m个桶，每个桶中的元素平均假设有n/m个，平均意义下每个桶中的

元素有n/m个，O(m * n/m *lg(n/m) = O(n*lg(n/m))，所以总的时间复杂度为T(n)=O(n+n*lg(n/m))

当m=n时时间复杂度为O(n)， 桶数量越多，时间效率越高，然而桶数量越多占用空间也就越大。

如上面后插链表，容易得到桶排序是稳定。

基数排序

基数排序中，r为基数，d为位数。则基数排序的时间复杂度为O(d(n+r))。在基数排序过程中，

对于任何位数上的基数进行“装桶”操作时，都需要n+r个临时空间。

基数排序的效率和初始序列是否有序没有关联，基数排序也是稳定的。

桶排序的性能

时间消耗包括两部分一部分为初始化桶，连接排好序的桶，其时间复杂度为O(n) 一般有m<n  (m个桶)
另一部分为对桶中的元素进行排序，这部分的复杂度，通过代码中的for和while循环直接看不太容易，这样考虑：每个桶里面有ni个元素，对ni个元素进行插入排序的耗时为O(ni^2)。

于是T(n)=O(n)+∑O(ni^2)，平均意义下认为ni=n/m，于是有T(n)=O(n)+n*O((n/m)^2)=O(n^2/m)+O(n)

当n=m时，T(n)=O(n)+O(n)=O(n)

对于每个桶采用其他的排序算法：m个桶，每个桶中的元素平均假设有n/m个，在上面进行基于比较的排序，复杂度不会低于n*O(n/m*lg(n/m))，平均意义下每个桶中的元素有n/m个，O(m * n/m *lg(n/m) = O(n*lg(n/m))，所以总的时间复杂度为T(n)=O(n+n*lg(n/m))

当m=n时时间复杂度为O(n)，此时和计数排序一样，桶数量越多，时间效率越高，然而桶数量越多占用空间也就越大。

如上面后插链表，容易得到桶排序是稳定。