LeetCode 164. Maximum Gap

最新推荐文章于 2024-10-16 14:45:51 发布

原创最新推荐文章于 2024-10-16 14:45:51 发布 · 238 阅读

0 ·

CC 4.0 BY-SA版权

LeetCode 题解同时被 2 个专栏收录

288 篇文章

订阅专栏

Multiple Passes

85 篇文章

订阅专栏

本文详细介绍了桶排序算法的过程，包括如何确定桶的长度、数量以及如何在每个非空桶中找到潜在的答案。通过一个具体的例子，清晰地展示了算法的实现步骤。

This one is to use bucket sort.

Review bucket sort process first:

Suppose there are N elements and they range from A to B, then, the maximum gap will be no smaller then 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 numbers of buckets. (might have empty 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 minmum 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.

An example will make the explain clear.

Suppose, we have array, [2, 3, 7, 9, 100] (it actually doesn't matter whether the given array is sorted or not.)

So, maximum = 100, min = 2 --> bucket len = (max - min) / (size-1) -- > 98/4 --> 25 (ceiling value)

Then, bucket number is : (100 - 2)/ len + 1 --> 98 / 25 + 1 --> 5. We thus have 5 buckets.

Location of input number is calculated by (num[i] - min) / len

2 ----> loc = 0

3 ---> loc = 0

7 ----> loc = 0

9---> loc = 0

100--> loc = 4. In this case, bucket 1, 2, 3 are empty (we didn't use them)

Following code is copied from others.

        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);  
            }  

            // bucket len
            int len = (maxNum - minNum) / num.size() + 1;  
              
            // bucket number
            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;  
                }  
            }  

            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;  
        }