LeetCode 164. Maximum Gap

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