计数排序以及计数排序的一种优化

public class countSort {
           public static void CountingSort(int A[], intB[], int len, int k){
                int CountArr[] = new int[k];
                int i;
                for (i = 0; i < k; i++){
                    CountArr[i] = 0;
                }
            
                for (i = 0; i < len; i++){
                    CountArr[A[i]]++;               
                }
            
                for (i = 1; i < k; i++){
                    CountArr[i] += CountArr[i-1];
                }
            
                // 从右至左保证算法的稳定性
                for (i = len-1; i >=0; i--){
                    B[CountArr[A[i]]-1] = A[i];
                    CountArr[A[i]]--;
                }
            }
           public static int maxInt(int[] array){
                     int max=array[0];
                     for(int i=1;i<array.length;i++){
                              if(max<array[i]){
                                       max=array[i];
                              }
                     }
                     return max;
           }
           public static void main(String args[]){
                     int A[]=new int[]{1,5,7,9,2,4,6,8,0,11};
                     int B[]=new int[10];
                     int max=maxInt(A);
                     CountingSort(A, B, A.length, max+1);
                     for(int i:B){
                              System.out.print(i+" ");
                     }
           }
}
 

public class SortAges {
         staticint oldestAge=99;
         /**
          * @param args
          */
         publicstatic void main(String[] args) {
                   //TODO Auto-generated method stub------6,9,7,4,0,2,1,4
                   int[]array={6,9,7,4,0,2,1,4};
                   Sort(array,array.length);
                   for(inti:array){
                            System.out.print(i+" ");
                   }
         }
         publicstatic void Sort(int[] age,int length){
                   if(age==null||length<=0){
                            return;
                   }
                   int[]timeofage=new int[oldestAge+1];
                   for(inti=0;i<=oldestAge;++i)
                                     timeofage[i]=0;
                   for(int i = 0; i < length; i++) {
                            intag=age[i];
                            if(ag<0||ag>oldestAge){
                                     break;
                            }
                            ++timeofage[ag];
                   }
                   intindex=0;
                   //这里使用到了双层循环，假设K（元素最大值）远远大于N（元素个数），会造成很多空间的浪费，这个时候，timeofage[i]很多为0的数，最后循环下来是N+K的时间复杂度。
                   for(int i = 0; i <=oldestAge; i++) {
                            for(int j = 0; j < timeofage[i]; j++) {
                                     age[index]=i;
                                     ++index;
                            }
                   }
         }
}

第一种是标准的计数排序，第二种计数排序使用到的空间复杂度要小于第一种计数排序的空间复杂度。很明显，节约了n个空间。在时间复杂度上都是o（K+N），当k看作常数的话都是o（n），k大于n得到话肯定就是o（k+n）了。很明显，第二种的计数排序是第一种的优化。