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.

官方给的思路：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.

下面是自己的代码：

class Solution {
public:
    int maximumGap(vector<int> &num) {
        if(num.size()<2)
            return 0;
        int min=INT_MAX,max=INT_MIN;
        for(auto i:num){
            if(i<min)
                min=i;
            if(i>max)
                max=i;
        }
        int size=num.size();
        int bs=(max-min)/(size-1);
        if(bs==0)
            bs=1;
        int bn=(max-min)/bs+1;
         
        vector<pair<int,int>> ret(bn,make_pair(INT_MAX,INT_MIN));
        for(auto i:num){
            int pos=(i-min)/bs;
            if(i<ret[pos].first)
                ret[pos].first=i;
            if(i>ret[pos].second)
                ret[pos].second=i;
        }
        int ans=0;
        for(int i=0;i<bn;){
            if(ret[i].first!=INT_MAX){
                int j;
                for(j=i+1;j<bn && ret[j].first==INT_MAX;++j)
                    ;
                if(j==bn)
                    break;
                if(ret[j].first-ret[i].second>ans)
                    ans=ret[j].first-ret[i].second;
                i=j;
            }
        }
        return ans;
    }
};