这题挺让我奇怪的，看起来没有hard的难度，但是正确的解法考察对各种STL时间复杂度的理解。
题目要求时间复杂度做到O(n)，那么其实是不能用map或set来做，因为它们的内部是由红黑树实现的（平衡搜索二叉树），其插入，查找的时间复杂度都在O（logN），将数组逐个插入维护map的操作时间复杂度就到了O（NlogN）了。
正确的解法是，利用unordered_set的哈希特性，其插入查找的时间复杂度都在O（1），最坏是O（N）。对于数组中的每个数x，我们只需要查找在数组中是否存在x+1,x+2,x+3…x+y，以x为起点的最长连续序列长度就是y了，这个查找过程可以通过unordered_set降低到O（1）！而且对于x，若其x-1是存在于数组中的话它其实是一定会在x-1的查找过程中被找到的，所以对于存在x-1的结果在数组中的x是需要被跳过的！
但是奇怪的是提交的结果map竟然在时间和空间都由于unordered_set！！

unordered_set

class Solution {
public:
    int longestConsecutive(vector<int>& nums) {
        if(nums.size() == 0)
            return 0;
        unordered_set<int> uset;
        for(int i=0;i<nums.size();i++)
            uset.insert(nums[i]);
        
        int len = 1;
        for(auto iter=uset.begin();iter!=uset.end();iter++){
            if(uset.find(*iter-1) == uset.end()){
                int tmp = 1;
                int num = *iter;
                while(uset.find(++num)!=uset.end())
                    tmp++;
                len = max(tmp,len);
            }
        }
        return len;
    }
};

map

class Solution {
public:
    int longestConsecutive(vector<int>& nums) {
        if(nums.size() == 0)
            return 0;
        map<int,int> m;
        for(int i=0;i<nums.size();i++)
            m[nums[i]]++;
        vector<int> list;
        for(auto iter=m.begin();iter!=m.end();iter++)
            list.push_back(iter->first);
        int i=0;
        int j=1;
        int len = 1;
        while(j<list.size()){
            if(list[j] == list[j-1]+1){
                len = max(len,j-i+1);
                j++;
            }
            else{
                j++;
                i = j-1;
            }
        }
        
        return len;
    }
};