128. Longest Consecutive Sequence

最长连续区间，如果可以SORT就太容易了。

SORT的目的是把连续的放到一起，便于我们遍历，我们可以手动完成这个过程。。

用MAP，先全都加进去，然后遍历原数组，往大小2个方向找，比较长度，找到了要REMOVE到，要不以后重复寻找了。

做了一般突然感觉不需要MAP，SET就可以，因为KEY和VALUE始终一样的。。。。

public class Solution 
{
    public int longestConsecutive(int[] nums) 
    {
        if(nums.length <= 1) return nums.length;
        
        Map<Integer,Integer> map = new HashMap<Integer,Integer>();
        
        for(int i:nums) map.put(i,i);
        int res = 1;
        for(int i = 0; i < nums.length;i++)
        {
            if(map.containsKey(nums[i]))
            {
                int max = 1;
                int smaller = nums[i]-1;
                int larger = nums[i]+1;
                
                while(map.containsKey(smaller))
                {
                    max++;
                    map.remove(smaller--);
                }
                while(map.containsKey(larger))
                {
                    max++;
                    map.remove(larger++);
                }
                
                res = Math.max(res,max);
                
            }
        }
        
        return res;
    }
}

---

---

二刷。

找最长连续序列。

建一个MAP，扫一遍数组加进去，这样就知道哪些数字有哪些没有了。

然后重新遍历数组，选一个往大找，往小找，找到就长度 + +，然后从MAP里删除相应的数字，前后都找不到了就更新。。

Time : O(n) 遍历了2次
Space : O(n) map

public class Solution {
    public int longestConsecutive(int[] nums) {
        if (nums.length <= 1) return nums.length;
        
        Map<Integer, Integer> map = new HashMap<>();
        
        for (int i : nums) {
            map.put(i, i);
        }
        
        int res = 0;
        
        for (int i : nums) {
            if (map.containsKey(i)) {
                int larger = i + 1;
                int smaller = i - 1;
                int max = 1;
                
                while (map.containsKey(larger)) {
                    map.remove(larger ++);
                    max ++;
                }
                while (map.containsKey(smaller)) {
                    map.remove(smaller --);
                    max ++;
                }
                res = Math.max(res, max);
            }
        }
        
        return res;
    }
}

---

三刷。

屎上最容易HARD难度的题。

不知道为什么一刷二刷用的是map而不是set.

Time: O(n) + O(n)

public class Solution {
    public int longestConsecutive(int[] nums) {
        if (nums.length <= 1) return nums.length;
        
        Set<Integer> set = new HashSet<>();
        
        for (int i: nums) {
            set.add(i);
        }
        
        int res = 0;
        
        for (int i : nums) {
            int temp = i;
            if (!set.contains(temp)) continue;
            int smaller = i - 1;
            int larger = i + 1;
            
            while (set.contains(smaller)) {
                set.remove(smaller --);
            }
            
            while (set.contains(larger)) {
                set.remove(larger ++);
            }
            
            res = Math.max(res, larger - smaller - 1);
            
        }
        return res;
    }
}