Longest Consecutive Sequence 从无序数组中找最长的连续数字 @LeetCode

又是一道Hashtable或者HashSet的空间换时间的题！

取出HashSet中的某一元素x，找x-1,x-2....x+1,x+2...是否也在set里

package Level3;

import java.util.HashSet;
import java.util.Set;

/**
 * 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.
 * 
 */
public class S132 {

	public static void main(String[] args) {
		int[] num = {0,0};
		System.out.println(longestConsecutive(num));
	}

	// 遇到不能排序又要复杂度O(n)有序的问题，只能增加空间复杂度，用hashset或者hashtable
	public static int longestConsecutive(int[] num) {
		Set<Integer> set = new HashSet<Integer>();
		
		for (int i : num) {
			set.add(i);
		}
		int max = 0;
		
		for(int i=0; i<num.length; i++){
			if(set.contains(num[i])){
				int next = num[i] - 1;		// 找比num[i]小一个的值
				int count = 1;
				set.remove(num[i]);			// 及时的移除，减少之后的查找时间
				while(set.contains(next)){
					set.remove(next);
					next--;
					count++;
				}
				next = num[i] + 1;		// 找比num[i]大一个的值
				while(set.contains(next)){
					set.remove(next);
					next++;
					count++;
				}
				max = Math.max(max, count);
			}
		}
		
		return max;
	}

}

之前这样写，但发现最差复杂度并不是O(n)，因此会超时

public class Solution {
    public int longestConsecutive(int[] num) {
        HashSet hs = new HashSet();
        int max = 0;
        for(int i : num) {
            hs.add(i);
            int cnt = 0;
            int tmp = i;
            while(hs.contains(tmp-1)) {
                tmp--;
                cnt++;
            }
            while(hs.contains(tmp+1)) {
                tmp++;
                cnt++;
            }
            max = Math.max(max, cnt);
        }
        return max;
    }
}

重写：

public class Solution {
    public int longestConsecutive(int[] num) {
        HashSet hs = new HashSet();
        
        for(int i : num) {
            hs.add(i);
        }
        
        int max = 0;
        for(int i : num) {
            int cnt = 1;
            hs.remove(i);
            int tmp = i;
            while(hs.contains(tmp-1)) {
                hs.remove(tmp-1);
                tmp--;
                cnt++;
            }
            tmp = i;
            while(hs.contains(tmp+1)) {
                hs.remove(tmp+1);
                tmp++;
                cnt++;
            }
            max = Math.max(max, cnt);
        }
        return max;
    }
}