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.

官方给出的Solution：

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.

大致意思就是：

找出数组中的最小值A和最大值B，若数组共有N个元素，则最大连续元素的差值不会小于ceiling[(B - A) / (N - 1)]。

用桶排序，每个桶的长度len = ceiling[(B - A) / (N - 1)]，则桶的个数最多为 (B - A) / len + 1。

对于一个数组元素K，可以通过 (K - A) / len来得到它在哪个桶中，对于每个桶只需记录其中的最大值和最小值即可。

由于同一个桶中的元素最大差值是len - 1，所以最终的答案肯定是不同的桶的元素之差。

对于每一个非空的桶p，找到下一个非空的桶q，则q.min - p.max可能是答案，遍历每个桶最终的最大值即是答案。

public int maximumGap(int[] num) {
        if(num == null || num.length < 2) {
            return 0;
        }
        int len = num.length;
        int max = num[0];
        int min = num[0];
        for(int i : num) {
            max = Math.max(max, i);
            min = Math.min(min, i);
        }
        // the maximum gap will be no smaller than ceiling[(max - min) / (len - 1)]
        int gap = (int)Math.ceil((double)(max - min)/(double)(len - 1));
        //num of bucket
        int bucketNum = (max - min) / gap + 1;
        int[] bucketMin = new int[bucketNum];
        int[] bucketMax = new int[bucketNum];
        Arrays.fill(bucketMin, Integer.MAX_VALUE);
        Arrays.fill(bucketMax, Integer.MIN_VALUE);
        
        for(int i : num) {
            //index of current element
            int index = (i - min)/gap;
            bucketMin[index] = Math.min(bucketMin[index], i);
            bucketMax[index] = Math.max(bucketMax[index], i);
        }
        int ret = 0;
        int preMax = min;
        for(int i=0; i<bucketNum; i++) {
            if(bucketMin[i] == Integer.MAX_VALUE && bucketMax[i] == Integer.MIN_VALUE) {
                //empty bucket
                continue;
            }
            ret = Math.max(ret, bucketMin[i] - preMax);
            preMax = bucketMax[i];
        }
        //last bucket
        ret = Math.max(ret, max - preMax);
        return ret;
    }