LeetCode最长连续序列：哈希集合的O(n)解法

1. 问题背景与核心挑战

这道LeetCode题目看似简单，实则暗藏玄机。作为一名刷过300+题的算法工程师，我第一次看到这个题目时也陷入了误区。题目要求我们找出未排序数组中数字连续的最长序列长度，并且必须在O(n)时间内完成。这就像在一堆散落的扑克牌中，找出数字连续的顺子，但牌的顺序完全打乱，而且只能用有限次翻看。

问题的难点主要体现在三个方面：

1. 未排序数组意味着不能直接使用双指针等常规技巧
2. O(n)时间复杂度限制排除了排序的可能性（排序至少需要O(nlogn)）
3. 连续序列中的元素在原数组中不要求相邻，增加了识别难度

提示：很多同学第一反应是先排序再处理，这在面试中会被直接淘汰。面试官设置O(n)限制就是为了考察对数据结构特性的理解。

2. 算法设计思路解析

2.1 暴力解法的局限性

最直观的解法是对每个数字，检查其+1、+2...是否存在于数组中，记录最大长度。这种方法时间复杂度为O(n²)，当n=10^5时必然超时。

python复制# 伪代码示意（不可取）
max_len = 0
for num in nums:
    current_num = num
    current_len = 1
    while (current_num + 1) in nums:
        current_num += 1
        current_len += 1
    max_len = max(max_len, current_len)

2.2 哈希集合的妙用

突破点在于利用哈希集合(O(1)查询)快速判断数字是否存在。我们可以：

1. 将所有数字存入哈希集合（去重）
2. 只对可能是序列起点的数字进行处理
3. 通过连续+1查询确定序列长度

关键洞察：一个数字x如果是序列起点，那么x-1必定不在集合中。这样就能避免重复统计。

2.3 算法正确性证明

该算法能保证：

• 每个数字最多被访问两次（一次在遍历集合，一次在扩展序列时）
• 每个连续序列只会被其最小元素触发统计
• 去重后的集合大小为n时，时间复杂度严格为O(n)

3. 完整实现与逐行解析

3.1 Python实现代码

python复制def longestConsecutive(nums):
    num_set = set(nums)
    max_len = 0
    
    for num in num_set:
        # 只处理可能是序列起点的数字
        if num - 1 not in num_set:
            current_num = num
            current_len = 1
            
            # 向后扩展序列
            while current_num + 1 in num_set:
                current_num += 1
                current_len += 1
                
            max_len = max(max_len, current_len)
    
    return max_len

3.2 关键代码解析

1. num_set = set(nums)：去重并实现O(1)查询
2. if num - 1 not in num_set：识别序列起点的核心判断
3. while current_num + 1 in num_set：向后扩展序列直到中断
4. 全程只使用简单变量维护状态，空间复杂度O(n)

3.3 复杂度分析

• 时间复杂度：O(n)
  • 创建集合：O(n)
  • 外层循环：每个元素最多处理一次
  • 内层while：每个元素最多被访问一次
• 空间复杂度：O(n)（存储哈希集合）

4. 示例推演与边界处理

4.1 典型示例推演

以nums = [100,4,200,1,3,2]为例：

1. 建立集合：
2. 处理100：
   • 99不在集合 → 序列起点
   • 向后查询：101不在 → 长度1
3. 处理4：
   • 3在集合 → 跳过
4. 处理200：
   • 199不在 → 序列起点
   • 201不在 → 长度1
5. 处理1：
   • 0不在 → 序列起点
   • 向后查询2、3、4都在 → 长度4
6. 最终结果：4

4.2 边界情况处理

• 空数组：返回0
• 所有元素相同：返回1（去重后集合大小为1）
• 已排序数组：不影响算法正确性
• 超大数字：Python不受整数大小限制，但要注意语言特性

5. 常见误区与优化技巧

5.1 典型错误实现

错误1：未去重导致重复计算

python复制# 错误：直接遍历nums而非num_set
for num in nums:  # 可能重复处理相同数字
    if num - 1 not in nums:  # 线性查询，O(n)时间
        ...

错误2：错误判断序列起点

python复制# 错误：仅判断num是数组最小值
if num == min(nums):  # 获取最小值需要O(n)时间
    ...

5.2 优化技巧

1. 提前终止：当max_len > n/2时可提前结束（最长可能序列）
2. 并行处理：理论上可分段处理，但实现复杂且提升有限
3. 内存优化：对于超大数组，可考虑分批加载（但通常面试不考）

5.3 面试应答技巧

当面试官问及此题时，建议回答流程：

1. 先说明暴力解法及其问题
2. 提出哈希集合优化思路
3. 重点解释"序列起点"的判断依据
4. 分析时间/空间复杂度
5. 讨论可能的变种问题

6. 算法变种与扩展思考

6.1 相似题目推荐

1. LeetCode 674. 最长连续递增序列（要求元素在原数组中连续）
2. LeetCode 298. 二叉树最长连续序列
3. LeetCode 549. 二叉树中最长的连续序列II

6.2 实际应用场景

这种算法思想可用于：

• 基因组序列分析
• 时间事件连续性检测
• 游戏中的连续成就系统

6.3 进阶思考题

如果要求返回最长序列本身而不仅是长度，该如何修改算法？

解决方案：在扩展序列时记录序列元素，当发现更长序列时更新结果。需要额外O(k)空间存储当前序列（k为最长序列长度）。

python复制def longestConsecutiveSequence(nums):
    num_set = set(nums)
    max_seq = []
    
    for num in num_set:
        if num - 1 not in num_set:
            current_num = num
            current_seq = [current_num]
            
            while current_num + 1 in num_set:
                current_num += 1
                current_seq.append(current_num)
                
            if len(current_seq) > len(max_seq):
                max_seq = current_seq
    
    return max_seq

7. 不同语言实现要点

7.1 Java实现注意事项

java复制class Solution {
    public int longestConsecutive(int[] nums) {
        Set<Integer> numSet = new HashSet<>();
        for (int num : nums) {
            numSet.add(num);
        }
        
        int maxLen = 0;
        
        for (int num : numSet) {
            if (!numSet.contains(num - 1)) {
                int currentNum = num;
                int currentLen = 1;
                
                while (numSet.contains(currentNum + 1)) {
                    currentNum += 1;
                    currentLen += 1;
                }
                
                maxLen = Math.max(maxLen, currentLen);
            }
        }
        
        return maxLen;
    }
}

注意点：

• 使用HashSet而非TreeSet（保证O(1)查询）
• 注意自动装箱/拆箱的性能影响

7.2 C++实现优化

cpp复制class Solution {
public:
    int longestConsecutive(vector<int>& nums) {
        unordered_set<int> numSet(nums.begin(), nums.end());
        int max_len = 0;
        
        for (int num : numSet) {
            if (numSet.find(num - 1) == numSet.end()) {
                int current_num = num;
                int current_len = 1;
                
                while (numSet.find(current_num + 1) != numSet.end()) {
                    ++current_num;
                    ++current_len;
                }
                
                max_len = max(max_len, current_len);
            }
        }
        
        return max_len;
    }
};

优化点：

• 使用unordered_set而非set（哈希实现vs红黑树）
• 直接初始化集合，避免单独循环

8. 算法理论深度探讨

8.1 并查集解法对比

这个问题也可以用并查集(Disjoint Set Union)解决：

1. 将每个数字视为独立集合
2. 对每个数字，将其与num+1和num-1合并
3. 最后统计最大集合大小

时间复杂度：O(nα(n))，其中α是反阿克曼函数，接近常数但理论复杂度略高于哈希解法。

8.2 信息论视角

从信息论角度看，该算法巧妙地利用了数字连续性的局部特性：

• 只需要在边界点（序列起点）触发计算
• 利用哈希表快速验证连续性
• 避免了全局排序带来的信息冗余处理

8.3 算法选择策略

在实际工程中选择算法时需要考虑：

1. 数据特征：是否有大量重复？数值范围如何？
2. 语言特性：不同语言的哈希表实现效率差异
3. 后续扩展：是否需要支持动态插入和查询？

9. 实战中的性能调优

9.1 内存占用优化

对于特别大的数组（1e7以上级别）：

• 如果数值范围有限，可以用位图代替哈希集合
• 考虑分块处理，牺牲部分时间复杂度换取内存空间

9.2 并行化可能性

理论上可以将数组分片，分别处理后再合并结果：

• 每片独立计算局部最长序列
• 需要额外处理跨分片的序列
• 实际加速比受数据分布影响大

9.3 实际测试数据

在LeetCode测试平台上：

• Python实现约80ms
• Java实现约10ms
• C++实现约8ms
  差异主要来自语言运行时开销

10. 从这道题学到的设计模式

这道题的解法体现了几个重要的算法设计思想：

1. 空间换时间：使用哈希集合存储额外信息来加速查询
2. 惰性计算：只在必要时（遇到序列起点）才进行计算
3. 边界触发：通过识别边界条件（x-1不存在）避免重复工作
4. 预处理优化：通过初始去重简化后续处理逻辑

这些思想在解决其他算法问题时也非常有用，比如图论中的邻接表存储、动态规划中的记忆化技术等。理解这道题的解法后，可以尝试解决LeetCode 41.缺失的第一个正数，会发现有异曲同工之妙