LintCode_400 Maximum Gap

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

Return 0 if the array contains less than 2 elements.

 Notice

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

Have you met this question in a real interview? 

Yes

Example

Given [1, 9, 2, 5], the sorted form of it is [1, 2, 5, 9], the maximum gap is between 5 and 9 = 4.

Challenge 

Sort is easy but will cost O(nlogn) time. Try to solve it in linear time and space.

思路是用桶排序做， 桶的长度为（max_v - min_v) / (len - 1);

对每个数入桶，然后结果肯定是这个桶的最小值和上个桶的最大值之间的差值， 遍历O(n);

class Solution {
public:
    /**
     * @param nums: a vector of integers
     * @return: the maximum difference
     */
    int maximumGap(vector nums) {
        // write your code here
        if (nums.size() < 2) {
            return 0;
        }
        if (nums.size() == 2) {
            return abs(nums[1] - nums[0]);
        }
        int min_v = INT_MAX;
        int max_v = INT_MIN;
        for (int i = 0; i < nums.size(); i++) {
            if (nums[i] < min_v) {
                min_v = nums[i];
            }
            if (nums[i] > max_v) {
                max_v = nums[i];
            }
        }
        
        int len = nums.size();
        double bucket_len = ((double)max_v-double(min_v)) / (len - 1);
        //cout< bucket_min(len, INT_MAX);
        vector bucket_max(len, INT_MIN);
        for (int i = 0; i < nums.size(); i++) {
             int index = ceil( (double)(nums[i] - min_v) / bucket_len ) - 1;
             index = max(0, index);
             if (nums[i] < bucket_min[index]) {
                 bucket_min[index] = nums[i];
             }
             if (nums[i] > bucket_max[index]) {
                 bucket_max[index] = nums[i];
             }
        }
        
        int res = 0;
        for (int i = 1; i < len; i++) {
            if (bucket_min[i] == INT_MAX && bucket_max[i] == INT_MIN) { // 考虑INT_MAX和INT_MIN的问题
                bucket_min[i] = bucket_min[ i - 1];
                bucket_max[i] = bucket_max[ i - 1];
            } else {
               res = max(res, bucket_min[i] - bucket_max[i - 1]);
            }
        }
        return res;
    }
};