連結

給定一個未排序的整數陣列 nums ，找出數字連續的最長序列（不要求序列元素在原陣列中連續）的長度。

請你設計並實現時間複雜度為O(n) 的演算法解決此問題。

import java.util.HashMap;
import java.util.Map;

class Solution {

    private static int solve1(int[] nums) {

        Map<Integer, Integer> headMap = new HashMap<>();
        Map<Integer, Integer> tailMap = new HashMap<>();

        int ret = 1;

        for (int i = 0; i < nums.length; ++i) {

            /**
             * 防止影響端點
             * 端點以外或端點以內隨便折騰
             */
            if (headMap.containsKey(nums[i]) || tailMap.containsKey(nums[i])) {
                continue;
            }

            headMap.put(nums[i], 1);
            tailMap.put(nums[i], 1);

            /**
             * 可合併前面的數
             */
            if (tailMap.containsKey(nums[i] - 1)) {
                // 2 3 4 -- 5
                int left = nums[i] - tailMap.get(nums[i] - 1);
                int right = nums[i] + headMap.get(nums[i]) - 1;
                tailMap.remove(nums[i] - 1);
                headMap.remove(nums[i]);

                int num = right - left + 1;
                headMap.put(left, num);
                tailMap.put(right, num);
                ret = Math.max(ret, num);
            }

            /**
             * 可合併後面的數
             */
            if (headMap.containsKey(nums[i] + 1)) {
                // 1 -- 2 3 4
                int left = nums[i] - tailMap.get(nums[i]) + 1;
                int right = nums[i] + headMap.get(nums[i] + 1);
                tailMap.remove(nums[i]);
                headMap.remove(nums[i] + 1);

                int num = right - left + 1;
                headMap.put(left, num);
                tailMap.put(right, num);
                ret = Math.max(ret, num);
            }
        }
        return ret;
    }

    private static int merge(Map<Integer, Integer> lengthMap, int a, int b) {
        // 1 2 3 4--5 6 7 8
        int left = a - lengthMap.get(a) + 1;
        int right = b + lengthMap.get(b) - 1;
        int length = right - left + 1;
        lengthMap.put(left, length);
        lengthMap.put(right, length);
        return length;
    }

    private static int solve2(int[] nums) {
        Map<Integer, Integer> lengthMap = new HashMap<>();

        int ret = 1;

        for (int i = 0; i < nums.length; ++i) {
            /**
             * 不重複處理
             */
            if (lengthMap.containsKey(nums[i])) {
                continue;
            }
            lengthMap.put(nums[i], 1);
            if (lengthMap.containsKey(nums[i] - 1)) {
                ret = Math.max(ret, merge(lengthMap, nums[i] - 1, nums[i]));
            }

            if (lengthMap.containsKey(nums[i] + 1)) {
                ret = Math.max(ret, merge(lengthMap, nums[i], nums[i] + 1));
            }
        }
        return ret;
    }

    public static int longestConsecutive(int[] nums) {

        if (nums == null || nums.length == 0) {
            return 0;
        }

        return solve2(nums);
    }
}