# 三数之和 (3Sum) LeetCode 15. Medium ## 题目描述 给你一个整数数组 `nums`，判断是否存在三元组 `[nums[i], nums[j], nums[k]]` 满足 `i != j`、`i != k` 且 `j != k`，同时还满足 `nums[i] + nums[j] + nums[k] == 0`。 请你返回所有和为 0 且不重复的三元组。 **注意**：答案中不可以包含重复的三元组。 **示例 1**： ``` 输入：nums = [-1,0,1,2,-1,-4] 输出：[[-1,-1,2],[-1,0,1]] 解释： nums[0] + nums[1] + nums[2] = (-1) + 0 + 1 = 0 nums[1] + nums[2] + nums[4] = 0 + 1 + (-1) = 0 nums[0] + nums[3] + nums[4] = (-1) + 2 + (-1) = 0 不同的三元组是 [-1,0,1] 和 [-1,-1,2] 注意，输出的顺序和三元组的顺序并不重要。 ``` **示例 2**： ``` 输入：nums = [0,1,1] 输出：[] 解释：唯一可能的三元组和不为 0 ``` **示例 3**： ``` 输入：nums = [0,0,0] 输出：[[0,0,0]] 解释：唯一可能的三元组和为 0 ``` ## 思路推导 ### 暴力解法分析 **最直观的思路**：三层循环枚举所有可能的三元组。 ```python def threeSum(nums): result = set() n = len(nums) for i in range(n): for j in range(i+1, n): for k in range(j+1, n): if nums[i] + nums[j] + nums[k] == 0: # 排序后加入集合，避免重复 triplet = sorted([nums[i], nums[j], nums[k]]) result.add(tuple(triplet)) return [list(t) for t in result] ``` **时间复杂度**：O(n³) - 外层循环：O(n) - 中层循环：O(n) - 内层循环：O(n) - 总计：O(n³) **空间复杂度**：O(1)，不考虑结果存储 **问题分析**： 1. 效率太低：n=2000 时，n³ = 8×10⁹ 次运算，会超时 2. 去重困难：需要额外的集合操作 3. 无法利用已知信息优化 ### 优化思考 - 第一步：降维 **观察**：固定第一个数后，问题变成"两数之和" ```python # 固定第一个数 nums[i] # 问题转化为：在 nums[i+1:] 中找两个数，使和为 -nums[i] ``` **为什么这样思考？** - 三数之和 = 固定一个数 + 两数之和 - 两数之和可以用双指针 O(n) 解决 - 总复杂度：O(n) × O(n) = O(n²) **优化后的思路**： ```python for i in range(n): target = -nums[i] # 在 nums[i+1:] 中用双指针找两数之和为 target twoSum(nums, i+1, target) ``` ### 优化思考 - 第二步：双指针的前提条件 **问题**：为什么需要排序？ **关键理解**：双指针依赖数组的**单调性** ``` 假设数组有序：[-4, -1, -1, 0, 1, 2] ↑ ↑ ↑ i left right 如果 nums[left] + nums[right] < target: - 由于数组升序，增大 left → 和会变大 - 减小 right → 和会变小 - 所以应该 left++ 如果 nums[left] + nums[right] > target: - 减小 right → 和会变小 - 所以应该 right-- ``` **不排序的后果**： - 无法确定指针移动方向 - 可能遗漏正确答案 - 无法利用有序性进行剪枝 ### 优化思考 - 第三步：去重策略 **去重的三个关键点**： 1. **外层去重**：跳过重复的第一个数 ```python if i > 0 and nums[i] == nums[i-1]: continue ``` 2. **内层去重**：找到答案后跳过重复元素 ```python while left < right and nums[left] == nums[left+1]: left += 1 while left < right and nums[right] == nums[right-1]: right -= 1 ``` 3. **为什么排序有利于去重**？ - 相同的数会相邻 - 只需比较相邻元素即可去重 - 时间复杂度从 O(n²) 降到 O(n) ## 解题思路 ### 核心思想 **排序 + 双指针**：先排序，固定第一个数，再用双指针找后两个数。 **为什么这样思考？** 1. **排序的作用**： - 去除重复结果（相同数相邻） - 使数组有序，才能使用双指针 - 提前终止（如果当前数>0，后面都>0） 2. **双指针的原理**： - 数组有序后，如果 sum < target，需要增大 → left++ - 如果 sum > target，需要减小 → right-- - 利用单调性，避免暴力枚举 3. **降维思想**： - 三数之和 → 固定一个数 → 两数之和 - O(n³) → O(n²) ### 详细算法流程 **步骤1：预处理 - 排序** ```python nums.sort() # O(n log n) ``` **作用**： - 去重：相同元素相邻 - 双指针基础：利用有序性 - 提前终止：最小数>0则退出 **步骤2：外层循环 - 固定第一个数** ```python for i in range(len(nums) - 2): # 去重：跳过重复元素 if i > 0 and nums[i] == nums[i-1]: continue # 提前终止：如果最小数>0，后面不可能=0 if nums[i] > 0: break # 双指针找后两个数 left, right = i + 1, len(nums) - 1 target = -nums[i] while left < right: current_sum = nums[left] + nums[right] if current_sum == target: result.append([nums[i], nums[left], nums[right]]) # 去重：跳过重复的left while left < right and nums[left] == nums[left+1]: left += 1 # 去重：跳过重复的right while left < right and nums[right] == nums[right-1]: right -= 1 # 同时移动，寻找下一组解 left += 1 right -= 1 elif current_sum < target: left += 1 # 需要更大的和 else: right -= 1 # 需要更小的和 ``` **关键点详解**： 1. **为什么循环到 `len(nums)-2`？** - 需要留2个数给双指针 - i 最大只能到 n-3 2. **为什么判断 `i > 0`？** - 第一个元素不用判断重复 - 避免越界访问 3. **为什么用 `break` 而不是 `continue`？** - 后面都>0，不可能和为0 - 直接退出外层循环 **步骤3：内层双指针 - 两数之和** ```python def twoSum(nums, start, target): left, right = start, len(nums) - 1 while left < right: current_sum = nums[left] + nums[right] if current_sum == target: result.append([-target, nums[left], nums[right]]) # 去重：跳过重复的left while left < right and nums[left] == nums[left+1]: left += 1 # 去重：跳过重复的right while left < right and nums[right] == nums[right-1]: right -= 1 # 同时移动，寻找下一组解 left += 1 right -= 1 elif current_sum < target: left += 1 # 需要更大的和 else: right -= 1 # 需要更小的和 ``` **关键点**： - 为什么找到答案后还要跳过重复？避免重复结果 - 为什么找到答案后要同时移动？继续寻找其他组合 ### 关键细节说明 **细节1：为什么是 `if i > 0`？** ```python # 错误写法 if nums[i] == nums[i-1]: # i=0时会越界！ continue # 正确写法 if i > 0 and nums[i] == nums[i-1]: # 第一个元素不用判断 continue ``` **细节2：为什么找到答案后要同时移动？** ``` 假设：[-2, 0, 1, 1, 2] i L R 找到：-2 + 0 + 2 = 0 ✓ 如果只移动一个指针： - L++: [-2, 0, 1, 1, 2] → -2 + 1 + 2 = 1 > 0 → R-- 但这样可能错过其他组合 正确做法：同时移动 - L++ and R--: 继续寻找其他可能的组合 ``` **细节3：为什么break而不是continue？** ```python if nums[i] > 0: break # 正确：后面的数都>0，不可能和为0 # continue # 错误：会继续无意义的循环 ``` **推理**： - 数组已排序 - 如果 nums[i] > 0，则 nums[i+1] >= nums[i] > 0 - 任意三个正数相加不可能为0 - 直接退出，节省时间 **细节4：为什么使用 `while` 而不是 `if` 去重？** ```python # 错误写法：只跳过一个重复元素 if nums[left] == nums[left+1]: left += 1 # 正确写法：跳过所有重复元素 while left < right and nums[left] == nums[left+1]: left += 1 ``` **示例**： ``` 数组：[-2, -1, -1, -1, 0, 1, 2] i L R 找到：-2 + (-1) + 3 = 0 ✓ 如果用 if： 只跳过一个-1，还会重复 如果用 while： 跳过所有-1，避免重复 ``` ### 边界条件分析 **边界1：数组长度不足** ``` 输入：[0, 1] 输出：[] 原因：长度<3，无法组成三元组 处理：循环条件 range(len(nums)-2) 自动处理 ``` **边界2：全部为0** ``` 输入：[0, 0, 0, 0] 输出：[[0, 0, 0]] 去重逻辑：只保留一个组合 过程： - i=0: 找到 [0,0,0]，跳过后续重复 - i=1: nums[1]==nums[0]，跳过 - i=2: nums[2]==nums[1]，跳过 ``` **边界3：有重复元素** ``` 输入：[-1, -1, 0, 1] 输出：[[-1, 0, 1]] 去重逻辑：跳过第二个-1 过程： - i=0: 找到 [-1,0,1] - i=1: nums[1]==nums[0]，跳过 ``` **边界4：最小的正整数情况** ``` 输入：[-2, -1, 0, 1, 2] 输出：[[-2, 0, 2], [-2, -1, 3], [-1, 0, 1]] 提前终止：i=0时nums[i]=-2<0，继续 i=3时nums[i]=1>0，退出 ``` ### 复杂度分析（详细版） **时间复杂度**： ``` - 排序：O(n log n) - 外层循环：O(n) - 内层双指针：O(n) - 总计：O(n log n) + O(n²) = O(n²) 为什么主项是O(n²)？ - n² >> n log n (当n较大时) - 渐近复杂度取最高阶 ``` **空间复杂度**： ``` - 排序：O(log n) (快速排序栈空间) - 结果存储：O(k) (k为结果数量) - 指针变量：O(1) - 总计：O(log n) (不考虑结果存储) ``` --- ## 图解过程 ``` 数组: [-4, -1, -1, 0, 1, 2] ↑ ↑ ↑ i left right 第一轮: i = 0, nums[i] = -4 left = 1, right = 5 sum = -4 + (-1) + 2 = -3 < 0 left++ left = 2, right = 5 sum = -4 + (-1) + 2 = -3 < 0 left++ left = 3, right = 5 sum = -4 + 0 + 2 = -2 < 0 left++ left = 4, right = 5 sum = -4 + 1 + 2 = -1 < 0 left++ left >= right, 退出 第二轮: i = 1, nums[i] = -1 left = 2, right = 5 sum = -1 + (-1) + 2 = 0 ✓ 结果: [-1, -1, 2] left = 3, right = 4 sum = -1 + 0 + 1 = 0 ✓ 结果: [-1, 0, 1] 第三轮: i = 2, nums[i] = -1 (重复，跳过) 第四轮: i = 3, nums[i] = 0 > 0, 退出 最终结果: [[-1,-1,2], [-1,0,1]] ``` --- ## 代码实现 ```go func threeSum(nums []int) [][]int { result := [][]int{} n := len(nums) // 步骤1：排序 sort.Ints(nums) // 步骤2：外层循环，固定第一个数 for i := 0; i < n-2; i++ { // 去重：跳过重复的第一个数 if i > 0 && nums[i] == nums[i-1] { continue } // 提前终止：如果最小数>0，后面不可能=0 if nums[i] > 0 { break } // 双指针找后两个数 left, right := i+1, n-1 target := -nums[i] for left < right { sum := nums[left] + nums[right] if sum == target { result = append(result, []int{nums[i], nums[left], nums[right]}) // 去重：跳过重复的left for left < right && nums[left] == nums[left+1] { left++ } // 去重：跳过重复的right for left < right && nums[right] == nums[right-1] { right-- } // 同时移动，寻找下一组解 left++ right-- } else if sum < target { left++ // 需要更大的和 } else { right-- // 需要更小的和 } } } return result } ``` --- ## 执行过程演示 **输入**：[-1, 0, 1, 2, -1, -4] **排序后**：[-4, -1, -1, 0, 1, 2] ``` i=0, nums[i]=-4, target=4 left=1, right=5: -1+2=1 < 4 → left++ left=2, right=5: -1+2=1 < 4 → left++ left=3, right=5: 0+2=2 < 4 → left++ left=4, right=5: 1+2=3 < 4 → left++ left=5, right=5: 退出 i=1, nums[i]=-1, target=1 left=2, right=5: -1+2=1 == 1 ✓ 添加 [-1, -1, 2] left=3, right=4 left=3, right=4: 0+1=1 == 1 ✓ 添加 [-1, 0, 1] left=4, right=3: 退出 i=2, nums[i]=-1 (重复，跳过) i=3, nums[i]=0 > 0, 退出 结果：[[-1, -1, 2], [-1, 0, 1]] ``` --- ## 常见错误 ### 错误1：忘记排序 ❌ **错误代码**： ```go func threeSum(nums []int) [][]int { // 直接遍历，没有排序 for i := 0; i < len(nums)-2; i++ { // ... } } ``` ✅ **正确代码**： ```go func threeSum(nums []int) [][]int { sort.Ints(nums) // 必须先排序 for i := 0; i < len(nums)-2; i++ { // ... } } ``` **原因**：不排序无法使用双指针，无法去重 --- ### 错误2：去重逻辑不完整 ❌ **错误代码**： ```go // 只去重了第一个数 if i > 0 && nums[i] == nums[i-1] { continue } // left和right没有去重 ``` ✅ **正确代码**： ```go // 三个地方都要去重 if i > 0 && nums[i] == nums[i-1] { continue } for left < right && nums[left] == nums[left+1] { left++ } for left < right && nums[right] == nums[right-1] { right-- } ``` **原因**：避免重复结果 --- ### 错误3：指针移动条件错误 ❌ **错误代码**： ```go if sum < target { right-- // 错误！应该增大和 } ``` ✅ **正确代码**： ```go if sum < target { left++ // 正确！增大left可以增大和 } ``` **原因**：数组有序，left越大，和越大 --- ### 错误4：提前终止条件错误 ❌ **错误代码**： ```go if nums[i] >= 0 { // 错误！等于0也要继续 break } ``` ✅ **正确代码**： ```go if nums[i] > 0 { // 正确！大于0才退出 break } ``` **原因**：[0, 0, 0] 是有效答案 --- ## 进阶问题 ### Q1: 如果是四数之和？ **方法**：两层循环 + 双指针，时间 O(n³) ```go func fourSum(nums []int, target int) [][]int { result := [][]int{} sort.Ints(nums) n := len(nums) for i := 0; i < n-3; i++ { if i > 0 && nums[i] == nums[i-1] { continue } for j := i + 1; j < n-2; j++ { if j > i+1 && nums[j] == nums[j-1] { continue } left, right := j+1, n-1 for left < right { sum := nums[i] + nums[j] + nums[left] + nums[right] if sum == target { result = append(result, []int{nums[i], nums[j], nums[left], nums[right]}) for left < right && nums[left] == nums[left+1] { left++ } for left < right && nums[right] == nums[right-1] { right-- } left++ right-- } else if sum < target { left++ } else { right-- } } } } return result } ``` **Q2: 如果数组很大，如何优化？** **优化**： 1. 提前终止：`nums[i] * 3 > target`（正数情况） 2. 二分查找：确定第二个数后，二分查找后两个 3. 哈希表：空间换时间 --- ## P7 加分项 ### 深度理解 - **排序的作用**：去重 + 双指针基础 - **双指针原理**：利用有序性，单向移动 - **去重策略**：多处去重，确保结果唯一 ### 实战扩展 - **大数据场景**：外部排序 + 分段处理 - **分布式场景**：MapReduce 框架 - **业务场景**：推荐系统、用户画像匹配 ### 变形题目 1. [16. 最接近的三数之和](https://leetcode.cn/problems/3sum-closest/) 2. [18. 四数之和](https://leetcode.cn/problems/4sum/) 3. [259. 较小的三数之和](https://leetcode.cn/problems/3sum-smaller/) --- ## 总结 **核心要点**： 1. **排序**：为双指针和去重创造条件 2. **固定一个数**：将问题转化为两数之和 3. **双指针**：根据 sum 与 target 的关系移动指针 4. **多重去重**：i、left、right 都要跳过重复元素 **易错点**： - 忘记排序 - 去重逻辑不完整 - left 和 right 的移动条件 - 优化提前终止的条件 **最优解法**：排序 + 双指针，时间 O(n²)，空间 O(1)