LeetCode 164. 最大间距

给定一个无序的数组，找出数组在排序之后，相邻元素之间最大的差值。

如果数组元素个数小于 2，则返回 0。

示例 1:

输入: [3,6,9,1]
输出: 3
解释: 排序后的数组是 [1,3,6,9], 其中相邻元素 (3,6) 和 (6,9) 之间都存在最大差值 3。
示例 2:

输入: [10]
输出: 0
解释: 数组元素个数小于 2，因此返回 0。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/maximum-gap
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

 

详解：

这个题的思路需要用到桶的思想去考虑，效率才会最佳。

什么叫桶：粗略的说一下，桶是可以放一定东西的容器，比如这一题的桶定义为可以存放一定范围的数。

举个例子：定义一个存放大于1小于n的数的桶，待会遍历数组的时候，遇到大于1小于n的数，这个数就可以放到这个桶。

解释完桶的概念，我直接说思路吧，根据思路去理解题目的解答：

1. 先找出这数组(长度为n)的最大数max和最小数min，然后创建n个桶。每个桶依次存放从min开始范围为(max-min)/n的所有数

2. 听起来有写生硬，举个例子吧

   假如max = 10, min = 1,n = 5;

   那么建5个桶，他们存放数的范围依次是1~2，3~4，5~6，7~8，9~10

3. 然后依次遍历更新所有桶里面的最大值和最小值，那么就可以得到max[i](第i个桶的最大数的值)，min[i]（第i个桶的最小数的值）

可以知道，每个桶内的最大最小值之差肯定不是结果。为什么呢？

讲道理这是桶的定理，我这里也稍微解释一下吧：

用反证法1：，假如某个桶m = max[i]-min[i]就是最大值，那么得出下面结论

1. 这个值m肯定会<=桶的容量R；
2. 其他所有的桶j的max[j]-min[j]<=m；
3. i前面所有的桶j和后面所有的桶k有：min[j]-max[j-1]和min[k+1]-max[k]都小于等于m

由第三条可以推出每个桶最少有一个数，为什么？假如某个桶j没有数，那么第min[j+1]-max[j-1]>桶的容量R>m,与原假设1矛盾，所以每个桶最少有一个数。

那这样n个桶出现了n+1个数，与只有n个数矛盾，所以原假设不成立。

所以最大差值一定在桶之间产生，在遍历一下所有桶，更新最大差值，可得到结果。

再详细的思路也不及代码片行，那直接贴代码：

    public int maximumGap(int[] nums) {
        int length = nums.length;
        if(length < 2){
            return 0;
        }
        int minValue = Integer.MAX_VALUE;
        int maxValue = Integer.MIN_VALUE;
        for (int num : nums) {
            if (minValue > num) {
                minValue = num;
            }
            if (maxValue < num) {
                maxValue = num;
            }
        }
        int[] minBucket = new int[length];
        int[] maxBucket = new int[length];

        for(int i = 0; i < length; i ++){
            minBucket[i] = Integer.MAX_VALUE;
            maxBucket[i] = Integer.MIN_VALUE;
        }
        int index, bucketValue = (maxValue - minValue) / length + 1;
        for (int num : nums) {
            index = (num - minValue) / bucketValue;
            if (minBucket[index] > num) {
                minBucket[index] = num;
            }
            if (maxBucket[index] < num) {
                maxBucket[index] = num;
            }
        }

        int tmp, maximumGap = 0;
        index = 0;
        for(int i = 1; i < length; i ++){
            if(minBucket[i] == Integer.MAX_VALUE){
                continue;
            }
            tmp = minBucket[i] - maxBucket[index];
            index = i;
            if(maximumGap < tmp){
                maximumGap = tmp;
            }
        }
        return maximumGap;
    }

最后贴效率：