LeetCode数组热题解析：两数之和、盛水容器与三数之和

1. LeetCode 热题100的数组类题目精要解析

数组作为数据结构中最基础的类型，在算法面试中出现的频率居高不下。根据2023年LeetCode官方统计，数组类题目在技术面试中的出现概率达到47%，远高于其他数据结构。而热题100中的数组题目更是浓缩了最经典的解题模式和最高频的考察点。

本系列将聚焦三个最具代表性的数组题目：两数之和（第1题）、盛最多水的容器（第11题）和三数之和（第15题）。这三个题目分别代表了哈希表应用、双指针技巧和排序+双指针的经典组合解法。掌握它们不仅能应对多数数组问题，更能培养解决复杂问题的思维模式。

提示：虽然这些题目在力扣上被标记为"简单"或"中等"，但实际面试中往往会在这些基础题目上进行变形和组合。建议在理解基础解法后，主动思考可能的变种问题。

2. 两数之和：哈希表的启蒙课

2.1 问题描述与暴力解法

题目要求：给定一个整数数组nums和一个整数目标值target，请你在该数组中找出和为目标值的那两个整数，并返回它们的数组下标。

最直观的解法是双重循环暴力枚举：

python复制def twoSum(nums, target):
    for i in range(len(nums)):
        for j in range(i+1, len(nums)):
            if nums[i] + nums[j] == target:
                return [i, j]
    return []

这种方法时间复杂度为O(n²)，空间复杂度O(1)。对于小规模数据尚可接受，但当数组长度达到10⁵级别时（如现代大数据处理场景），这种解法就完全不可行了。

2.2 哈希表优化解法

通过使用哈希表（字典）存储已遍历元素的值和索引，我们可以将时间复杂度降至O(n)：

python复制def twoSum(nums, target):
    hashmap = {}
    for i, num in enumerate(nums):
        complement = target - num
        if complement in hashmap:
            return [hashmap[complement], i]
        hashmap[num] = i
    return []

这个解法的精妙之处在于：

1. 只需要一次遍历，边遍历边构建哈希表
2. 每次先检查当前元素的补数是否已在表中
3. 如果没有才将当前元素加入表，避免重复使用同一元素

注意：当数组中有重复元素时，后出现的索引会覆盖先前的。但因为我们是先检查补数再插入，所以不会影响结果正确性。

2.3 进阶思考：多种变体

实际面试中，面试官可能会提出以下变种问题：

• 如果要求返回所有可能的解而不仅是一个？
• 如果数组已排序，如何优化空间复杂度？
• 如果要求解三个数之和（即原始的三数之和问题）？

这些问题都可以在两数之和的基础上进行扩展。例如对于已排序数组，我们可以使用双指针法，将空间复杂度降至O(1)：

python复制def twoSumSorted(nums, target):
    left, right = 0, len(nums)-1
    while left < right:
        current_sum = nums[left] + nums[right]
        if current_sum == target:
            return [left, right]
        elif current_sum < target:
            left += 1
        else:
            right -= 1
    return []

3. 盛最多水的容器：双指针的经典应用

3.1 问题理解与暴力解法

题目描述：给定一个长度为n的整数数组height，有n条垂直线，第i条线的两个端点是(i, 0)和(i, height[i])。找出其中的两条线，使得它们与x轴共同构成的容器可以容纳最多的水。

暴力解法同样是双重循环计算所有可能的容器面积：

python复制def maxArea(height):
    max_area = 0
    for i in range(len(height)):
        for j in range(i+1, len(height)):
            current_area = min(height[i], height[j]) * (j - i)
            max_area = max(max_area, current_area)
    return max_area

这种O(n²)的解法在n较大时效率极低，我们需要更聪明的办法。

3.2 双指针优化解法

关键观察：容器的盛水量由两个因素决定 - 较短的边和两边的距离。初始时，我们取最左和最右的两边，这样宽度最大。然后逐步向内移动较短的边，因为移动较长的边不可能增加盛水量（盛水量受限于较短的边）。

python复制def maxArea(height):
    left, right = 0, len(height)-1
    max_area = 0
    while left < right:
        current_area = min(height[left], height[right]) * (right - left)
        max_area = max(max_area, current_area)
        if height[left] < height[right]:
            left += 1
        else:
            right -= 1
    return max_area

这个解法的时间复杂度为O(n)，空间复杂度O(1)。它展示了如何通过观察问题特性来设计高效算法。

3.3 算法正确性证明

为什么这种方法不会错过最大解？关键在于我们总是移动较短的边：

1. 当前面积 = min(h[l], h[r]) * (r - l)
2. 如果移动较长的边，新面积 ≤ 当前面积（因为宽度减小，而高度仍受限于未移动的较短边）
3. 只有移动较短的边，才有可能遇到更高的边，从而可能获得更大的面积

这种证明方法在面试中非常重要，能展示你对算法本质的理解。

4. 三数之和：排序与双指针的完美结合

4.1 问题描述与难点分析

题目要求：给定一个包含n个整数的数组nums，判断nums中是否存在三个元素a，b，c，使得a + b + c = 0？找出所有不重复的三元组。

这个问题的难点在于：

1. 需要找到所有满足条件的三元组
2. 解集中不能有重复的三元组
3. 最优解法需要低于O(n³)的时间复杂度

4.2 排序+双指针解法

先将数组排序，然后固定一个数，将问题转化为两数之和：

python复制def threeSum(nums):
    nums.sort()
    result = []
    for i in range(len(nums)-2):
        if i > 0 and nums[i] == nums[i-1]:
            continue  # 跳过重复元素
        left, right = i+1, len(nums)-1
        while left < right:
            total = nums[i] + nums[left] + nums[right]
            if total < 0:
                left += 1
            elif total > 0:
                right -= 1
            else:
                result.append([nums[i], nums[left], nums[right]])
                # 跳过重复元素
                while left < right and nums[left] == nums[left+1]:
                    left += 1
                while left < right and nums[right] == nums[right-1]:
                    right -= 1
                left += 1
                right -= 1
    return result

这个解法的时间复杂度为O(n²)（排序O(nlogn) + 双重循环O(n²)），空间复杂度取决于排序实现，通常为O(logn)或O(n)。

4.3 关键细节与优化

1. 去重处理：

   • 外层循环跳过相同的nums[i]
   • 内层找到解后，跳过相同的nums[left]和nums[right]

2. 提前终止：

   python复制if nums[i] > 0:
       break  # 因为数组已排序，后续元素都大于0
   if nums[i] + nums[i+1] + nums[i+2] > 0:
       break  # 最小的三个数之和已大于0
   if nums[i] + nums[-2] + nums[-1] < 0:
       continue  # 当前nums[i]与最大的两个数之和仍小于0
   

3. 边界条件处理：

   • 数组长度不足3时直接返回空
   • 处理全0的特殊情况

5. 数组问题的通用解题框架

通过这三个经典题目，我们可以总结出解决数组类问题的通用思路：

1. 排序预处理：很多数组问题在排序后会变得更容易解决（如三数之和、合并区间等）

2. 双指针技巧：

   • 对撞指针（如盛水容器、两数之和已排序版本）
   • 快慢指针（如移除重复元素）
   • 滑动窗口（如最小子数组和）

3. 哈希表辅助：快速查找元素是否存在（如两数之和）

4. 分治思想：将大问题分解为小问题（如归并排序、快速选择）

5. 前缀和与差分：处理子数组和问题（如和为K的子数组）

在实际面试中，通常需要组合使用这些技巧。例如三数之和就结合了排序和双指针，而有些更复杂的问题可能需要同时使用哈希表和双指针。

6. 实战中的常见陷阱与优化技巧

6.1 边界条件处理

数组问题最容易出错的就是边界条件：

• 空数组或单元素数组
• 全相同元素的数组
• 极大/极小的数值（整数溢出）
• 恰好满足条件的边界值

建议在写出主体解法后，专门设计这些边界用例进行测试。

6.2 空间复杂度的权衡

有时可以通过牺牲空间复杂度来换取时间复杂度的大幅降低：

• 两数之和：O(n)空间换O(n)时间
• 前缀和数组：O(n)空间换O(1)的区间和查询

但在内存受限的场景（如嵌入式系统），可能需要选择空间最优的解法。

6.3 代码可读性与性能的平衡

面试中除了正确性，代码的可读性和可维护性也很重要：

• 使用有意义的变量名（如left/right比i/j更清晰）
• 适当添加注释解释关键步骤
• 将复杂逻辑拆分为辅助函数

但在性能关键的场景（如高频交易系统），可能需要优先考虑性能最优的写法。

7. 从这三个题目延伸的练习建议

为了真正掌握这些技巧，建议按以下顺序进行扩展练习：

1. 两数之和系列：

   • 167. 两数之和 II - 输入有序数组
   • 170. 两数之和 III - 数据结构设计
   • 1099. 小于 K 的两数之和

2. 盛水容器类问题：

   • 42. 接雨水（更难的双指针应用）
   • 407. 接雨水 II（三维情况）

3. 三数之和系列：

   • 16. 最接近的三数之和
   • 259. 较小的三数之和
   • 18. 四数之和（扩展到更多数）

4. 综合应用：

   • 15. 三数之和
   • 18. 四数之和
   • 454. 四数相加 II（结合哈希表）

在解决这些问题时，刻意练习以下能力：

• 先尝试自己思考解法，而不是直接看答案
• 写出解法后，主动思考时间/空间复杂度
• 尝试找出更优的解法或不同的解法
• 模拟面试场景，向"面试官"解释你的思路

8. 面试中的实战建议

1. 理解问题阶段：

   • 仔细阅读题目，确认理解正确
   • 主动提出测试用例验证理解
   • 询问数据范围和特殊要求

2. 设计算法阶段：

   • 先提出暴力解法，再思考优化
   • 解释算法思路和复杂度分析
   • 讨论可能的边界条件和异常处理

3. 编码实现阶段：

   • 写出清晰、模块化的代码
   • 添加必要的注释
   • 保持代码风格一致

4. 测试验证阶段：

   • 设计常规用例和边界用例
   • 逐步调试发现问题
   • 解释如何修复发现的问题

5. 后续问题阶段：

   • 准备回答关于算法扩展的问题
   • 思考并行化或分布式处理的可能
   • 讨论实际应用场景

以三数之和为例，面试官可能会追问：

• 如果数组太大无法一次性装入内存怎么办？
• 如何修改算法来找到乘积最大的三元组？
• 如何使算法在多核机器上并行运行？

这些问题考察的是将基础知识应用到新场景的能力。