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.

题意：

给定一个数组，找出该数组排序后两两数字之间的最大差值。

解题思路；

1.最先想到的就是排序，然后计算两两之间的差值。     时间复杂度： O（nlogn）

2. 开辟一个INT_MAX大小的空间，然后将存在的元素置true, 再计算两两之间的差值。  但是这样会超时，为什么呢？因为开辟空间太大啦

3.那就对上面改进一下咯，其实范围不需要这么大，找到数组中最大值和最小值，因此需开辟最大值-最小值的空间范围.

但是。。。。。空间超了额。。。

下面是代码：正确的，但是空间超了

class Solution {
public:
    int maximumGap(vector<int>& nums) {
        if(nums.size() < 2) return 0;
        int maxn = INT_MIN, minn = INT_MAX;
        for(int i = 0; i < nums.size(); i++){
            if(nums[i] < minn)
                minn = nums[i];
            if(nums[i] > maxn)
                maxn = nums[i];
        }
        int gap = maxn - minn+1;
        vector<int>vec(gap,0);
        for(int i = 0; i < nums.size(); i++){
            vec[nums[i] - minn]++;
        }
        int last = 0, ma = -1;
        for(int i = 1; i < gap; i++){
            if(vec[i] > 0){
                ma = max(ma, i-last);
                last = i;
            }
        }
        

        return ma;
    }
};

3.别人的思路   桶排序 那就只能把空间范围再次缩小啦~~

解题思路：

基数排序（radix sort）/桶排序（bucket sort）

官方版（桶排序）：

假设有N个元素A到B。

那么最大差值不会小于ceiling[(B - A) / (N - 1)]

令bucket（桶）的大小len = ceiling[(B - A) / (N - 1)]，则最多会有(B - A) / len + 1个桶

对于数组中的任意整数K，很容易通过算式loc = (K - A) / len找出其桶的位置，然后维护每一个桶的最大值和最小值

由于同一个桶内的元素之间的差值至多为len - 1，因此最终答案不会从同一个桶中选择。

对于每一个非空的桶p，找出下一个非空的桶q，则q.min - p.max可能就是备选答案。返回所有这些可能值中的最大值。

下面是代码

class Solution {
public:
    int maximumGap(vector<int>& nums) {
        if(nums.size() < 2) return 0;
        double maxn = INT_MIN, minn = INT_MAX, len = nums.size();
        for(int i = 0; i < nums.size(); i++){
            if(nums[i] < minn)
                minn = nums[i];
            if(nums[i] > maxn)
                maxn = nums[i];
        }
        int bucket_size = ceil((maxn - minn)/(len-1)); //桶的大小  出错2
        if(bucket_size == 0) return 0; //出错1
        int bucket_num = (maxn-minn)/bucket_size+1; //桶的个数
        vector<vector<int>>vec(bucket_num,vector<int>());
        for(int i = 0; i < nums.size(); i++){
            vec[(nums[i] - minn)/bucket_size].push_back(nums[i]);
        }
        int pre_max = 0, res = 0;
        for(int i = 0; i < bucket_num; i++){
            int cur_min = INT_MAX, cur_max = 0;
            for(int j = 0; j < vec[i].size(); j++){
                if(vec[i][j] > cur_max)
                    cur_max = vec[i][j];
                if(vec[i][j] < cur_min)
                    cur_min = vec[i][j];
            }
            if(vec[i].size() > 0){ //出错3
                 if(i > 0) //出错4
                    res = max(res, cur_min - pre_max);
                pre_max = cur_max;
            }
        }
        return res;
    }
};

尽管根据上面的来写代码，但是仍然有些小trips的地方出错：

出错1： 对于【1，1，1，1】 这种case,  没有对bucket_size=0进行验证，导致运行bucket_num时分母为0，出错；

出错2：开始时计算bucket_size时， 没有用ceil,导致对于【1，1，1，1，5，5，5，5】这种case,运行出的bucket_size为0；

出错3：由于有些桶存在个数为0的情况，因此需要跳过这种情况，即加入判断 if(vec[i].size() > 0)

出错4：因为我是计算当前的最小值与前面最大值的差值，因此对于第0号的bucket_num, 它前面的最大值是不知道的，因此需要跳过去，因此要加入if(i>0)