数据结构---线性排序（规律数据，线性复杂度）

一、桶排序，按区间分割，桶里面存储相应数据，并采取相关排序算法排序，下面采用快速排序。内存容量不够时，采用分割

复杂度：线性

原地：

稳定：

    public void bucket(int[] target,int bucketSize){
        int max = Integer.MIN_VALUE;
        int min = Integer.MAX_VALUE;
        for(int i : target){
            max = Math.max(i, max);
            min = Math.min(i, min);
        }
        int bucketLength = (max-min)/bucketSize;
        java.util.HashMap<Integer, java.util.ArrayList<Integer>> hashmap = new java.util.HashMap<Integer, java.util.ArrayList<Integer>>();
        for(int i=0;i<=bucketLength;i++){        
            hashmap.put(i, new java.util.ArrayList<Integer>());
        }
        for(int i : target){
            java.util.ArrayList arraylist = hashmap.get((i-min)/bucketSize);
            arraylist.add(i);
        }
        java.util.Iterator iterator = hashmap.entrySet().iterator();
        while(iterator.hasNext()){
            Map.Entry<Integer, java.util.ArrayList<Integer>> entry = (Entry<Integer, ArrayList<Integer>>) iterator.next();
            entry.getKey();
            Object[] values = entry.getValue().toArray();

            this.sort(values, 0, values.length-1);
            for(Object i :values){
                System.out.print(i+" ");                
            }
        }

    }
    
    //快速排序，选取最后一值作为分区的标准，小于标准的放左边，大于标准的放右边；
    public void sort(Object[] values,int start,int end){
        if(start >= end)return;
        int i = partion(values,start,end);
        sort(values,start,i);
        sort(values,i+1,end);
    }
    
    public int partion(Object[]target,int start,int end){
        int result = end;
        int i = start;
        int temp;
        for(int j=start;j<end;j++){
            if((int)target[j]<(int)target[end]){
                temp = (int)target[j];
                target[i] = target[j];
                target[j] = temp;
                i++;
            }
        }
        if(i < end){
            temp = (int)target[end];
            target[i] = target[end];
            target[end] = temp;
            result = i;
        }else if(i==end){
            result = i-1;
        }
        return result;
    }
    
    public static void main(String[] args) throws Exception {
        new test().bucket(new int[]{1,5,54,4,7,8,51,45,12,25,41,32}, 10);        
    }

二、计数排序，数据范围小，数据量大，桶排序的特例，超级密集桶排序数据。

public void sort(int[] target){
        int max = Integer.MIN_VALUE;
        int min = 0;
        for(int i=0;i<target.length;i++){
            max = Math.max(target[i], max);
            
        }
        int[] temp = new int[max-min+1];
        for(int i:target){
            temp[i]++;
        }

        for(int i:temp){
            System.out.print(i+" ");
        }
        System.out.println(" ");
        int[] result = new int[target.length];
        int resultIndex = 0;
        for(int i =0;i<temp.length;i++){
            for(int j=1;j<=temp[i];j++){
                result[resultIndex++] = i;
            }
        }
//        for(int i=1;i<=max; ++i){
//            temp[i]=temp[i-1]+temp[i];
//        }
//        for(int i=target.length-1;i>=0;--i){
//            int index = temp[target[i]]-1;
//            result[index] = target[i];
//            temp[target[i]]--;
//        }
        
        for(int i:result){
            System.out.print(i+" ");
        }
    }
    
    public static void main(String[] args){
        int[] target = {1,5,4,1,4,1,5,4};
        new test().sort(target);
    }