Longest Consecutive Sequence

题目

Given an unsorted array of integers, find the length of the longest consecutive elements sequence.

For example,
Given [100, 4, 200, 1, 3, 2],
The longest consecutive elements sequence is [1, 2, 3, 4]. Return its length: 4.

Your algorithm should run in O(n) complexity.

思路一：先排序，再遍历

时间复杂度是：O(nlogn+n)

代码如下：

class Solution {
public:
    int longestConsecutive(vector<int> &num) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        if(num.size()<2)
            return num.size();
        sort(num.begin(),num.end());
        
        int max = 1;
        int tmp = 1;
        int i=1;
        while(i<num.size())
        {
            if(num[i]==num[i-1]+1)
            {
                tmp = tmp+1;
            }
            if(num[i]>num[i-1]+1)
            {
                max = tmp>max?tmp:max;
                tmp = 1;
            }  
            i = i+1;
        }
        max = tmp>max?tmp:max;       
        return max;
        
    }
};

此代码是完全可以通过 Juge Small  和 Juge Large 的。但是题目要求 是 Unsorted 和 O(N)。

思路二：Hash 思想

具体想法：

1、一边遍历vector，一边建立HashTable表。

2、对于当前的第i个元素，如果Map里面未出现，将其加入到Map中，并设置length=1：

（1）检测其左边的连续序列的左边界值 low：low = num[i]-1-mymap[num[i]-1]+1   这是已得到的当前元素的左连续序列的左边界元素，

          并更新该low元素和当前元素的lenth：mymap[num[i]] = mymap[low]+1;   mymap[low] = mymap[low]+1; （即更新该元素的左连续序列左右边界长度值length+1）

（2）检查其右边的连续序列的右边界值high，此时分两种情况：

          （A）如果当前元素没有左连续序列部分，即左边界为当前元素，则做类似于（1）的操作来处理右连续序列；

           （B）若有，则将当前元素插入到左连续序列 low = num[i]-mymap[num[i]]+1  和 右连续序列 high = num[i]+1+mymap[num[i]+1]-1 之间，

             并更新左边界low 和右边界high 的lenth长度：mymap[low] = mymap[low]+mymap[high];     mymap[high] = mymap[low];

实现代码：

class Solution {
public:
    int longestConsecutive(vector<int> &num) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        if(num.size()<2)
            return num.size();        
        int max = 1;
        unordered_map<long,int> mymap;
        int low,high;
        for(int i=0;i<num.size();i++)
        {
            if(mymap.find(num[i])!=mymap.end())
                continue ;
            mymap[num[i]]=1;
            if(mymap.find(num[i]-1)!=mymap.end())
            {
                low = num[i]-1-mymap[num[i]-1]+1;
                mymap[num[i]] = mymap[low]+1;
                mymap[low] = mymap[low]+1;
                max = mymap[low]>max?mymap[low]:max;
            }
            if(mymap.find(num[i]+1)!=mymap.end())
            {
                if(mymap[num[i]]==1)
                {
                    high = num[i]+1+mymap[num[i]+1]-1;
                    mymap[num[i]] = mymap[high]+1;
                    mymap[high] = mymap[high]+1;
                    max = mymap[high]>max?mymap[high]:max;
                }
                else
                {
                    low = num[i]-mymap[num[i]]+1;
                    high = num[i]+1+mymap[num[i]+1]-1;
                    mymap[low] = mymap[low]+mymap[high];
                    mymap[high] = mymap[low];
                    max = mymap[high]>max?mymap[high]:max;
                }                
            }
        }  
        return max;
        
    }
};

还可以进一步简化：因为如果 mymap[num[i]]==1 和 mymap[num[i]]>1 都有 low = num[i]-mymap[num[i]]+1 ，所以可以合并处理。

class Solution {  
public:  
    int longestConsecutive(vector<int> &num) {  
        // Start typing your C/C++ solution below  
        // DO NOT write int main() function  
        if(num.size()<2)  
            return num.size();          
        int max = 1;  
        unordered_map<long,int> mymap;  
        int low,high;  
        for(int i=0;i<num.size();i++)  
        {  
            if(mymap.find(num[i])!=mymap.end())  
                continue ;  
            mymap[num[i]]=1;  
            if(mymap.find(num[i]-1)!=mymap.end())  
            {  
                low = num[i]-1-mymap[num[i]-1]+1;  
                mymap[num[i]] = mymap[low]+1;  
                mymap[low] = mymap[low]+1;  
                max = mymap[low]>max?mymap[low]:max;  
            }  
            if(mymap.find(num[i]+1)!=mymap.end())  
            {  
                low = num[i]-mymap[num[i]]+1;  
                high = num[i]+1+mymap[num[i]+1]-1; 
                mymap[low] = mymap[low]+mymap[high];  
                mymap[high] = mymap[low];  
                max = mymap[high]>max?mymap[high]:max;            
            }  
        }    
        return max;            
    }  
};

Run Status: Accepted!
Program Runtime: 88 milli secs

最新：

public class Solution {
    public int longestConsecutive(int[] nums) {
        if(nums.length == 0){
            return 0;
        }
        Set<Integer> hash = new HashSet<>();
        int max = 0;
        for(int e : nums){
            hash.add(e);
        }
        for(int e : nums){
            int lenth = 1;
            int left = e-1;
            while(hash.contains(left)){
                lenth ++;
                hash.remove(left);   // if you have not this line, it will cause Time Limit Exceeded
                left --;
            }
            int right = e+1;
            while(hash.contains(right)){
                lenth ++;
                hash.remove(right);   // if you have not this line, it will cause Time Limit Exceeded
                right ++;
            }
            max = Math.max(max, lenth);
        }
        return max;
    }
}