算法篇---桶式排序和基数排序

桶式排序不再是一种基于比较的排序方法，它是一种比较巧妙的排序方式，但这种排序方式需要待排序的序列满足以下两个特征：

待排序列所有的值处于一个可枚举的范围之类；

待排序列所在的这个可枚举的范围不应该太大，否则排序开销太大。

排序的具体步骤如下：

（1）对于这个可枚举范围构建一个buckets数组，用于记录“落入”每个桶中元素的个数；

（2）将（1）中得到的buckets数组重新进行计算，按如下公式重新计算：

buckets[i] = buckets[i] +buckets[i-1] (其中1<=i<buckets.length); 

桶式排序是一种非常优秀的排序算法，时间效率极高，它只要通过2轮遍历：第1轮遍历待排数据，统计每个待排数据“落入”各桶中的个数，第2轮遍历buckets用于重新计算buckets中元素的值，2轮遍历后就可以得到每个待排数据在有序序列中的位置，然后将各个数据项依次放入指定位置即可。

桶式排序的空间开销较大，它需要两个数组，第1个buckets数组用于记录“落入”各桶中元素的个数，进而保存各元素在有序序列中的位置，第2个数组用于缓存待排数据。

桶式排序是稳定的。

如果待排序数据的范围在0~k之间，那么它的时间复杂度是O(k+n)的

桶式排序算法速度很快，因为它的时间复杂度是O(k+n)，而基于交换的排序时间上限是nlg n。

但是它的限制多，比如它只能排整形数组。而且当k较大，而数组长度n较小，即k>>n时，辅助数组C[k+1]的空间消耗较大。

当数组为整形，且k和n接近时, 可以用此方法排序。（有的文章也称这种排序算法为“计数排序”）

代码实现：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42

public  class  BucketSortTest {       public  static  int  count =  0 ;           public  static  void  main(String[] args) {               int [] data =  new  int [] {  5 ,  3 ,  6 ,  2 ,  1 ,  9 ,  4 ,  8 ,  7  };           print(data);           bucketSort(data,  0 ,  10 );           print(data);           }           public  static  void  bucketSort( int [] data,  int  min,  int  max) {           // 缓存数组           int [] tmp =  new  int [data.length];           // buckets用于记录待排序元素的信息           // buckets数组定义了max-min个桶           int [] buckets =  new  int [max - min];           // 计算每个元素在序列出现的次数           for  ( int  i =  0 ; i < data.length; i++) {               buckets[data[i] - min]++;           }           // 计算“落入”各桶内的元素在有序序列中的位置           for  ( int  i =  1 ; i < max - min; i++) {               buckets[i] = buckets[i] + buckets[i -  1 ];           }           // 将data中的元素完全复制到tmp数组中           System.arraycopy(data,  0 , tmp,  0 , data.length);           // 根据buckets数组中的信息将待排序列的各元素放入相应位置           for  ( int  k = data.length -  1 ; k >=  0 ; k--) {               data[--buckets[tmp[k] - min]] = tmp[k];           }       }           public  static  void  print( int [] data) {           for  ( int  i =  0 ; i < data.length; i++) {               System.out.print(data[i] +  "\t" );           }           System.out.println();       }      }

　　运行结果：

5    3    6    2    1    9    4    8    7    
1    2    3    4    5    6    7    8    9    

基数排序，说白了就是进行多次的桶式排序。

基数排序已经不再是一种常规的排序方式，它更多地像一种排序方法的应用，基数排序必须依赖于另外的排序方法。基数排序的总体思路就是将待排序数据拆分成多个关键字进行排序，也就是说，基数排序的实质是多关键字排序。

多关键字排序的思路是将待排数据里德排序关键字拆分成多个排序关键字；第1个排序关键字，第2个排序关键字，第3个排序关键字......然后，根据子关键字对待排序数据进行排序。

多关键字排序时有两种解决方案：

最高位优先法（MSD）(Most Significant Digit first)

最低位优先法（LSD）(Least Significant Digit first)

例如，对如下数据序列进行排序。

192,221,12,23

可以观察到它的每个数据至多只有3位，因此可以将每个数据拆分成3个关键字：百位（高位）、十位、个位（低位）。

如果按照习惯思维，会先比较百位，百位大的数据大，百位相同的再比较十位，十位大的数据大；最后再比较个位。人得习惯思维是最高位优先方式。

如果按照人得思维方式，计算机实现起来有一定的困难，当开始比较十位时，程序还需要判断它们的百位是否相同--这就认为地增加了难度，计算机通常会选择最低位优先法。

基数排序方法对任一子关键字排序时必须借助于另一种排序方法，而且这种排序方法必须是稳定的。

对于多关键字拆分出来的子关键字，它们一定位于0-9这个可枚举的范围内，这个范围不大，因此用桶式排序效率非常好。

对于多关键字排序来说，程序将待排数据拆分成多个子关键字后，对子关键字排序既可以使用桶式排序，也可以使用任何一种稳定的排序方法。

 

代码实现：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56

package  基数排序;   import  java.util.Arrays;   public  class  MultiKeyRadixSortTest {           public  static  void  main(String[] args) {           int [] data =  new  int [] {  1100 ,  192 ,  221 ,  12 ,  23  };           print(data);           radixSort(data,  10 ,  4 );           System.out.println( "排序后的数组：" );           print(data);       }           public  static  void  radixSort( int [] data,  int  radix,  int  d) {           // 缓存数组           int [] tmp =  new  int [data.length];           // buckets用于记录待排序元素的信息           // buckets数组定义了max-min个桶           int [] buckets =  new  int [radix];               for  ( int  i =  0 , rate =  1 ; i < d; i++) {                   // 重置count数组，开始统计下一个关键字               Arrays.fill(buckets,  0 );               // 将data中的元素完全复制到tmp数组中               System.arraycopy(data,  0 , tmp,  0 , data.length);                   // 计算每个待排序数据的子关键字               for  ( int  j =  0 ; j < data.length; j++) {                   int  subKey = (tmp[j] / rate) % radix;                   buckets[subKey]++;               }                   for  ( int  j =  1 ; j < radix; j++) {                   buckets[j] = buckets[j] + buckets[j -  1 ];               }                   // 按子关键字对指定的数据进行排序               for  ( int  m = data.length -  1 ; m >=  0 ; m--) {                   int  subKey = (tmp[m] / rate) % radix;                   data[--buckets[subKey]] = tmp[m];               }               rate *= radix;           }           }           public  static  void  print( int [] data) {           for  ( int  i =  0 ; i < data.length; i++) {               System.out.print(data[i] +  "\t" );           }           System.out.println();       }      }

　　运行结果：

1100    192    221    12    23    
排序后的数组：
12    23    192    221    1100    

 转自：http://blog.csdn.net/apei830/article/details/6596104

博客地址：	http://www.cnblogs.com/oumyye/
博客版权：	本文以学习、研究和分享为主，欢迎转载，转载请务必注明出处，谢谢合作。 如果文中有不妥或者错误的地方请指出。如果觉得本文对你有所帮助不如【推荐】一下！如果你有更好的建议，不如留言一起讨论，共同进步！