各种经典排序算法网上还是比较多的，但是此处实现一个时间复杂度为O(n)（不完全准确，有一定条件）的排序算法。借助JAVA的BitSet来实现，仅提供一个思路。

       废话不多说，直接上代码：

public static void sort(){
 int[] arr = new int[]{32,21,7,29,18,50};
 int max = max(arr);
 System.out.println(max);
 BitSet bitSet = new BitSet(max);
 //初始化bitSet
 for(int i=0;i<bitSet.length();i++){
       bitSet.set(i,false);
 }
 for(int j=0;j<arr.length;j++){
       bitSet.set(arr[j],true);
 }
 int i=0;
 for(int k=0;k<bitSet.length();k++){
     if(bitSet.get(k))
        arr[i++] = k;
 }
     System.out.print(Arrays.toString(arr));
}
 
private static int max(int[] arr){
  int max = 0;
  for(int item:arr){
     if(item>max){
        max = item;
     }
  }
  return max;
}

  借助BitSet位存储来对应到具体的某一个排序的值，当然借助别的形式也可以实现，比如new int[] 数组，其长度同样为待排序数组的最大值，但是这样是有限制的，int的最大值是Integer.MAX_VALUE(2147483647)，最小值是Integer.MIN_VALUE(-2147483648)。一般情况下是够用。关键是占用空间问题，一个int是4个字节，32位，所以如果指定int的长度，则会需要更大的存储空间。假设指定int长度为5，则存储需要20个字节（相当于640位）。而BitSet指定长度后，是按照位进行数据存储，这样数据就会少很多。所以BitSet常用于存储海量数据。

      BitSet可以存储海量数据，但是同时，BitSet会过滤重复的内容，因为它是以true/false来标志的，所以要是对于重复的内容就不能直接使用了，如果非要可能具有相同内容进行排序，可以用以下的方式来实现。

     思路：存储某个值出现几次，需要一个存储KV的数据结构。这里使用concurrentHashMap来实现。后面会说明原因。废话不多说，依旧直接上代码

public static void sort(){
   int[] arr = new int[]{2,1,7,6,2,3,5,2,6};
   Map<Integer,Integer> count = new ConcurrentHashMap<Integer,Integer>(arr.length);    #增加一个Map对象存储
    int max = max(arr);
   System.out.println(max);
   BitSet bitSet = new BitSet(max);
   //初始化bitSet,默认为false，可以不设置
   for(int i=0;i<bitSet.length();i++){
        bitSet.set(i,false);
   }
   for(int j=0;j<arr.length;j++){
        bitSet.set(arr[j],true);

        if (count.containsKey(arr[j])){
            count.put(arr[j],count.get(arr[j])+1);
       }else{
            count.put(arr[j],1);
       }
  }
   Set<Map.Entry<Integer,Integer>> sets = count.entrySet(); 
   for(Map.Entry<Integer,Integer> entry:sets){
     if(entry.getValue() == 1){
      count.remove(entry.getKey());    #遍历Map，将只出现一次的删除掉
     }
   }  
  int i=0;
   for(int k=0;k<bitSet.length();k++){
     if(bitSet.get(k)){
         if(!sets.isEmpty()){
             if (count.containsKey(k)){    #若Map集合包含有出现1次以上的数值，则按出现的次数进行操作
                int cc = count.get(k);
                 for(int j=0;j<cc;j++){
                    arr[i++] = k;
                 }
                count.remove(k);    #将已经处理过的移除
             }else{
                   arr[i++] = k;
             }
         }else{
            arr[i++] = k;
         }
     }
   }
 System.out.println(Arrays.toString(arr));
}

private static int max(int[] arr){
 int max = 0;
 for(int item:arr){
   if(item>max){
     max = item;
   }
 }
 return max;
}

  可以看到在代码23行和35行执行了map的remove操作，而且在操作之后进行又进行了读操作。由于HashMap是非线程安全的，在进行读写操作执行时，会发生异常，尤其在编码中，如果在线上项目，除非你能确定使用场景，否则一但HashMap操作不当，就会造成各种异常情况，而且可能还不太好排查。而ConcurrentHashMap是线程安全的，而且其内部的加锁机制也不是以前粗暴的加锁方式，也更优雅。有兴趣的同学可以Google下此类的分析或者直接看源码实现。