桶排序和基数排序区别(算法+代码)

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

1、算法思路:

桶排序

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

基数排序

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

2、实现过程

桶排序过程

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

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

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

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

桶排序和基数排序区别(算法+代码)_第1张图片

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

基数排序实现过程

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

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

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

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

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

桶排序和基数排序区别(算法+代码)_第2张图片

分类后,我们在从各个桶中,将这些数按照从编号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) 一般有mm个桶)

另一部分为对桶中的元素进行排序:每个桶里面有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) 一般有mm个桶)
另一部分为对桶中的元素进行排序,这部分的复杂度,通过代码中的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),此时和计数排序一样,桶数量越多,时间效率越高,然而桶数量越多占用空间也就越大。

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


你可能感兴趣的:(java,数据结构)