当前位置：首页 > news >正文

【Hot100 ｜ 6 LeetCode 15. 三数之和】

news 2025/11/8 9:15:30

这段代码是解决 LeetCode 15. 三数之和 问题的经典排序 + 双指针解法，核心目标是在整数数组中找到所有不重复的三元组（a, b, c），使得 a + b + c = 0。该解法通过排序简化查找逻辑，结合双指针优化效率，并通过严格去重避免重复结果，时间复杂度为 O (n²)，空间复杂度为 O (log n)（主要来自排序）。

一、问题理解

问题要求

给定一个整数数组 nums，返回所有和为 0 的三元组 [nums[i], nums[j], nums[k]]，满足：

i、j、k 是不同的索引（i ≠ j、i ≠ k、j ≠ k）；
结果中不能包含重复的三元组（如 [-1, 0, 1] 和 [0, -1, 1] 视为相同，需去重）。

二、核心思路：排序 + 双指针 + 去重

暴力解法（三重循环枚举所有三元组）时间复杂度为 O (n³)，且需要额外去重，效率极低。该解法通过以下优化实现高效求解：

排序：先对数组排序，好处有二：
- 方便利用双指针缩小查找范围（根据和的大小移动指针）；
- 让相同元素相邻，便于去重（避免重复三元组）。
固定一元素 + 双指针找另外两元素：
- 固定第一个元素 nums[i]（i 从 0 到 n-3）；
- 用左指针 left = i+1、右指针 right = n-1 寻找另外两个元素，使得三者和为 0。
根据和调整指针：
- 若 nums[i] + nums[left] + nums[right] == 0：找到符合条件的三元组，加入结果；
- 若和 < 0：总和偏小，左指针右移（增大数值）；
- 若和 > 0：总和偏大，右指针左移（减小数值）。
去重逻辑：对固定元素 i、左指针 left、右指针 right 分别去重，避免重复三元组。

三、代码逐行解析

java

运行

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;class Solution {public List<List<Integer>> threeSum(int[] nums) {// 1. 初始化结果列表（存储所有符合条件的三元组）List<List<Integer>> ans = new ArrayList<>();// 2. 边界处理：数组为空或长度不足3，直接返回空列表if (nums == null || nums.length < 3) {return ans;}// 3. 对数组排序（核心前提：方便双指针查找和去重）Arrays.sort(nums);// 4. 固定第一个元素i，遍历数组（i最大为n-3，确保left和right有位置）for (int i = 0; i < nums.length; i++) {// 4.1 去重i：若当前元素与前一个元素相同，跳过（避免重复三元组）// 注意i>0：防止i=0时越界if (i > 0 && nums[i] == nums[i - 1]) {continue;}// 4.2 初始化双指针：left从i+1开始（避免重复索引），right从末尾开始int left = i + 1;int right = nums.length - 1;// 4.3 双指针循环：left < right（确保两指针不重叠）while (left < right) {// 计算当前三元组的和int sum = nums[i] + nums[left] + nums[right];if (sum == 0) {// 5. 找到符合条件的三元组，加入结果列表ans.add(new ArrayList<>(Arrays.asList(nums[i], nums[left], nums[right])));// 5.1 去重left：跳过与当前left相同的元素（避免重复三元组）// 注意left < right：防止越界while (left < right && nums[left] == nums[left + 1]) {left++;}// 5.2 去重right：跳过与当前right相同的元素while (left < right && nums[right] == nums[right - 1]) {right--;}// 5.3 移动双指针（找到一组后必须移动，避免死循环）left++;right--;} else if (sum < 0) {// 6. 和偏小：左指针右移（增大数值，让总和更接近0）left++;} else {// 7. 和偏大：右指针左移（减小数值，让总和更接近0）right--;}}}// 8. 返回所有符合条件的三元组return ans;}
}

四、实例演示（直观理解过程）

以测试用例 nums = [-1, 0, 1, 2, -1, -4] 为例，演示执行过程：

步骤 1：排序数组

排序后 nums = [-4, -1, -1, 0, 1, 2]（相同元素相邻，方便去重）。

步骤 2：遍历固定元素 i

i=0（nums[i] = -4）：

left=1（-1），right=5（2），sum = -4 + (-1) + 2 = -3 < 0 → left 右移至 2（-1）；
sum = -4 + (-1) + 2 = -3 < 0 → left 右移至 3（0）；
sum = -4 + 0 + 2 = -2 < 0 → left 右移至 4（1）；
sum = -4 + 1 + 2 = -1 < 0 → left 右移至 5，此时 left 不小于 right，循环结束（无符合条件的三元组）。

i=1（nums[i] = -1）：

去重检查：i=1 > 0，nums [1]（-1）≠ nums [0]（-4）→ 不跳过；
left=2（-1），right=5（2），sum = -1 + (-1) + 2 = 0 → 符合条件，加入结果 [-1, -1, 2]；
- 去重 left：nums [2]（-1）== nums [3]（0）？否 → 不移动；
- 去重 right：nums [5]（2）== nums [4]（1）？否 → 不移动；
- 移动指针：left=3，right=4；
sum = -1 + 0 + 1 = 0 → 符合条件，加入结果 [-1, 0, 1]；
- 去重 left：nums [3]（0）== nums [4]（1）？否 → 不移动；
- 去重 right：nums [4]（1）== nums [3]（0）？否 → 不移动；
- 移动指针：left=4，right=3 → 循环结束。

i=2（nums[i] = -1）：

去重检查：i=2 > 0，nums [2]（-1）== nums [1]（-1）→ 跳过（避免重复三元组）。

i=3（nums[i] = 0）：

left=4（1），right=5（2），sum = 0 + 1 + 2 = 3 > 0 → right 左移至 4，此时 left 不小于 right，循环结束。

i≥4：数组长度不足（left = i+1 会超过 right），循环结束。

最终结果

[[-1, -1, 2], [-1, 0, 1]]，无重复三元组，符合要求。

五、关键细节：去重逻辑详解

去重是该题的核心难点，代码通过三层去重确保结果唯一：

固定元素 i 的去重：if (i > 0 && nums[i] == nums[i - 1]) continue;
- 原因：若 nums [i] 与 nums [i-1] 相同，那么以 i 为第一个元素的三元组，必然和以 i-1 为第一个元素的三元组重复（因为数组已排序，后续元素相同）。
- 注意 i>0：防止 i=0 时访问 nums [-1] 越界。
左指针 left 的去重：while (left < right && nums[left] == nums[left + 1]) left++;
- 时机：仅在找到一个符合条件的三元组后执行（避免漏解）。
- 原因：若 nums [left] 与 nums [left+1] 相同，移动 left 可跳过重复元素，避免同一三元组被多次加入。
- 注意 left < right：防止 left+1 越界。
右指针 right 的去重：while (left < right && nums[right] == nums[right - 1]) right--;
- 逻辑同 left 去重，确保 right 侧无重复元素。

六、复杂度分析

时间复杂度：O(n²)。排序耗时 O (n log n)，外层循环遍历 i 耗时 O (n)，内层双指针遍历耗时 O (n)，整体由 O (n²) 主导。
空间复杂度：O(log n)。主要来自排序的空间开销（Java Arrays.sort () 对基本类型使用双轴快排，空间复杂度为 O (log n)），结果列表的空间不计入（属于输出要求）。