桶排序及其应用

桶排序是一种不用比较的排序。适合需要排序的数据的数值不是很大且非负。
思路：首先遍历一遍数组arr，将其中的最大值找出来。然后创建一个大小为max+1的数组。然后遍历arr，将arr[i]的值放进到help[arr[i] ]中，同时help的值加一。

package Code01;

public class Code06_BucketSort {
    public static void main(String[] args) {
        int[] arr = {2,7,9,1};
        bucketSort(arr);
        for(int i = 0; i < arr.length; i++){
            System.out.println(arr[i]);
        }
    }
    public static void bucketSort(int[] arr){
        if(arr == null || arr.length < 2){
            return ;
        }
        int max = Integer.MIN_VALUE;
        for(int i = 0; i < arr.length; i++){
            max = Math.max(max, arr[i]);
        }
        int[] bucket = new int[max + 1];
        for(int i = 0; i < arr.length; i++){
            bucket[arr[i]]++;
        }
        int i = 0;
        for(int j = 0; j < bucket.length; j++){
            while(bucket[j]-- > 0){
                arr[i++] = j;
            }
        }
    }

桶排序的应用
给定一个数组，求如果排序之后，相邻两数的最大差值，要求时间复杂度O(N)，且要求不能用非基于比较的排序。

思路：这道题就是应用的桶排序。首先遍历一遍数组，找到最大值和最小值，然后创建一个len+1的数组（这样可以保证必定会有一个桶是空的，因此在找最大差值的时候，最大差值必然不会是在一个桶里面，这样就只需要记录相邻的桶的差值就可以了）。

package Code01;

public class Code11_MaxGap {
    public static void main(String[] args){
        int[] arr = {2,7,9,1,10,17};
        int res = maxGap(arr);
        System.out.println(res);
    }
    public static int maxGap(int[] arr){
        if(arr == null || arr.length < 2)
            return 0;
        int len = arr.length;
        int min = Integer.MAX_VALUE;
        int max = Integer.MIN_VALUE;
        for(int i = 0; i < len; i++){
            max = Math.max(max, arr[i]);
            min = Math.min(min, arr[i]);
        }
        //找出最大和最小的数字，方便后面将数字放进桶里面
        if(min == max)
            return 0;

        int[] maxs = new int[len + 1];
        int[] mins = new int[len + 1];
        boolean[] b = new boolean[len + 1];
        int bid = 0;
        for(int i = 0; i < arr.length; i++){
            bid = bucket(arr[i], len , min, max);//找出数字应该放在哪个桶里面
            mins[bid] = b[bid] ? Math.min(mins[bid], arr[i]) : arr[i];
            maxs[bid] = b[bid] ? Math.max(maxs[bid], arr[i]) : arr[i];
            b[bid] = true;
        }
        int res = 0;
        int lastMax = maxs[0];
        for(int i = 0; i < len + 1; i++){
            if(b[i]){
                res = Math.max(res, mins[i] - lastMax);
                lastMax = maxs[i];
            }
        }
        return res;

    }
    public static int bucket(long num, long len, long min, long max){
        return (int)((num - min) * len / (max - min));

    }
}