排序与查找实例（六）：计数排序

      常见的非比较排序算法有3个 计数排序，基数排序，桶排序，平均时间复杂度都是O(n)。比较排序就是指通过 比较操作(通常是“小于或等于”操作)来确定两个元素中哪个应该放在序列前面。比较排序的算法理论的算法复杂度下线为：O(nlgn)。但是这3个排序算法并没有我们常见的快速排序，归并排序等出名，主要是限制比较多。 1.计数排序 当输入的元素是 n 个0 到 k之间的整数时，它的运行时间是Θ(n + k)。计数排序不是比较排序，排序的 速度快于任何比较排序算法。

     由于用来计数的数组C的长度取决于待排序数组中数据的范围（等于待排序数组的最大值与最小值的差加上1），这使得计数排序对于数据范围很大的数组，需要大量时间和内存。例如：计数排序是用来排序0到100之间的数字的最好的算法，但是它不适合按字母顺序排序人名。但是，计数排序可以用在基数排序中的算法来排序数据范围很大的数组。通俗地理解，例如有10个年龄不同的人，统计出有8个人的年龄比A小，那A的年龄就排在第9位,用这个方法可以得到其他每个人的位置,也就排好了序。当然，年龄有重复时需要特殊处理（保证稳定性），这就是为什么最后要反向填 充目标数组，以及将每个数字的统计减去1的原因。算法的步骤如下：找出待排序的数组中最大和最小的元素 统计数组中每个值为i的元素出现的次数，存入数组C的第i项对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加） 反向填充目标数组：将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1假定输入是个数组A【1…n】， length【A】=n。另外还需要一个存放排序结果的数组B【1…n】，以及提供临时存储区的C【0…k】(k是所有元素中最大的一个)。

    具体实例及实现如下：

    实例： 假设数字范围在 0 到 9. 输入数据: 1, 4,1, 2, 7, 5, 2 1) 使用一个数组记录每个数组出现的次数 Index: 0 1 2 3 4 5 6 7 8 9 Count: 0 2 2 0 1 1 0 1 0 02) 累加所有计数（从C中的第一个元素开始，每一项和前一项相加），Index: 0 1 2 3 4 5 6 7 8 9 Count: 0 2 4 4 56 6 7 7 7 更改过的计数数组就表示每个元素在输出数组中的位置 3) 反向填充目标数组：将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1例如对于: 1, 4, 1,2, 7, 5, 2. 1 的位置是 2. 把1放在输出数组的第2个位置.并把计数减 1，下一个1出现的时候就放在了第1个位置。(方向可以保持稳定)

    

/**  

 * @Title: CountingSort.java

 * @Package sortandsearch

 * @Description: TODO

 * @author peidong 

 * @date 2017-5-8 上午10:40:02

 * @version V1.0  

 */

packagesortandsearch;

 

/**

 * @ClassName: CountingSort

 * @Description: 计数排序实例

 * @date 2017-5-8 上午10:40:02

 *

 */

 

publicclass CountingSort {

 

       /*public static void countingSort(int[]a, int[] b, int k) {

              // k >=n

              int[] c = new int[k + 1];

              for (int i = 0; i < k; i++) {

                     c[i] = 0;

              }

              for (int i = 0; i < a.length;i++) {

                     c[a[i]]++;

              }

              System.out.println("\n**************");

              System.out.println("计数排序第2步后，临时数组C变为：");

              for (int m : c) {

                     System.out.print(m + "");

              }

              for (int i = 1; i <= k; i++) {

                     c[i] += c[i - 1];

              }

              System.out.println("\n计数排序第3步后，临时数组C变为：");

              for (int i = 1; i <= k; i++) {

                     c[i] += c[i - 1];

              }

              for (int i = a.length - 1; i >=0; i--)  {

                     b[c[a[i]] - 1] = a[i];

                     c[a[i]]--;

              }

              System.out.println("\n计数排序第4步后，临时数组C变为：");

              for (int m : c) {

                     System.out.print(m + "");

              }

              System.out.println("\n计数排序第4步后，临时数组B变为：");

              for (int m : b) {

                     System.out.print(m + "");

              }

 

              System.out.println();

              System.out.println("*****************\n");

 

       }*/

       public static int[] countSort1(int[]arr){

           if (arr == null || arr.length == 0) {

              return null;

          }

          

          int max = Integer.MIN_VALUE;

          int min = Integer.MAX_VALUE;

          

          //找出数组中的最大最小值

          for(int i = 0; i < arr.length; i++){

              max = Math.max(max, arr[i]);

              min = Math.min(min, arr[i]);

          }

          

          int help[] = new int[max];

          

          //找出每个数字出现的次数

          for(int i = 0; i < arr.length; i++){

              int mapPos = arr[i] - min;

              help[mapPos]++;

          }

          

          int index = 0;

          for(int i = 0; i < help.length; i++){

              while(help[i]-- > 0){

                   arr[index++] = i+min;

              }

          }

          

          return arr;

       }

      

       public static int[] countSort2(int[]arr){

          int max = Integer.MIN_VALUE;

          int min = Integer.MAX_VALUE;

          

          //找出数组中的最大最小值

          for(int i = 0; i < arr.length; i++){

              max = Math.max(max, arr[i]);

              min = Math.min(min, arr[i]);

          }

          

          int[] help = new int[max - min + 1];

          

          //找出每个数字出现的次数

          for(int i = 0; i < arr.length; i++){

              int mapPos = arr[i] - min;

              help[mapPos]++;

          }

          

          //计算每个数字应该在排序后数组中应该处于的位置

          for(int i = 1; i < help.length; i++){

              help[i] = help[i-1] + help[i];

          }

          

          //根据help数组进行排序

          int res[] = new int[arr.length];

          for(int i = 0; i < arr.length; i++){

              int post = --help[arr[i] - min];

              res[post] = arr[i];

          }

          

          return res;

       }

 

       /**

        *

        *@Title: getMaxNumber

        *@Description: 获取最大位数值

        *@param a

        *@return

        *@return int

        *@throws

        */

       public static int getMaxNumber(int[] a) {

              int max = 0;

              for (int i = 0; i < a.length;i++) {

                     if (max < a[i]) {

                            max = a[i];

                     }

              }

              return max;

       }

 

       /**

        *@Title: main

        *@Description: 测试计数排序

        *@param args

        *@return void

        *@throws

        */

       public static void main(String[] args) {

              // TODO Auto-generated method stub

              int[] a = new int[] { 2, 5, 3, 0,2, 3, 0, 3 };

              int[] b = new int[a.length];

              System.out.println("计数排序前为：");

              for (int i = 0; i < a.length;i++) {

                     System.out.print(a[i] +" ");

              }

              System.out.println();

              countSort2(a);

              System.out.println("计数排序后为：");

              for (int i = 0; i < a.length;i++) {

                     System.out.print(b[i] +" ");

              }

              System.out.println();

 

       }

 

}

 

/*时间复杂度: O(n+k)

空间复杂度: O(n+k)

 

其它：

 

1. 计数排序是有效的，如果输入数据的范围是不显著大于数字的个数。

 

2. 它不是一个基于比较的排序。它运行的时间复杂度为O（n）

 

3. 它经常被用来作为另一个排序算法像基数排序的一个子程序。

 

4. 计数排序可以扩展到负输入也可以。*/