Leetcode|Maximum Gap

最新推荐文章于 2021-02-26 15:12:33 发布

一的三次方

最新推荐文章于 2021-02-26 15:12:33 发布

阅读量337

点赞数

CC 4.0 BY-SA版权

分类专栏：算法 leetcode

本文链接：https://blog.youkuaiyun.com/mike_learns_to_rock/article/details/46679061

leetcode 同时被 2 个专栏收录

69 篇文章

订阅专栏

算法

14 篇文章

订阅专栏

本文介绍了一种线性时间复杂度求解未排序数组中最大元素间距的方法，利用桶排序原理，通过维护桶内最大最小值来计算排序后数组的最大间距。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

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.

这题是桶排序的应用，其实不需要完全的排序。只需要计算出相邻桶之间的元素的差值。所以每个桶里面只需要维护两个元素即可，最大和最小的。

注意肯定有的桶是空桶，注意跳过。

桶的单位大小是(max-min)/nums.size()+1;

代码如下：

int maximumGap(vector<int>& nums) {
        if(nums.size()<2) return 0;
        int min=nums[0],max=nums[0];
        for(int i=1;i<nums.size();i++)
        {
            min=min>nums[i]?nums[i]:min;
            max=max<nums[i]?nums[i]:max;
        }
        //得到了min和max，可以分桶了
        int bucket_size=(max-min)/nums.size()+1;
        vector<vector<int> > bucket((max-min)/bucket_size+1);
        for(int i=0;i<nums.size();i++)
        {
            int index=(nums[i]-min)/bucket_size;
            if(bucket[index].empty())
            {
                bucket[index].push_back(nums[i]);
                bucket[index].push_back(nums[i]);
            }else{
                bucket[index][0]= bucket[index][0]>nums[i]?nums[i]:bucket[index][0];
                bucket[index][1]= bucket[index][1]<nums[i]?nums[i]:bucket[index][1];
            }
        }
        int prev=0;
        int maxgap=INT_MIN;
        for(int i=1;i<bucket.size();i++)
        {
            if(bucket[i].empty()) continue;
            int gap=bucket[i][0]-bucket[prev][1];
            prev=i;
            maxgap=maxgap<gap?gap:maxgap;
        }
        return maxgap;
    }

leetcode的solution说明：

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.