相邻两数最大差值

有一个整形数组A，请设计一个复杂度为O(n)的算法，算出排序后相邻两数的最大差值。

给定一个int数组A和A的大小n，请返回最大的差值。保证数组元素多于1个。

测试样例：

[1,2,5,4,6],5

返回：2

解析：使用bucket排序思想，把大小为n的数组分成(max-min)/n个区间，显然这个区间是1 ~ n。

映射函数如下：

((num - min) * n / (max - min));

这样写是因为(num-min) / ((max-min) / n) =  ((num - min) * n / (max - min));

比如num=6，min=1，max=6，(6-1) * 5 / (6-1) = 5，所以6在5号桶。这个映射函数决定了桶序号不可能为0，所以编程时要先剔除为0的空桶。

由于在任何一个桶中任何两个数的差值都不可能大于区间差值，而在空桶左右两边不空的桶里，相邻数的差值肯定大于区间值。所以产生最大差值的两个相邻数肯定来自不同的桶。所以只要计算桶之间数的间距就可以，也就是只用记录每个桶的最大值和最小值，最大差值可能来自某个非空桶的最小值减去前一个非空桶的最大值。

代码如下：

class Gap {public:    int maxGap(vector<int> A, int n) {       if(n < 0 || ((A.size()==0) ^ (n==0)))            return -1;                       int res = 0;       if(n < 2)        return res;                       int max = A[0], min = A[0];        for(int i=1; i<n; ++i){            if(A[i] > max)                max = A[i];           if(A[i] < min)                min = A[i];        }        if(max == min)        return res;                vector<bool> has_num(n+1, false);   //用来标记是否是非空桶        vector<int> maxs(n+1, 0);        vector<int> mins(n+1, 0);        for(int i=0; i<n; ++i){            int bucket_id = get_bucket_id(A[i], n, min, max);            maxs[bucket_id] = has_num[bucket_id] ? std::max(maxs[bucket_id], A[i]) : A[i];            mins[bucket_id] = has_num[bucket_id] ? std::min(mins[bucket_id], A[i]) : A[i];            has_num[bucket_id] = true;        }                int k = 0;        int last_max = 0;        while(k <= n){            if(has_num[k]){               last_max = maxs[k];   //排除序号为0的空桶，因为前面都是空桶，不是数据，相邻最大差是数据与数据之间的最大差，所以第一个last_max=maxs[k]，               break;                //从下一个mins减去这个last_max开始找出最大的差            }           ++k;        }               while(++k <= n){            if(has_num[k]){       //只有非空桶才可以进入，所以res一直为两个非空桶的差                res = std::max(mins[k]-last_max, res);                last_max = maxs[k];   //注意更新last_max            }        }                return res;    }private:    int get_bucket_id(long long num, long long n, long long min, long long max){   //使用long long类型防止溢出        return (int)((num - min) * n / (max - min));    }};

整段程序的核心就是：

            while(++k <= n){            if(has_num[k]){       //只有非空桶才可以进入，所以res一直为两个非空桶的差                res = std::max(mins[k]-last_max, res);                last_max = maxs[k];   //注意更新last_max            }        }

这一段程序通过++k保证了在之前k的基础上加1，has_num[k]保证只有非空桶进入该条件，所以相邻两个非空桶就会进入，并计算res。我们要注意更新last_max。