天题系列： Maximum Gap --bucket sort

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.

OG soln:

Suppose there are N elements and they range from A to B.

Then the maximum gap will be no smaller than ceiling[(B - A) / (N - 1)]

Let the length of a bucket to be len = ceiling[(B - A) / (N - 1)], then we will have at most num = (B - A) / len + 1 of bucket

for any number K in the array, we can easily find out which bucket it belongs by calculating loc = (K - A) / len and therefore maintain the maximum and minimum elements in each bucket.

Since the maximum difference between elements in the same buckets will be at most len - 1, so the final answer will not be taken from two elements in the same buckets.

For each non-empty buckets p, find the next non-empty buckets q, then q.min - p.max could be the potential answer to the question. Return the maximum of all those values.

 

"in its sorted form." 这里就暗示了必须得排序，所以之后找结果就是两个相邻桶之间的计算。最后计算的时候，是n-1个桶的最大值，和n个桶的最小值之间的差，同样，是因为要sorted form

public class Solution {
    public int maximumGap(int[] num) {
        // bucket sort
        if(num==null || num.length<2) return 0; //bug
        
        int min = num[0], max = min;
        for(int i=0; i< num.length ; i++){
            if (min> num[i]) min = num[i];
            if(max< num[i]) max = num[i];
        }
        int len = (max-min)/(num.length-1); //bucket length, bucket has unlimit capacity
        if (len == 0 ) return max-min;
        int n = (max-min) / len +1; // buckets' number
        int[] bucketMin = new int[n];
        int[] bucketMax = new int[n];
        
        for(int i=0; i<n; i++){     // padding the buckets
            bucketMin[i]=Integer.MAX_VALUE;
            bucketMax[i]=Integer.MIN_VALUE;
        }
        
        for(int i=0; i< num.length; i++){
            int ind = (num[i]-min)/len;
            bucketMin[ind] = Math.min(bucketMin[ind], num[i]); // fill in buckets
            bucketMax[ind] = Math.max(bucketMax[ind], num[i]);
        }
        
        bucketMin[0] = min;
        bucketMax[n-1] = max;
        
        // 考虑怎么找到相邻的gapMax 问题: gap 必然出现在相邻桶的最大，最小之间
        int res = Integer.MIN_VALUE;
        int tmp = min;
        for(int ind=0; ind < n; ind++){
            if(bucketMin[ind]==Integer.MAX_VALUE || bucketMax[ind]==Integer.MIN_VALUE ) continue;
            res = Math.max(res, bucketMin[ind]-tmp);
            tmp = bucketMax[ind];
        }

        return res;
    }
}