【leetcode 桶排序】Maximum Gap

1、题目

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.

2、分析

题意：给定一个未排序的数组。返回其排序后的数组中 相邻元素之差 最大的值。

比方给定：[5,9,8,3,15]

排序后为：[3,5,8,9,15]。相邻元素之差最大的是15-9=6，返回6。

复杂度要求：时间空间均为O(n)。

这道题最直接的解法是，先排序，得到有序数组。然后再对相邻元素作差。找出差最大的，比方以下简短的代码：

class Solution {
public:
    int maximumGap(vector<int> &num) {
        if(num.size()<2) return 0;
        sort(num.begin(),num.end()); //O(nlogn)
        int gap=-1;
        for(int i=1;i<num.size();i++){
            gap=max(gap,num[i]-num[i-1]);
        }
        return gap;
    }
};

在Leetcode上上面的代码能够AC，但其实并没有满足时间复杂度要求。由于STL函数sort()的复杂度是O(nlogn)，【sort C++ reference】。

那么。线性的排序算法有哪些？计数排序、基数排序、桶排序。

以下用桶排序实现。这也是leetcode上给出的參考解法。我直接copy过来：

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 maxNum = num[0];
        int minNum = num[0];
        for (int i : num) {
            maxNum=max(maxNum,i);
            minNum=min(minNum,i);
        }
        // 每一个桶的长度len,向上取整所以加+
        int len = (maxNum - minNum) / num.size() + 1;
        
        //桶的个数:(maxNum - minNum) / len + 1,每一个桶里面存储属于该桶的最大值和最小值就可以，注意这里的最大最小值是局部的
        vector<vector<int>> buckets((maxNum - minNum) / len + 1);
        for (int x : num) {
            int i = (x - minNum) / len;
            if (buckets[i].empty()) {
                buckets[i].reserve(2);
                buckets[i].push_back(x);
                buckets[i].push_back(x);
            } else {
                if (x < buckets[i][0]) buckets[i][0] = x;
                if (x > buckets[i][1]) buckets[i][1] = x;
            }
        }
        //gap的计算，For each non-empty buckets p, find the next non-empty buckets q, return min（ q.min - p.max ）
        int gap = 0;
        int prev = 0;
        for (int i = 1; i < buckets.size(); i++) {
            if (buckets[i].empty()) continue;
            gap = max(gap, buckets[i][0] - buckets[prev][1]);
            prev = i;
        }
        return gap;
    }
};

【其它解法以后再更新】