桶排序

从《基于比较的排序结构总结 》中我们知道:全依赖“比较”操作的排序算法时间复杂度的一个下界O(N*logN)。但确实存在更快的算法。这些算法并不是不用“比较”操作,也不是想办法将比较操作的次数减少到 logN。而是利用对待排数据的某些限定性假设 ,来避免绝大多数的“比较”操作。桶排序就是这样的原理。

桶排序的基本思想

 假设有一组长度为N的待排关键字序列K[1....n]。首先将这个序列划分成M个的子区间(桶) 。然后基于某种映射函数 ,将待排序列的关键字k映射到第i个桶中(即桶数组B的下标 i) ,那么该关键字k就作为B[i]中的元素(每个桶B[i]都是一组大小为N/M的序列)。接着对每个桶B[i]中的所有元素进行比较排序(可以使用快排)。然后依次枚举输出B[0]....B[M]中的全部内容即是一个有序序列。

[桶—关键字]映射函数

      bindex=f(key)   其中,bindex 为桶数组B的下标(即第bindex个桶), k为待排序列的关键字。桶排序之所以能够高效,其关键在于这个映射函数,它必须做到:如果关键字k1<k2,那么f(k1)<=f(k2)。也就是说B(i)中的最小数据都要大于B(i-1)中最大数据。很显然,映射函数的确定与数据本身的特点有很大的关系,我们下面举个例子:

假如待排序列K= {49、 38 、 35、 97 、 76、 73 、 27、 49 }。这些数据全部在1—100之间。因此我们定制10个桶,然后确定映射函数f(k)=k/10。则第一个关键字49将定位到第4个桶中(49/10=4)。依次将所有关键字全部堆入桶中,并在每个非空的桶中进行快速排序后得到如下图所示:

对上图只要顺序输出每个B[i]中的数据就可以得到有序序列了。

桶排序代价分析

桶排序利用函数的映射关系,减少了几乎所有的比较工作。实际上,桶排序的f(k)值的计算,其作用就相当于快排中划分,已经把大量数据分割成了基本有序的数据块(桶)。然后只需要对桶中的少量数据做先进的比较排序即可。

对N个关键字进行桶排序的时间复杂度分为两个部分:

(1) 循环计算每个关键字的桶映射函数,这个时间复杂度是O(N)。

(2) 利用先进的比较排序算法对每个桶内的所有数据进行排序,其时间复杂度为  ∑ O(Ni*logNi) 。其中Ni 为第i个桶的数据量。

很显然,第(2)部分是桶排序性能好坏的决定因素。尽量减少桶内数据的数量是提高效率的唯一办法(因为基于比较排序的最好平均时间复杂度只能达到O(N*logN)了)。因此,我们需要尽量做到下面两点:

(1) 映射函数f(k)能够将N个数据平均的分配到M个桶中,这样每个桶就有[N/M]个数据量。

(2) 尽量的增大桶的数量。极限情况下每个桶只能得到一个数据,这样就完全避开了桶内数据的“比较”排序操作。当然,做到这一点很不容易,数据量巨大的情况下,f(k)函数会使得桶集合的数量巨大,空间浪费严重。这就是一个时间代价和空间代价的权衡问题了。

对于N个待排数据,M个桶,平均每个桶[N/M]个数据的桶排序平均时间复杂度为:

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

当N=M时,即极限情况下每个桶只有一个数据时。桶排序的最好效率能够达到O(N)。

总结: 桶排序的平均时间复杂度为线性的O(N+C),其中C=N*(logN-logM)。如果相对于同样的N,桶数量M越大,其效率越高,最好的时间复杂度达到O(N)。 当然桶排序的空间复杂度 为O(N+M),如果输入数据非常庞大,而桶的数量也非常多,则空间代价无疑是昂贵的。此外,桶排序是稳定的。

其实我个人还有一个感受:在查找算法中,基于比较的查找算法最好的时间复杂度也是O(logN)。比如折半查找、平衡二叉树、红黑树等。但是Hash表却有O(C)线性级别的查找效率(不冲突情况下查找效率达到O(1))。大家好好体会一下:Hash表的思想和桶排序是不是有一曲同工之妙呢?

桶排序在海量数据中的应用

一年的全国高考考生人数为500 万,分数使用标准分,最低100 ,最高900 ,没有小数,你把这500 万元素的数组排个序。

分析:对500W数据排序,如果基于比较的先进排序,平均比较次数为O(5000000*log5000000)≈1.112亿。但是我们发现,这些数据都有特殊的条件:  100=<score<=900。那么我们就可以考虑桶排序这样一个“投机取巧”的办法、让其在毫秒级别就完成500万排序。

方法:创建801(900-100)个桶。将每个考生的分数丢进f(score)=score-100的桶中。这个过程从头到尾遍历一遍数据只需要500W次。然后根据桶号大小依次将桶中数值输出,即可以得到一个有序的序列。而且可以很容易的得到100分有***人,501分有***人。

实际上,桶排序对数据的条件有特殊要求,如果上面的分数不是从100-900,而是从0-2亿,那么分配2亿个桶显然是不可能的。所以桶排序有其局限性,适合元素值集合并不大的情况。

 

 



用java写了个版本

 1 import com.gxf.util.Node;
 2 import com.gxf.util.Util;
 3 
 4 /**
 5  * 桶排序
 6  * @author GXF
 7  *
 8  */
 9 public class BucketSort {
10 
11     public static void main(String[] args) {
12         BucketSort bucketSort = new BucketSort();
13         int nums[]={49,38,65,97,76,13,27,49};
14         Util.showIntArray(nums);
15         bucketSort.bucketSort(nums);
16         Util.showIntArray(nums);
17     }
18     
19     /**
20      * 桶排序
21      * @param nums
22      */
23     public void bucketSort(int nums[]){
24         //所有的桶
25         Node bucketTable[] = new Node[10];
26         for(int i = 0; i < bucketTable.length; i++){
27             bucketTable[i] = new Node(0);
28         }//for
29         
30         //进行桶排序
31         for(int i = 0; i < nums.length; i++){
32             Node nodeToInsert = new Node(nums[i]);
33             //计算桶序号,索引
34             int bucketIndex = nums[i] / 10;
35             //如果对应的桶为空,直接添加
36             if(bucketTable[bucketIndex].key == 0)
37             {
38                 bucketTable[bucketIndex].next = nodeToInsert;
39                 bucketTable[bucketIndex].key++;
40             }//if
41             else{                            
42                 Node head = bucketTable[bucketIndex];
43                 while(head.next != null && head.next.key < nums[i])
44                     head = head.next;
45                 nodeToInsert.next = head.next;
46                 head.next = nodeToInsert;
47                 bucketTable[bucketIndex].key++;
48             }//else
49         }//for
50         
51         //将桶中的数据放到原数组中
52         int arrayIndex = 0;
53         for(int i = 0; i < bucketTable.length; i++){
54             if(bucketTable[i].key != 0){
55                 Node head = bucketTable[i].next;
56                 while(head != null){
57                     nums[arrayIndex++] = head.key;
58                     head = head.next;
59                 }//while
60             }//if
61         }//for
62     }
63     
64     
65 
66 }

针对

一个字符数组,里面的字符可能是a-z、A-Z、0-9.现在要求对数组进行排序,要求所有小写字符放在最前面,所有大写字符放在中间,所有数字放在最后。而且各部分内部分别有序

用桶排序实现了一下

 1 import com.gxf.util.CharNode;
 2 import com.gxf.util.Util;
 3 
 4 /**
 5  * 用桶排序对字符数组排序
 6  * 里面的字符可能是a-z、A-Z、0-9.现在要求对数组进行排序,要求所有小写字符放在最前面,所有大写字符放在中间,所有数字放在最后。而且各部分内部分别有序
 7  * @author GXF
 8  *
 9  */
10 public class BucketSortCharArray {
11 
12     public static void main(String[] args) {
13         String string = "asdfasdfa16a5f6d6546d5f46sa5d4f4F6AS5F4A6D4FFa4fa56d4fa";
14         char array[] = string.toCharArray();
15         BucketSortCharArray bucketSortCharArray = new BucketSortCharArray();
16         Util.showCharArray(array);
17         bucketSortCharArray.bucketSortCharArray(array);
18         Util.showCharArray(array);
19 
20     }
21     
22     /**
23      * 使用桶排序对字符数组进行排序
24      * @param array
25      */
26     public void bucketSortCharArray(char array[]){
27         //这里只需要3个桶就okay了
28         CharNode bucketTable[] = new CharNode[3];
29         //初始化桶
30         for(int i = 0; i < bucketTable.length; i++){
31             bucketTable[i] = new CharNode(' ');
32         }//for
33         
34         //开始桶排序
35         for(int i = 0; i < array.length; i++){
36             CharNode nodeToInsert = new CharNode(array[i]);
37             int bucketIndex = getBucketIndext(array[i]);
38             
39             //如果对应的桶为空
40             if(bucketTable[bucketIndex].next == null)
41                 bucketTable[bucketIndex].next = nodeToInsert;
42             else{
43                 CharNode head = bucketTable[bucketIndex];
44                 while(head.next != null && head.next.val < array[i])
45                     head = head.next;
46                 nodeToInsert.next = head.next;
47                 head.next = nodeToInsert;
48             }//else
49         }//for
50         
51         //遍历所有桶的数据,将数据放到原数组中
52         int arrayIndex = 0;
53         for(int i = 0; i < bucketTable.length; i++){
54             CharNode head = bucketTable[i].next;
55             while(head != null){
56                 array[arrayIndex++] = head.val; 
57                 head = head.next;
58             }//while
59         }
60     }
61     
62     /**
63      * a-z、A-Z、0-9
64      * @param element
65      * @return
66      */
67     private int getBucketIndext(char element){
68         if(element >= 'a' && element <= 'z')
69             return 0;
70         else if(element >= 'A' && element <= 'Z')
71             return 1;
72         return 2;
73     }
74 
75 }

-------------------------------------------------------------我是分割线,下面是快速排序的实现---------------------------------------------------------------

 1 import com.gxf.util.Util;
 2 
 3 /**
 4  * 对字符数组进行排序
 5  * @author GXF
 6  * 里面的字符可能是a-z、A-Z、0-9.现在要求对数组进行排序,要求所有小写字符放在最前面,所有大写字符放在中间,所有数字放在最后。而且各部分内部分别有序
 7  *
 8  */
 9 public class SortCharArray {
10 
11     public static void main(String[] args) {
12         String string = "affasfasdf1656546sg6a5s4g6d4F4A65FD4A6F4AF65FAFfdf46f4s6f4a6fF6AD5F46E4F3";
13         
14         char array[] = string.toCharArray();
15         Util.showCharArray(array);
16         
17         SortCharArray sortCharArray = new SortCharArray();
18         sortCharArray.sort(array);
19         
20         Util.showCharArray(array);
21 
22     }
23     
24     private void sort(char array[]){
25         if(array == null || array.length == 0)
26             return;
27         sort(array, 0, array.length - 1);
28     }
29     
30     public void sort(char array[], int start, int end){
31         if(start < end){
32             int index = partion(array, start, end);
33             sort(array, start, index - 1);
34             sort(array, index + 1, end);
35         }//if
36     }
37     
38     /**
39      * 一次划分
40      * @param array
41      * @param start
42      * @param end
43      * @return
44      */
45     private int partion(char array[], int start, int end){
46         char key = array[start];
47         while(start < end){
48             while(start < end && !compare(array, key, end))
49                 end--;
50             array[start] = array[end];
51             while(start <end && compare(array, key, start))
52                 start++;
53             array[end] = array[start];
54         }//while
55         array[start] = key;
56         return start;
57     }
58     
59     /**
60      * 比较char[position] 和 key大小
61      * key > char[position] true else false
62      * @param array
63      * @param key
64      * @param position
65      * @return
66      */
67     private boolean compare(char array[], char key, int position){
68         int keyVal = getCharIntVal(key);
69         int positionVal = getCharIntVal(array[position]);
70         
71         return keyVal - positionVal > 0 ? true : false;
72     }
73     
74     /**
75      * 获取字符对应的整型值
76      * @param charElement
77      * @return
78      */
79     private int getCharIntVal(char charElement){
80         if(charElement >= '0' && charElement <= '9')
81             return charElement + 'Z';
82         if(charElement >= 'a' && charElement <= 'z')
83             return charElement - 'z';
84         return (int)charElement;
85     }
86 }

 

 一个很形象的桶排序动态图

http://www.cs.usfca.edu/~galles/visualization/BucketSort.html

参考:

http://hxraid.iteye.com/blog/647759

posted on 2015-07-22 10:50  luckygxf  阅读(285)  评论(0编辑  收藏  举报

导航