leetcode--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.

code 1:

public class Solution {
    public int longestConsecutive(int[] num) {
        int max = 0, length = num.length;
		if(length > 0){
			Map<Integer, Integer> conSeq = new HashMap<Integer, Integer>();
			for(int i = 0; i < length; ++i){
				int left = num[i], right = num[i], len = 1;		
				if(!conSeq.containsKey(num[i])) {
				    conSeq.put(num[i], 1);
				    if(conSeq.containsKey(left - 1) && conSeq.containsKey(right + 1)){
					    len += (conSeq.get(left - 1) + conSeq.get(right + 1));
					    left -= conSeq.get(left - 1);
					    right += conSeq.get(right + 1);
				    }
				    else if(conSeq.containsKey(left - 1) && !conSeq.containsKey(right + 1)){
				        len += conSeq.get(left - 1);
					    left -= conSeq.get(left - 1);
				    }
				    else if (!conSeq.containsKey(left - 1) && conSeq.containsKey(right + 1)){
					    len += conSeq.get(right + 1);
					    right += conSeq.get(right + 1);
				    }
				    else{
					    //do nothing
				    }
				    max = Math.max(max, len);
				    conSeq.put(left, len);
				    conSeq.put(right, len);
				}
			}
		}
		return max;    
    }
}

　　

 code 2:

public class Solution {
    public int longestConsecutive(int[] num) {
        int length = 0;
		if(num.length > 0){
		    length = 1;
			Map<Integer, Integer> lens = new HashMap<Integer, Integer>();
			Map<Integer, Integer> visited = new HashMap<Integer, Integer>();
			for(int i = 0; i < num.length; ++i){
				lens.put(num[i], 1);
				visited.put(num[i], 0);
			}
			
			for(int i = 0; i < num.length; ++i){
				if(visited.get(num[i]) != 0)
					continue;
				else{
					visited.put(num[i], 1);
					if(lens.containsKey(num[i] - 1)){
						if(visited.get(num[i] - 1) == 0){
							int templength = lens.get(num[i] - 1) + lens.get(num[i]);
							lens.put(num[i], templength);
							lens.put(num[i] - lens.get(num[i] - 1), templength);
							length = (length < templength)? templength: length;
							visited.put(num[i] - 1, 1);
						}
					}
					if(lens.containsKey(num[i] + 1)){
						int templength = lens.get(num[i] + 1) + lens.get(num[i]);
						lens.put(num[i] - lens.get(num[i]) + 1, templength);
						lens.put(num[i] + lens.get(num[i] + 1), templength);
						length = (length < templength)? templength: length;
					}					
				}
			}
		}
		return length;
    }
}