哈希集合与空间换时间：力扣128最长连续序列O(n)解法精讲

力扣128题最长连续序列，我在热题100和面试高频题单里见过它无数次，几乎每次刷题攻略聊到“用空间换时间”的经典案例时，它都会被拎出来当教材。题目本身不长，核心就一句话：给你一个未排序的整数数组，找出数字连续的最长序列的长度，并且要求算法的时间复杂度为 O(n)。很多人第一反应是先排序再扫描，可是排序最少也是 O(n log n)，这一下就和题目要求撞上了。更麻烦的是，这题的“连续”指的是值域上的逐步加一，数组里元素顺序完全无所谓，跟很多新手理解的“连续子数组”是两个概念。今天我就把这题从题目拆解、哈希集合解法、其他方案对比，再到实际刷题时容易踩的坑，完整地捋一遍。

这篇文章适合刚刷 LeetCode 的新手，也适合准备面试想快速回顾套路的人。读完你能掌握的不只是这一道题的代码，而是“如何通过空间换时间把重复枚举省掉”这一类题的通用思考方式。我会用 Java 写主解法，所有结论在 C++、Python 里同样成立。

1. 先读懂题目：为什么这题不能无脑排序

1.1 “连续序列”到底是什么意思

先看一个例子。数组是 [100, 4, 200, 1, 3, 2]，这里面的数字连续序列有 [1, 2, 3, 4] 和 [100]、[200]，最长的是第一个，长度是 4。注意，[1, 3, 2, 4] 在数组中并不是连续出现的，我们找的是值域上连续的数，不需要它们在原数组里相邻。这一点不少人第一次做时会绕进去，以为像“最长连续子数组”那样要在原顺序里找，结果整个思路就走偏了。

还有一层容易被忽略的细节：重复元素。数组 [0, 0, 1, 2, 3] 的最长连续序列依然是 [0, 1, 2, 3]，长度是 4。重复的 0 不会让长度增加，所以做这题的第一步自觉去重非常关键，这也是后面为什么哈希集合这么契合题意的原因。

还有一个边界需要对齐：空数组返回 0，数组中只有一个元素时返回 1。负数也要能处理，比如 [-3, -2, -1, 0] 的结果是 4，不能因为数组里有负数就出问题。LeetCode 的测试用例里这些边界都覆盖得很全，初次提交翻车往往不是主干逻辑错了，而是这些细节没兜住。

1.2 O(n) 的硬性要求排除了哪些方案

题目要求时间复杂度 O(n)，这个条件直接把“排序”这条路堵死了。有人会杠：Java 的 Arrays.sort() 底层是双轴快排，平均也是 O(n log n)，严格说不满足；Python 的 list.sort() 是 TimSort，同样不满足。任何基于比较的排序都无法做到线性时间，这是信息论层面的限制，不是优化一下就能突破的。

那有没有办法绕开排序？常见的思路是“把数组中的值放到一个能 O(1) 判断是否存在的数据结构里”。数组值范围可能很大，题目给定的数值范围通常在 -10^9 到 10^9 之间，直接开布尔数组标记肯定不行，内存直接爆炸。所以工程上最自然的选择是哈希表——Java 里是 HashSet，C++ 里是 unordered_set，Python 里是 set。

用哈希表后，“连续”关系就可以通过查 num + 1 是否存在来判断。这其实是把原来“排序后相邻比较”的逻辑，转换成“值域上探查后继是否存在”的逻辑，为一颗洋葱剥到了核心：我们真正需要的是快速判断某个数在不在集合里，而不是把所有数排好序。

2. 哈希集合解法：只从连续序列的起点开始枚举

2.1 核心优化：为什么一定要判断 num - 1 是否存在

哈希集合版本中最直观的暴力做法，是把数组中每个数都当作起点，不断查 num + 1，然后在所有结果里取最大值。比如数组是 [1, 2, 3, 4]，从 1 能数到 4 得到长度 4；从 2 又能数到 4 得到长度 3。整体算下来时间会退化到 O(n²)，因为同一个连续段被重复数了 n 次。

解法里最关键的一步，就是用 contains(num - 1) 来过滤掉那些不是起点的数。只有当 num - 1 不在集合里，说明当前数是一个连续段的最小值，此时才往上枚举。还拿 [1, 2, 3, 4] 举例，2、3、4 的前驱都在集合里，它们会被直接跳过，只有 1 会进入 while 循环。这样一来，每个数字最多被“向上探查”一次，整体时间就稳定在 O(n) 了。

很多讲解把这一步说成“只从连续序列的起点开始数”，这句话其实已经把全部精华浓缩了。面试时如果你能主动说出“为了防止重复枚举，我只从没有前驱的元素开始向后累加”，面试官基本就会满意地点头。不要小看这个判断，它是整个算法从 O(n²) 变成 O(n) 的分水岭。

2.2 Java 参考实现与代码注释

java复制class Solution {
    public int longestConsecutive(int[] nums) {
        // 用 HashSet 去重，同时保证 O(1) 的 contains 查询
        Set<Integer> set = new HashSet<>();
        for (int num : nums) {
            set.add(num);
        }

        int best = 0;

        // 遍历 set 而不是原数组
        // 原数组有重复值，遍历 set 天然去重，避免同一个数被重复处理
        for (int num : set) {
            // 如果 num - 1 存在，说明 num 不是连续段的起点，跳过
            // 这一步保证每个连续段只会从最小值开始枚举一次
            if (!set.contains(num - 1)) {
                int currentNum = num;
                int currentLen = 1;

                // 不断向后寻找后继数字
                while (set.contains(currentNum + 1)) {
                    currentNum++;
                    currentLen++;
                }

                best = Math.max(best, currentLen);
            }
        }

        return best;
    }
}

代码本身非常短，但有几个实现细节值得单独拿出来聊。

第一，遍历的是 set 而不是 nums。如果遍历原数组，重复值会导致同一个数被当作起点或中间节点重复进入逻辑，虽然加上前驱判断后很多情况能兜住，但遍历 set 是最干净的做法，也让“每个数只处理一次”这句话在实现层面真正成立。

第二，可以把 HashSet 的初始容量预设为 nums.length，或者使用 new HashSet<>(nums.length * 2) 来减少扩容次数。在 LeetCode 这种数据规模不算极端的场景下影响不大，但如果拿到面试官面前去写，这个细节能体现你对 Java 集合底层机制的了解。HashSet 底层是 HashMap，扩容阈值和负载因子都跟 HashMap 一致，频繁扩容确实有额外开销。

第三，contains 方法的时间复杂度理论上平均是 O(1)，但在哈希冲突严重时会退化。工程上 JVM 的 HashMap 在链表过长时会转成红黑树，所以即使在极端输入下，Java 的实现也不至于完全退化到 O(n) 的查询。不过面试里说“O(1)”就够了，默认是平均情况。

2.3 摊还分析：为什么总循环次数是 O(n)

这个解法的复杂度分析是面试必问题。外层 for 循环看起来是 O(n)，里面还有一个 while 循环，很多人到这里就说不清了：外层 O(n)、内层最坏 O(n)，怎么不是 O(n²)？

关键点在于：while 循环不是对每个元素都会完整执行。只有当 num - 1 不在集合中时，也就是当前元素是连续段起点时，才会进入 while。进入之后，它会沿着连续段一路走到头。一个连续段中，只有起点会触发这次完整遍历，段里其他元素全被 contains(num - 1) 这个条件拦截在外层 for 里，直接 continue。

所以可以把每个数字的被访问次数分成两部分：作为外层 for 的当前数被看一次，作为某个连续段的后继被 while 探查一次。每个数字最多被“看”两次，总操作次数是 O(n)。这就是典型的摊还分析——单独看某次 while 可能跑很长，但把整个流程摊到 n 个元素上，平均成本是常数。

理解了这个分析，你甚至可以手推一些例子去验证：数组是 [0, 1, 2, ..., 9999] 时，外层 10000 次，但 while 整体也只跑了 9999 次，和单独从 0 开始跑一次连续段完全一致。别的数全被前驱判断拦住了。这个例子能帮你把抽象复杂度落回具体执行过程，面试时能当场说清楚会很加分。

3. 其他可行方案：排序法和并查集思路

3.1 排序后线性扫描：简单但不见得省事

哈希集合解法是想出最优解后不得不写，排序法更像是“如果允许 O(n log n) 时间，我最自然的想法”。它的实现确实更直观：先排序，再遍历，遇到连续的就增加当前长度，遇到相同元素就跳过，遇到断开的就结算一次。

java复制public int longestConsecutive(int[] nums) {
    if (nums.length == 0) {
        return 0;
    }

    Arrays.sort(nums);

    int best = 1;
    int currentLen = 1;

    for (int i = 1; i < nums.length; i++) {
        if (nums[i] == nums[i - 1]) {
            // 跳过重复元素，长度不能因为重复而增加
            continue;
        }
        if (nums[i] == nums[i - 1] + 1) {
            currentLen++;
        } else {
            best = Math.max(best, currentLen);
            currentLen = 1;
        }
    }

    return Math.max(best, currentLen);
}

这里有一个很容易漏写的点：for 循环结束后，最后一个连续段可能还没结算，所以 return 前要再 Math.max(best, currentLen) 一次。很多人第一次写排序法时会在这一步翻车，数组 [1, 2, 3, 4] 的情况下如果直接返回 best，结果会是 1 而不是 4，因为整个数组只构成一个连续段，循环里没触发 else 分支。

排序法的空间复杂度要看你讨论的排序实现。Arrays.sort(int[]) 用的是双轴快排，额外空间是 O(log n)；如果对 Integer[] 排序，TimSort 会需要 O(n) 的临时空间。所以这个问题在面试里直接说 O(n log n) 时间、O(1) 或 O(n) 空间都可以，关键是要知道排序本身带来的时间开销已经不符合题目原意。

它适合什么场景呢？如果你不是在刷题，而是在实际业务里处理一批内存数据，数据量不大，排序法往往更不容易出错，代码也更好维护。LeetCode 这题要求 O(n) 只是为了锻炼算法思维，真实业务里没人会拦着你排序。所以不要觉得排序法是“错误答案”，它只是在这道题的约束下不是最优解。

3.2 并查集：一个可扩展的备选思路

如果说哈希解法是从“连续段的起点”切入，并查集则是从“关系的合并”切入。思路是把相邻的数字在并查集里做 union，然后找最大的连通分量大小。具体做法是用一个 Map<Integer, Integer> 保存每个数字的父节点，遍历数组时如果 num - 1 或 num + 1 已经出现过，就把它们合并到同一个集合里，最后统计每个 set 的 size 取最大。

Java 里并查集实现通常长这样思路：

java复制class DSU {
    Map<Integer, Integer> parent;
    Map<Integer, Integer> size;

    public DSU(int[] nums) {
        parent = new HashMap<>();
        size = new HashMap<>();
        for (int num : nums) {
            parent.put(num, num);
            size.put(num, 1);
        }
    }

    public int find(int x) {
        if (parent.get(x) != x) {
            parent.put(x, find(parent.get(x))); // 路径压缩
        }
        return parent.get(x);
    }

    public void union(int x, int y) {
        int rootX = find(x);
        int rootY = find(y);
        if (rootX == rootY) return;
        if (size.get(rootX) < size.get(rootY)) {
            int tmp = rootX;
            rootX = rootY;
            rootY = tmp;
        }
        parent.put(rootY, rootX);
        size.put(rootX, size.get(rootX) + size.get(rootY));
    }
}

完整解法还需要在遍历时对所有相邻关系调用 union，最后遍历所有父节点找最大 size。时间上，理论上并查集做到接近 O(nα(n))，α(n) 是反阿克曼函数，基本可看成常数。但要维护两个 Map，编码量比哈希集合解法大不少，所以实战中我基本不推荐用它来解这道题。

那为什么还要提它？因为并查集是“连通分量类”问题的核心工具，力扣上很多题目，比如岛屿数量、冗余连接、账户合并，背后都是这个套路。如果你正处于系统性刷题阶段，把并查集当成这题的扩展点学习，性价比很高；如果只是为了快速过题，跳过完全没问题。

3.3 三种方案横评：什么时候选哪个

对比下来，哈希集合方案既简洁又在复杂度上完全胜出。这个结论不是巧合，而是题目设计本身就指向哈希结构：需要去重、需要 O(1) 存在性查询、需要遍历所有元素。你以后见到“值域连续性”“区间合并”这类关键词时，都可以条件反射地先问自己一句：能不能用哈希表把值存起来再逐个查。

4. 实际刷题中遇到的坑与排查技巧

4.1 Integer 缓存和自动装箱

Java 里用 Map<Integer, Integer> 存储并查集或者做出现次数统计时，自动装箱会造成一个隐蔽的性能问题：小于等于 127 的 Integer 走缓存，大于等于 128 就 new 新对象。这会让 == 比较在数值较小时碰巧成立、较大时莫名失败。在哈希集合解法里，我用的是 Set<Integer> 和 equals/contains，不存在这个问题；但如果有人想用 Map 做类似逻辑，写 parent.get(x) == x 这种代码，数值超过 127 就会踩坑。

建议是：涉及 Integer 比较一律用 equals 或者 intValue() 拆箱后比较，不要依赖 ==。这个坑在这个题目里可能不会立刻爆出来，但把它记在脑子里，后续刷到并查集相关题目时会帮你省很多 debug 时间。

4.2 重复元素导致的“假连续”

我第一次用哈希集合解法提交时，一个没注意的 bug 就是在遍历原数组而不是 set。数组 [1, 2, 2, 3] 如果遍历原数组，1 和 2 会各触发一次处理，虽然前驱判断能在一定程度上拦住，但如果你写法里带着布尔标记数组或其他状态，就很容易把一个元素处理两遍，结果被重复数据干扰。

解决方式是构造集合后直接遍历 set。哈希集合天然去重，一个连续段用一个起点触发一次，既简单又不容易出问题。另外，如果面试时你写的是 Python，直接 for num in set(nums) 也同样安全。

4.3 空数组和单元素数组

边界条件很多人都会写，但最容易忽略的是单元素数组的处理。nums = [5] 时，正确答案是 1，不是 0。哈希集合解法中外层循环会把 5 加入 set，由于 5 - 1 不在集合里，进入 while，6 不在集合里，循环结束，best 更新为 1，结果正确。排序法里这种场景反而容易出问题：如果排序后只有一个元素，for 循环根本不执行，如果你 return 的是 currentLen 初始值而不是手动设为 1，结果就错了。代码里我特意把 currentLen 初始值设为 1，同时对空数组单独返回 0，就是为了兜住这个场景。

这类边界靠背是背不完的，更好的习惯是提交前自己列出几类用例：空数组、单个元素、全相同元素、负数、全正数、已经被排序过的数组、逆序数组。不用全跑，挑几个在脑子里走一遍流程就够了。

4.4 手写测试用例速查

为了方便大家自测，我把这题有价值的用例整理成一个表格。每次写完代码后在本地跑一遍这些用例，基本可以覆盖所有容易翻车的地方。

4.5 面试时怎么把这道题讲出层次感

面试遇到这题，很多人一上来就甩代码，这是比较吃亏的。建议按下面这个顺序讲：先确认题意，主动说出“连续是指值连续，不需要在原数组里位置相邻，重复元素不增加长度”；再说明为什么不能用排序，指出 O(n) 约束；然后描述哈希集合的总体思路，尤其强调“只从没有前驱的数开始向上枚举”这一步的优化动机；最后写代码，写完跑一个例子验证。

如果面试官追问复杂度，就把我前面摊还分析的内容说清楚。如果面试官问“还能怎么优化”，可以接“空间上已经没有太多下降空间，因为需要 O(n) 的记录结构；但可以反过来想如果数组本身有序，这个问题就退化成一遍扫描”这类延展。整体节奏控制在 5 到 8 分钟比较合适。

5. 从这题延伸到热题 100 的同族套路

刷题如果只是单题记忆，效率会很低。这题其实可以串联起好几道热题 100 里的题目，形成一个“用哈希结构处理连续/存在性关系”的小专题。

先说最长公共前缀这一题，它的解法本质也是“从第一个字符串出发，逐个位置比对公共前缀”，和哈希关系不大，但它同样是在处理“连续性”——只是这里的连续变成了字符串数组下标方向上的逐位相等。如果把这道字符串题和力扣 128 放在一起看，你会发现它们都在讲“如何避免重复比较”：128 是通过跳过非起点来避免重复枚举连续段，公共前缀是通过一次遍历比较多个字符串的同一列来避免每对字符串单独比较。

再看最长递增子序列，不一样的是它要求严格递增且允许跳着选，这类问题一般用动态规划或贪心加二分，和哈希的关系变弱，但“把数组元素转成状态集合”这个思维是一致的。当你在哈希集合解法中体会到“用 set 把原数组映射成可查询的值域”后，再遇到需要快速判断某值是否存在的题目，会自然想到这套工具。

还有一道典型的连续区间题目是“缺失的第一个正数”，题解也会用到原地哈希，把数组本身当作哈希表来标记哪些正数出现过。它和 128 的区别在于空间限制更严格：128 允许 O(n) 额外空间，缺失正数要求在常数额外空间内完成，所以不能 new 一个 set，只能通过交换元素把值放到对应下标位置。这两题搭配刷，你对“空间换时间”这个主题的理解会很通透。

如果你是按 LeetCode 热题 100 的顺序刷题，遇到 128 题时我建议把上面这几题放在同一个刷题周期里集中练习，不要今天做一题明天跳到完全不相关的另一题。同类题集中轰炸的效率，比线性地一题一题往后刷要高得多。我自己刷题早期对这个套路没意识，结果每道题都是单独的孤岛，后来强行做了专题归类，再遇到新题明显能更快想出思路。

我的几点实操体会

最后再分享几个我在实际刷题和面试交流中积累的体会。第一，这道题看题解五分钟能看懂，但不代表你会写。建议合上题解，自己在编辑器里从空文件开始敲一遍，卡住的地方就是你真正薄弱的地方。第二，别只满足于 AC，把“为什么遍历 set 而不是 nums”、“为什么 while 整体是 O(n)”这两个问题用大白话解释清楚，比代码跑通更重要，因为面试官问的就是这些“为什么”。第三，如果你用 C++ 刷这题，记得 unordered_set 的迭代顺序是未定义的，但因为我们只关心存在性，不影响正确性；如果你用 Python，注意 set 的遍历顺序虽然稳定但不能依赖。这题套路就这么多，核心是哈希集合加起点判断，剩下的是熟练度和边界感的问题，多写几次自然就内化了。