代码改变世界

计数排序,基数排序和桶排序

2012-08-04 20:11 coodoing 阅读(...) 评论(...) 编辑 收藏

    计数排序,基数排序,桶排序等非比较排序算法,平均时间复杂度都是O(n)。这些排序因为其待排序元素本身就含有了定位特征,因而不需要比较就可以确定其前后位置,从而可以突破比较排序算法时间复杂度O(nlgn)的理论下限。

计数排序(Counting sort)

    计数排序(Counting sort)是一种稳定的排序算法。计数排序是最简单的特例,由于用来计数的数组C的长度取决于待排序数组中数据的范围(等于待排序数组的最大值与最小值的差加上1),这使得计数排序对于数据范围很大的数组,需要大量时间和内存,适用性不高。例如:计数排序是用来排序0到100之间的数字的最好的算法,但是它不适合按字母顺序排序人名。但是,计数排序可以用在基数排序中的算法来排序数据范围很大的数组。当输入的元素是 n 个 0 到 k 之间的整数时,它的运行时间是 Θ(n + k)。

    假定输入是个数组A【1...n】, length【A】=n。 另外还需要一个存放排序结果的数组B【1...n】,以及提供临时存储区的C【0...k】(k是所有元素中最大的一个)。算法伪代码

1337947779_3381

算法的步骤如下

  1. 找出待排序的数组中最大和最小的元素
  2. 统计数组中每个值为t的元素出现的次数,存入数组C的第t
  3. 对所有的计数累加(从C中的第一个元素开始,每一项和前一项相加)
  4. 反向填充目标数组:将每个元素t放在新数组的第C(t)项,每放一个元素就将C(t)减去1

算法实现:

   1: /*
   2:  *  算法的步骤如下:
   3:     1、找出待排序的数组中最大和最小的元素
   4:     2、统计数组中每个值为t的元素出现的次数,存入数组C的第t项
   5:     3、对所有的计数累加(从C中的第一个元素开始,每一项和前一项相加)
   6:     4、反向填充目标数组:将每个元素t放在新数组的第C(t)项,每放一个元素就将C(t)减去1
   7:  * */
   8: public class CountingSort {
   9:     // 类似bitmap排序
  10:     public static void countSort(int[] a, int[] b, final int k) {
  11:         // k>=n
  12:         int[] c = new int[k + 1];
  13:         for (int i = 0; i < k; i++) {
  14:             c[i] = 0;
  15:         }        
  16:         for (int i = 0; i < a.length; i++) {
  17:             c[a[i]]++;
  18:         }        
  19:         System.out.println("\n****************");
  20:         System.out.println("计数排序第2步后,临时数组C变为:");
  21:         for (int m:c) {
  22:             System.out.print(m + " ");
  23:         }
  24:         
  25:         for (int i = 1; i <= k; i++) {
  26:             c[i] += c[i - 1];
  27:         }        
  28:         System.out.println("\n计数排序第3步后,临时数组C变为:");
  29:         for (int m:c) {
  30:             System.out.print(m + " ");
  31:         }
  32:         
  33:         for (int i = a.length - 1; i >= 0; i--) {
  34:             b[c[a[i]] - 1] = a[i];//C[A[i]]-1 就代表小于等于元素A[i]的元素个数,就是A[i]在B的位置
  35:             c[a[i]]--;
  36:         }
  37:         System.out.println("\n计数排序第4步后,临时数组C变为:");
  38:         for (int n:c) {
  39:             System.out.print(n + " ");
  40:         }
  41:         System.out.println("\n计数排序第4步后,数组B变为:");
  42:         for (int t:b) {
  43:             System.out.print(t + " ");
  44:         }
  45:         System.out.println();
  46:         System.out.println("****************\n");
  47:     }
  48:  
  49:     public static int getMaxNumber(int[] a) {
  50:         int max = 0;
  51:         for (int i = 0; i < a.length; i++) {
  52:             if (max < a[i]) {
  53:                 max = a[i];
  54:             }
  55:         }
  56:         return max;
  57:     }
  58:  
  59:     public static void main(String[] args) {
  60:         int[] a = new int[] { 2, 5, 3, 0, 2, 3, 0, 3 };
  61:         int[] b = new int[a.length];
  62:         System.out.println("计数排序前为:");
  63:         for (int i = 0; i < a.length; i++) {
  64:             System.out.print(a[i] + " ");
  65:         }
  66:         System.out.println();
  67:         countSort(a, b, getMaxNumber(a));
  68:         System.out.println("计数排序后为:");
  69:         for (int i = 0; i < a.length; i++) {
  70:             System.out.print(b[i] + " ");
  71:         }
  72:         System.out.println();
  73:     }
  74:  
  75: }

 

基数排序(radix sorting)

      基数排序(radix sorting)将所有待比较数值(正整数)统一为同样的数位长度,数位较短的数前面补零。 然后 从最低位开始,依次进行一次排序。这样从最低位排序一直到最高位排序完成以后, 数列就变成一个有序序列。具体过程可以参考动画演示

     假设我们有一些二元组(a,b),要对它们进行以a为首要关键字,b的次要关键字的排序。我们可以先把它们先按照首要关键字排序,分成首要关键字相同的若干堆。然后,在按照次要关键值分别对每一堆进行单独排序。最后再把这些堆串连到一起,使首要关键字较小的一堆排在上面。按这种方式的基数排序称为MSD(Most Significant Dight)排序。第二种方式是从最低有效关键字开始排序,称为LSD(Least Significant Dight)排序。首先对所有的数据按照次要关键字排序,然后对所有的数据按照首要关键字排序。要注意的是,使用的排序算法必须是稳定的,否则就会取消前一次排序的结果。由于不需要分堆对每堆单独排序,LSD方法往往比MSD简单而开销小。下文介绍的方法全部是基于LSD的。

      基数排序的简单描述就是将数字拆分为个位十位百位,每个位依次排序。因为这对算法稳定要求高,所以我们对数位排序用到上一个排序方法计数排序。因为基数排序要经过d (数据长度)次排序, 每次使用计数排序, 计数排序的复杂度为 On),  d 相当于常量和N无关,所以基数排序也是 O(n)。基数排序虽然是线性复杂度, 即对n个数字处理了n次,但是每一次代价都比较高, 而且使用计数排序的基数排序不能进行原地排序,需要更多的内存, 并且快速排序可能更好地利用硬件的缓存, 所以比较起来,像快速排序这些原地排序算法更可取。对于一个位数有限的十进制数,我们可以把它看作一个多元组,从高位到低位关键字重要程度依次递减。可以使用基数排序对一些位数有限的十进制数排序

    例如我们将一个三位数分成,个位,十位,百位三部分。我们要对七个三位数来进行排序,依次对其个位,十位,百位进行排序,如下图:

很显然,每一位的数的大小都在[0,9]中,对于每一位的排序用计数排序再适合不过。

算法实现:

   1: // 基数排序:稳定排序
   2: public class RadixSorting {
   3:  
   4:     // d为数据长度
   5:     private static void radixSorting(int[] arr, int d) {        
   6:         //arr = countingSort(arr, 0);
   7:         for (int i = 0; i < d; i++) {
   8:             arr = countingSort(arr, i); // 依次对各位数字排序(直接用计数排序的变体)
   9:             print(arr,i+1,d);
  10:         }
  11:     }
  12:     
  13:     // 把每次按位排序的结果打印出来
  14:     static void print(int[] arr,int k,int d)
  15:     {
  16:         if(k==d)
  17:             System.out.println("最终排序结果为:");
  18:         else
  19:             System.out.println("按第"+k+"位排序后,结果为:");
  20:         for (int t : arr) {
  21:             System.out.print(t + " ");
  22:         }
  23:         System.out.println();
  24:     }
  25:     
  26:     // 利用计数排序对元素的每一位进行排序
  27:     private static int[] countingSort(int[] arr, int index) {
  28:         int k = 9;
  29:         int[] b = new int[arr.length];
  30:         int[] c = new int[k + 1]; //这里比较特殊:数的每一位最大数为9        
  31:  
  32:         for (int i = 0; i < k; i++) {
  33:             c[i] = 0;
  34:         }
  35:         for (int i = 0; i < arr.length; i++) {
  36:             int d = getBitData(arr[i], index);
  37:             c[d]++;
  38:         }
  39:         for (int i = 1; i <= k; i++) {
  40:             c[i] += c[i - 1];
  41:         }
  42:         for (int i = arr.length - 1; i >= 0; i--) {
  43:             int d = getBitData(arr[i], index);
  44:             b[c[d] - 1] = arr[i];//C[d]-1 就代表小于等于元素d的元素个数,就是d在B的位置
  45:             c[d]--;
  46:         }
  47:         return b;
  48:     }
  49:  
  50:     // 获取data指定位的数
  51:     private static int getBitData(int data, int index) {
  52:         while (data != 0 && index > 0) {
  53:             data /= 10;
  54:             index--;
  55:         }
  56:         return data % 10;
  57:     }
  58:  
  59:     public static void main(String[] args) {
  60:         // TODO Auto-generated method stub
  61:         int[] arr = new int[] {326,453,608,835,751,435,704,690,88,79,79};//{ 333, 956, 175, 345, 212, 542, 99, 87 };
  62:         System.out.println("基数排序前为:");
  63:         for (int t : arr) {
  64:             System.out.print(t + " ");
  65:         }
  66:         System.out.println();
  67:         radixSorting(arr, 4);        
  68:     }
  69:  
  70: }

 

桶排序(Bucket Sort)

    首先定义桶,桶为一个数据容器,每个桶存储一个区间内的数。依然有一个待排序的整数序列A,元素的最小值不小于0,最大值不超过K假设我们有M个桶,第i个桶Bucket[i]存储i*K/M至(i+1)*K/M之间的数。桶排序步骤如下:

  1. 扫描序列A,根据每个元素的值所属的区间,放入指定的桶中(顺序放置)。
  2. 对每个桶中的元素进行排序,什么排序算法都可以,例如插入排序
  3. 依次收集每个桶中的元素,顺序放置到输出序列中。

     具体过程可以参考动画演示

算法伪代码为:

1338056660_6338

具体代码:

 

   1: // 桶排序
   2: public class BucketSort {
   3:  
   4:     // 插入排序
   5:     static void insertSort(int[] a) {
   6:         int n = a.length;
   7:         for (int i = 1; i < n; i++) {
   8:             int p = a[i];
   9:             insert(a, i, p);
  10:         }
  11:     }
  12:  
  13:     static void insert(int[] a, int index, int x) {
  14:         // 元素插入数组a[0:index-1]
  15:         int i;
  16:         for (i = index - 1; i >= 0 && x < a[i]; i--) {
  17:             a[i + 1] = a[i];
  18:         }
  19:         a[i + 1] = x;
  20:     }
  21:  
  22:     private static void bucketSort(int[] a) {
  23:         int M = 10; // 11个桶
  24:         int n = a.length;
  25:         int[] bucketA = new int[M]; // 用于存放每个桶中的元素个数
  26:         // 构造一个二维数组b,用来存放A中的数据,这里的B相当于很多桶,B[i][]代表第i个桶
  27:         int[][] b = new int[M][n];
  28:         int i, j;
  29:         for (i = 0; i < M; i++)
  30:             for (j = 0; j < n; j++)
  31:                 b[i][j] = 0;
  32:  
  33:         int data, bucket;
  34:         for (i = 0; i < n; i++) {
  35:             data = a[i];
  36:             bucket = data / 10;
  37:             b[bucket][bucketA[bucket]] = a[i];// B[0][]中存放A中进行A[i]/10运算后高位为0的数据,同理B[1][]存放高位为1的数据
  38:             bucketA[bucket]++;// 用来计数二维数组中列中数据的个数,也就是桶A[i]中存放数据的个数
  39:         }
  40:         System.out.println("每个桶内元素个数:");
  41:         for (i = 0; i < M; i++) {
  42:             System.out.print(bucketA[i] + " ");
  43:         }
  44:         System.out.println();
  45:  
  46:         System.out.println("数据插入桶后,桶内未进行排序前的结果为:");
  47:         for (i = 0; i < M; i++) {
  48:             for (j = 0; j < n; j++)
  49:                 System.out.print(b[i][j] + " ");
  50:             System.out.println();
  51:         }
  52:  
  53:         System.out.println("对每个桶进行插入排序,结果为:");
  54:         // 下面使用直接插入排序对这个二维数组进行排序,也就是对每个桶进行排序
  55:         for (i = 0; i < M; i++) {
  56:             // 下面是对具有数据的一列进行直接插入排序,也就是对B[i][]这个桶中的数据进行排序
  57:             if (bucketA[i] != 0) {
  58:                 // 插入排序
  59:                 for (j = 1; j < bucketA[i]; j++) {
  60:                     int p = b[i][j];
  61:                     int k;
  62:                     for (k = j - 1; k >= 0 && p < b[i][k]; k--)
  63:                     {
  64:                         assert k==-1;
  65:                         b[i][k + 1] = b[i][k];
  66:                     }
  67:                     b[i][k + 1] = p;
  68:                 }
  69:             }
  70:         }
  71:         
  72:         // 输出排序过后的顺序
  73:         for (i = 0; i < 10; i++) {
  74:             if (bucketA[i] != 0) {
  75:                 for (j = 0; j < bucketA[i]; j++) {
  76:                     System.out.print(b[i][j] + " ");
  77:                 }
  78:             }
  79:         }
  80:     }
  81:  
  82:     /**
  83:      * @param args
  84:      */
  85:     public static void main(String[] args) {
  86:         // TODO Auto-generated method stub
  87:         int[] arr = new int[] {3,5,45,34,2,78,67,34,56,98};                                                            
  88:         bucketSort(arr);
  89:     }
  90:  
  91: }

三种线性排序的比较

排序算法 时间复杂度 空间复杂度  
计数排序 O(N+K) O(N+K) 稳定排序
基数排序 O(N) O(N) 稳定排序
桶排序 O(N+K) O(N+K) 稳定排序

     从整体上来说,计数排序,桶排序都是非基于比较的排序算法,而其时间复杂度依赖于数据的范围,桶排序还依赖于空间的开销和数据的分布。而基数排序是一种对多元组排序的有效方法,具体实现要用到计数排序或桶排序。

     相对于快速排序、堆排序等基于比较的排序算法,计数排序、桶排序和基数排序限制较多,不如快速排序、堆排序等算法灵活性好。但反过来讲,这三种线性排序算法之所以能够达到线性时间,是因为充分利用了待排序数据的特性,如果生硬得使用快速排序、堆排序等算法,就相当于浪费了这些特性,因而达不到更高的效率。

参考资料

http://www.cnblogs.com/bluedream2009/archive/2011/04/14/2016551.html

http://www.byvoid.com/blog/sort-radix/