LeetCode Maximum Gap

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

等会去看下discuss，找了一个使用基数排序的，发现比快排多了一倍的时间。

第二轮：

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.

只能说自己实现的挫：

#include <iostream>
#include <map>
#include <vector>
#include <cmath>

using namespace std;


class Bucket {
private:
    int min_value;
    int max_value;
    int idx;
    bool isempty;
public:
    Bucket() : min_value(INT_MAX), max_value(INT_MIN) {
        isempty = true;
    }
    void push(int v) {
        if (min_value > v) {
            min_value = v;
        }
        if (max_value < v) {
            max_value = v;
        }
        isempty = false;
    }
    bool empty() {return isempty;}
    int getMax() {return max_value;}
    int getMin() {return min_value;}
    int getIdx() {return idx;}
    void setIdx(int val) {idx = val;}
};

class Solution {
public:
    int maximumGap(vector<int> &num) {
        int n = num.size();

        if (n < 2) {
            return 0;
        }

        int maxv = INT_MIN;
        int minv = INT_MAX;
        for (int e : num) {
            if (e > maxv) {
                maxv = e;
            } else if (e < minv) {
                minv = e;
            }
        }

        int diff = maxv - minv;

        int min_gap = ceil(diff * 1.0 / (n-1));
        int bn = diff / min_gap + 1;

        map<int, Bucket> buckets;

        for (int e : num) {
            int idx = (e - minv) / min_gap;
            if (buckets.count(idx) < 1) {
                buckets[idx] = Bucket();
            }
            buckets[idx].push(e);
        }

        auto iter = buckets.begin();


        Bucket last = iter->second;
        int max_gap = last.getMax() - last.getMin();

        for (iter++;iter!=buckets.end();iter++) {
            int gap = iter->second.getMin() - last.getMax();
            if (gap > max_gap) {
                max_gap = gap;
            }
            gap = iter->second.getMax() - iter->second.getMin();
            if (gap > max_gap) {
                max_gap = gap;
            }
            last = iter->second;
        }
        return max_gap;
    }
};

int main() {
    vector<int> data  ={1,1,1,1,1,5,5,5,5,5};
    
    Solution s;
    int gap = s.maximumGap(data);
    cout<<gap<<endl;
    return 0;
}