计数排序，传说中时间复杂度O(n+k)的排序算法

基本思想

假设数序列中小于元素a的个数为n，则直接把a放到第n+1个位置上。当存在几个相同的元素时要做适当的调整，因为不能把所有的元素放到同一个位置上。计数排序假设输入的元素都是0到k之间的整数。

回到顶部

参考代码

#include <stdio.h>
void COUNTINGSORT(int *A, int *B, int array_size, int k)
{
        int C[k+1], i, value, pos;
        for(i=0; i<=k; i++)
        {
            C[i] = 0;
        }
        for(i=0; i< array_size; i++)
        {
            C[A[i]] ++;
        }
        for(i=1; i<=k; i++)
        {
            C[i] = C[i] + C[i-1];
        }
        for(i=array_size-1; i>=0; i--)
        {
            value = A[i];
            pos = C[value];
            B[pos-1] = value;
            C[value]--;
        }
}

        
int main()
{
        int A[8] = {2, 5, 3, 0, 2, 3, 0, 3}, B[8], i;
        COUNTINGSORT(A, B, 8, 5);
        for (i=0; i<= 7; i++)
        {
            printf("%d ", B[i]);
        }
        printf("\n");
        return 0;
}

回到顶部

图示

对于数据2 5 3 0 2 3 0 3程序执行的过程如下图所示：

      现在有个问题，若必须是0到n的自然数，是不是用途很小？我想了想，其实可以任意整数的，即找出最小的数来，看看与0的距离d,把所有的数同时减去d,划到0到n的范围内，计数排序。到最后待恢复就可以了。

计数排序的复杂度为Ο(n+k)（其中k是整数的范围），快于任何比较排序算法。[1-2]  当然这是一种牺牲空间换取时间的做法，而且当O(k)>O(n*log(n))的时候其效率反而不如基于比较的排序（基于比较的排序的时间复杂度在理论上的下限是O(n*log(n)), 如归并排序，堆排序）

实现

#include <iostream> using  namespace  std; const  int  MAXN = 100000; const  int  k = 1000;  // range int  a[MAXN], c[MAXN], ranked[MAXN];   int  main() {      int  n;      cin >> n;      for  ( int  i = 0; i < n; ++i) {          cin >> a[i];           ++c[a[i]];      }      for  ( int  i = 1; i < k; ++i)          c[i] += c[i-1];      for  ( int  i = n-1; i >= 0; --i)          ranked[--c[a[i]]] = a[i];      for  ( int  i = 0; i < n; ++i)          cout << ranked[i] << endl;      return  0; }

C语言实现

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

#include <stdio.h> #include <stdlib.h> #define random(x) rand()%(x) #define NUM 100//产生100个随机数 #define MAXNUM 200//待排序的数字范围是0-200 void  countingSort( int  A[],  int  n,  int  k){      int  *ptemp, *pout;      int  i;      ptemp = ( int  *) malloc ( sizeof ( int )*k);      pout = ( int  *) malloc ( sizeof ( int )*n);      for  (i = 0; i < k; i++)          ptemp[i] = 0;      for  (i = 0; i < n; i++)          ptemp[A[i]] += 1;      for  (i = 1; i < k; i++)          ptemp[i] = ptemp[i - 1] + ptemp[i];      for  (i = n - 1; i >= 0; i--)      {          pout[ptemp[A[i]] - 1] = A[i];          ptemp[A[i]] -= 1;      }      for  (i = 0; i < n; i++)          A[i] = pout[i];      free (ptemp);      free (pout); } void  printArray( int  A[],  int  n){      int  i = 0;      for  (i = 0; i < n; i++){          printf ( "%4d" , A[i]);      }      printf ( "\n" ); }   void  main() {      int  A[NUM];      int  i;      for  (i = 0; i < NUM; i++)          A[i] = random(MAXNUM);      printf ( "before sorting:\n" );      printArray(A, NUM);      countingSort(A, NUM, MAXNUM);      printf ( "after sorting:\n" );      printArray(A, NUM); }

JAVA语言描述

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

//针对c数组的大小，优化过的计数排序 publicclassCountSort{      publicstaticvoidmain(String[]args){        //排序的数组          int  a[]={ 100 , 93 , 97 , 92 , 96 , 99 , 92 , 89 , 93 , 97 , 90 , 94 , 92 , 95 };          int  b[]=countSort(a);          for (inti:b){             System.out.print(i+ "" );          }          System.out.println();      }      public  static  int [] countSort( int []a){          int  b[] =  new  int [a.length];          int  max = a[ 0 ],min = a[ 0 ];          for ( int  i:a){              if (i>max){                  max=i;              }              if (i<min){                  min=i;              }          } //这里k的大小是要排序的数组中，元素大小的极值差+1          int  k=max-min+ 1 ;          int  c[]= new  int [k];          for ( int  i= 0 ;i<a.length;++i){              c[a[i]-min]+= 1 ; //优化过的地方，减小了数组c的大小          }          for ( int  i= 1 ;i<c.length;++i){              c[i]=c[i]+c[i- 1 ];          }          for ( int  i=a.length- 1 ;i>= 0 ;--i){              b[--c[a[i]-min]]=a[i]; //按存取的方式取出c的元素          }      return  b;      } }