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.

注释部分是我刚开始直接按数据结构上的桶排序，然后通过了，便于刚开始理解。

后来参照别人的思路（想不通的话可以自己借助实例数组，自己跟着程序手动走一遍）：

    用桶排序
    算出相邻两个桶之间的最大差值
    如果是平均分布，则桶的数目和元素的数目相同时，其排序的时间复杂度是0(n)
    假设桶的个数和元素的数目相同，若是平均分布，则每个桶里有一个数，而若某个桶里有两个以上的桶时，这时必有至少一个是空桶，那么最大间隔可能就落在空桶的相邻两个桶存储的数之间，最大间隔不会落在同一个桶的数里，因此我们不需要对每个桶再排一次序，只需要记录同一个桶的最大值和最小值，算出前一个有最大值的桶和后一个有最小值的桶之差，则可能是最大间隔
    步骤：1）.算好用的桶的个数，用最大元素和最小元素算出平均间隔，记录在平均间隔上的最大值和最小值，
         2）. 再算出前一个间隔里的最大值和后一个间隔里的最小值之差，取最大的一个，
         3）. 再算出最小值和第二小的差（平均间隔最小值第一个），最大值和第二大（平均间隔最大值最后一个）的差，三个值相比，取最大的，就是最大间隔

class Solution {
public:
int maximumGap(vector<int> &num) 
{
    if(num.size()<2)return 0;
    int maxN=*max_element(num.begin(),num.end());
    int minN=*min_element(num.begin(),num.end());
    int gap=ceil(double(maxN-minN)/(num.size()-1));
    int nBacket=ceil(double(maxN-minN)/gap);
    vector<pair<int, int>> vec(nBacket,make_pair(INT_MAX,INT_MIN));
    for (int i=0;i<num.size();i++)
    {
        if(num[i]==maxN||num[i]==minN)continue;
        int nBack=(num[i]-minN)/gap;
        if (num[i]<vec[nBack].first)vec[nBack].first=num[i];
        if(num[i]>vec[nBack].second)vec[nBack].second=num[i];
    }
    int maxGap=0;
    int pre=minN;
    for(int i=0;i<nBacket;i++)
    {
        if(vec[i].second==INT_MIN)continue;
        int tmp=vec[i].first-pre;
        maxGap=maxGap>tmp?maxGap:tmp;
        pre=vec[i].second;
    }
    maxGap=maxGap>maxN-pre?maxGap:maxN-pre;
    return maxGap;
}
/**
int maximumGap(vector<int> &num) {
    if(num.size()<2)return 0;
    vector<int> vec0;
    vector<vector<int>> vec1(10,vec0);
    vector<int> tmp(num);
    int min=*min_element(num.begin(),num.end());
    int max=*max_element(num.begin(),num.end());
    int loop=0;
    int tmax=max;
    while (tmax)
    {
        tmax/=10;
        loop++;
    }
    int power=1;
    for (int i=0;i<loop;i++)
    {
        if(i==0)power=1;
        else power*=10;
        vector<vector<int>> vec(vec1);
        for (int k=0;k<tmp.size();k++)
        {
            int n=tmp[k]/power-(int(tmp[k]/(10*power)))*10;
            vec[n].push_back(tmp[k]);
        }
        tmp.clear();
        for(int j=0;j<10;j++)
        {
            if(vec[j].empty())continue;
            else
            {
                for (int jj=0;jj<vec[j].size();jj++)
                {
                    tmp.push_back(vec[j][jj]);
                }
            }
        }
    }
    int maxGap=tmp[1]-tmp[0];
    for (int i=2;i<tmp.size();i++)
    {
        maxGap=maxGap>tmp[i]-tmp[i-1]?maxGap:tmp[i]-tmp[i-1];
    }
    return maxGap;
}
*/
};