164. Maximum Gap

Given an unsorted array, find the maximum difference between the successive elements in its sorted form.

Try to solve it in linear time/space.

Return 0 if the array contains less than 2 elements.

You may assume all elements in the array are non-negative integers and fit in the 32-bit signed integer range.

思路：bucket sort，n个数，n-1个间隔，建设所有数不是平均间隔的，如果以一边包括间隔边界，一边不包括来兼通

几个细节需要考虑：

细节1：interval和桶下标j的确定，每个数要落到哪个桶里

细节2：计算桶间距时，pre和max_interval的确定

//inner class
     class bucket{
         int max;
         int min;
        //constructor: public, no return type
        public bucket(){
            max=-1;
            min=-1;
        }
    }
    public int maximumGap(int[] nums) {
        int max=0, min=Integer.MAX_VALUE, n=nums.length;
        if(n<=1) return 0;
        for(int i=0; i<n; i++){
            max = Math.max(max, nums[i]);
            min = Math.min(min, nums[i]);
        }
        if(max==min) return 0;
        double interval = (double)(max-min)/(n-1);
        //need n buckets, why????
        bucket[] buckets = new bucket[n];
        //need to initialize each class array element
        for(int i=0; i<buckets.length; i++){
            buckets[i] = new bucket();
        }
        for(int i=0; i<n; i++){
            int j = (int)((nums[i]-min)/interval);
            buckets[j].max = buckets[j].max<0? nums[i]: Math.max(buckets[j].max, nums[i]);
            buckets[j].min = buckets[j].min<0? nums[i]: Math.min(buckets[j].min, nums[i]);
        }
        int max_interval = buckets[0].max - buckets[0].min;
        int pre =  buckets[0].max;
        for(int j=1; j<buckets.length; j++){
            if(buckets[j].max>=0){
                max_interval = Math.max(max_interval, buckets[j].min - pre);
                pre = buckets[j].max;
            }
        }
        return max_interval;
    }

public int maximumGap(int[] nums) {
        int max=0, min=Integer.MAX_VALUE, n=nums.length;
        if(n<=1) return 0;
        for(int i=0; i<n; i++){
            max = Math.max(max, nums[i]);
            min = Math.min(min, nums[i]);
        }
        int[][] bucket = new int[n][2];
        for(int i=0; i<n; i++){
            for(int j=0; j<2; j++){
                bucket[i][j]=-1;
            }
        }
        double interval = (double)(max-min)/(n-1);
        if(max==min) return 0;
        for(int i=0; i<n; i++){
            int j = (int)((nums[i]-min)/interval);
            bucket[j][0] = bucket[j][0]<0? nums[i]: Math.max(bucket[j][0], nums[i]);
            bucket[j][1] = bucket[j][1]<0? nums[i]: Math.min(bucket[j][1], nums[i]);
        }
        int max_interval = bucket[0][0] - bucket[0][1];
        int pre =  bucket[0][0];
        for(int j=1; j<bucket.length; j++){
            if(bucket[j][0]>=0){
                max_interval = Math.max(max_interval, bucket[j][1] - pre);
                pre = bucket[j][0];
            }
            
        }
        return max_interval;
    }