[Leetcode] 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、桶排序：设数组中有n个元素，其中最大值为Max，最小值为Min，则排序后相邻两个元素的差值的最大值不会小于ceil((Max - Min)/(n - 1))（可以利用反证法进行证明）。因此我们的做法是：设置桶的大小为size = ceil((Max - Min)/(n - 1))，那么桶的个数为(Max - Min) / size + 1；我们遍历数组，对每个桶计算其最大值和最小值，最后遍历一遍桶，因为最大的gap不会出现在桶内部，而在桶之间，所以获得“后一个非空桶的最小值减前一个非空桶的最大值的最大值”，即为我们的题目所求。该思路的时间复杂度和空间复杂度都是O(n)。

2、基数排序：这道题目还可以使用基数排序来完成。我们先简单介绍一下基数排序的概念：就是按照数字的低位到高位依次对每一位进行排序，比如5632, 7689, 2136, 2137, 2148, 6782。先对最后一位进行排序，可以装入十个桶内，对应的桶内装的数字在该位对应的是0~9这十个数字，然后接着对倒数第二位再进行排序，依次往前，直到排到最高位。为了便于理解，我们把每次排序之后的结果列举如下：

倒数第一位：5632, 6782, 2136, 2137, 2148, 7689；

倒数第二位：5632, 2136, 2137, 2148, 6782, 7689；

倒数第三位：2136, 2137, 2148, 5632, 7689, 6782；

倒数第四位：2136, 2137, 2148, 5632, 6782, 7689。

在进行基数排序之后，我们就可以通过一次线性扫描从而得到Maximum Gap。基数排序的时间复杂度是O(k*n)，空间复杂度是O(k + n)。由于题目中限定输入数据在32位有符号整数的范围之内，所以可以认为k是一个小于等于32位的常数，所以用基数排序也符合本题目的要求。

代码：

1、桶排序：

class Solution {
public:
    int maximumGap(vector<int>& nums) {
        if(nums.size() < 2) {
            return 0;
        }
        int Max = *max_element(nums.begin(), nums.end());
        int Min = *min_element(nums.begin(), nums.end());
        if(Max == Min) {
            return 0;
        }
        int gap = ceil(static_cast<double>(Max - Min) / (nums.size() - 1));
        int bucketNum = ceil(static_cast<double>(Max - Min) / gap);
        vector<int> bucketsMin(bucketNum, INT_MAX);
        vector<int> bucketsMax(bucketNum, INT_MIN);
        for(int i = 0; i < nums.size(); ++i) {
            if(nums[i] == Max || nums[i] == Min) {
                continue;
            }
            int idx = (nums[i] - Min) / gap;
            bucketsMin[idx] = min(bucketsMin[idx], nums[i]);
            bucketsMax[idx] = max(bucketsMax[idx], nums[i]);
        }
        int ans = INT_MIN;
        int previous = Min;
        for(int i = 0; i < bucketNum; ++i) {
            if(bucketsMin[i] == INT_MAX || bucketsMax[i] == INT_MIN) {
                continue;
            }
            ans = max(ans, bucketsMin[i] - previous);
            previous = bucketsMax[i];
        }
        ans = max(ans, Max - previous);
        return ans;
    }
};

2、基数排序：

class Solution {
public:
    int maximumGap(vector<int>& nums) {
        if (nums.size() < 2) {
            return 0;
        }
        int length = to_string(*max_element(nums.begin(), nums.end())).size();
        int radix = 1, max_gap = 0, size = nums.size();
        for (int i = 0; i < length; ++i) {          // step 1: radix sort
            vector<int> buckets(10, 0), temp_nums(size);
            for (int val : nums) {                  // store the appearance count to buckets
                ++buckets[(val / radix) % 10];
            }
            for (int j = 1; j < 10; ++j) {          // make buckets[j] the index of nums[j] in temp_nums
                buckets[j] += buckets[j - 1];
            }
            for (int j = size - 1; j >= 0; --j) {   // store the data to temperary array
                temp_nums[--buckets[(nums[j] / radix) % 10]] = nums[j]; 
            }
            for (int j = 0; j < size; ++j) {        // assign the sorted data to the nums
                nums[j] = temp_nums[j];
            }
            radix *= 10;
        }
        for (int i = 1; i < size; ++i) {            // step 2: get max gap
            max_gap = max(max_gap, nums[i] - nums[i - 1]);
        }
        return max_gap;
    }
};