🔥个人主页：北极的代码（欢迎来访）
🎬作者简介：java后端学习者
✨命运的结局尽可永在，不屈的挑战却不可须臾或缺！
摘要：
题目背景：LeetCode15
给你一个整数数组
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 。提示：
3 <= nums.length <= 3000-105 <= nums[i] <= 105
题目答案:1 双指针法
java
class Solution {
public List<List<Integer>> threeSum(int[] nums) {
List<List<Integer>> result = new ArrayList<>();
Arrays.sort(nums);
// 找出a + b + c = 0
// a = nums[i], b = nums[left], c = nums[right]
for (int i = 0; i < nums.length; i++) {
// 排序之后如果第一个元素已经大于零，那么无论如何组合都不可能凑成三元组，直接返回结果就可以了
if (nums[i] > 0) {
return result;
}
if (i > 0 && nums[i] == nums[i - 1]) { // 去重a
continue;
}
int left = i + 1;
int right = nums.length - 1;
while (right > left) {
int sum = nums[i] + nums[left] + nums[right];
if (sum > 0) {
right--;
} else if (sum < 0) {
left++;
} else {
result.add(Arrays.asList(nums[i], nums[left], nums[right]));
// 去重逻辑应该放在找到一个三元组之后，对b 和 c去重
while (right > left && nums[right] == nums[right - 1]) right--;
while (right > left && nums[left] == nums[left + 1]) left++;
right--;
left++;
}
}
}
return result;
}
}题目答案：2 哈希法
java
class Solution {
public List<List<Integer>> threeSum(int[] nums) {
List<List<Integer>> result = new ArrayList<>();
Arrays.sort(nums);
for (int i = 0; i < nums.length; i++) {
// 如果第一个元素大于零，不可能凑成三元组
if (nums[i] > 0) {
return result;
}
// 三元组元素a去重
if (i > 0 && nums[i] == nums[i - 1]) {
continue;
}
HashSet<Integer> set = new HashSet<>();
for (int j = i + 1; j < nums.length; j++) {
// 三元组元素b去重
if (j > i + 2 && nums[j] == nums[j - 1] && nums[j - 1] == nums[j - 2]) {
continue;
}
int c = -nums[i] - nums[j];
if (set.contains(c)) {
result.add(Arrays.asList(nums[i], nums[j], c));
set.remove(c); // 三元组元素c去重
} else {
set.add(nums[j]);
}
}
}
return result;
}
}题目解析：
两层for循环就可以确定 两个数值，可以使用哈希法来确定 第三个数 0-(a+b) 或者 0 - (a + c) 是否在 数组里出现过，其实这个思路是正确的，但是我们有一个非常棘手的问题，就是题目中说的不可以包含重复的三元组。
把符合条件的三元组放进vector中**，然后再去重，这样是非常费时的，很容易超时**，也是这道题目通过率如此之低的根源所在。
去重的过程不好处理，有很多小细节，如果在面试中很难想到位。
时间复杂度可以做到O(n^2)，但还是比较费时的，因为不好做剪枝操作。因此我们在这里先用下一别的方法：双指针法
大体的思路：
拿这个nums数组来举例，首先将数组排序，然后有一层for循环，i从下标0的地方开始，同时定一个下标left 定义在i+1的位置上，定义下标right 在数组结尾的位置上。
依然还是在数组中找到 abc 使得a + b +c =0，我们这里相当于 a = nums[i]，b = nums[left]，c = nums[right]。
接下来如何移动left 和right呢
如果nums[i] + nums[left] + nums[right] > 0 就说明 此时三数之和大了，因为数组是排序后了，所以right下标就应该向左移动，这样才能让三数之和小一些。
如果 nums[i] + nums[left] + nums[right] < 0 说明 此时 三数之和小了，left 就向右移动，才能让三数之和大一些，直到left与right相遇为止。
然后是最核心的操作：元素去重
关于元素去重，我们考虑的是相同三元组重复，而不是一个数组中的三个元素重复。先明确这个
a、b、c本身可以重复 ，比如[-1,-1,2]是合法答案。但不能出现两个一模一样的三元组 ：
[-1,-1,2]和[-1,-1,2]这叫重复，必须去掉一个。
对 a 去重：
三数之和思路是：固定一个 a = nums [i]，然后在后面找 b + c = -a
数组往往是这样的：
[-4, -1, -1, -1, 0, 1, 2]你会发现有好几个 -1：
当 i=1，a = -1能找到一组：
[-1, -1, 2]当 i=2，a 又 = -1又会找到一组：
[-1, -1, 2]当 i=3，a 还 = -1又又找到一组：
[-1, -1, 2]结果你就会返回：
[ [-1,-1,2], [-1,-1,2], [-1,-1,2] ]这就是重复的三元组，题目不允许。
所以 "对 a 去重" 的意思是：
如果当前这个 a，跟上一个 a 是同一个数字，就直接跳过！
为什么a 相同 ，后面找到的 b、c 就一定一样
因为数组已经排序了！
- 前提：数组排过序
三数之和标准做法第一步：
Arrays.sort(nums);数组变成从小到大有序：
[-4, -1, -1, -1, 0, 1, 2]
- 关键逻辑：
a 相同 + 数组有序 → 要找的 b + c 目标相同 → 找到的组合必然相同
一步步拆：
① a 相同 → 要找的目标相同
我们要找：a + b + c = 0 → b + c = -a
如果两次 a 都是 -1 那么两次要找的目标都是：b + c = 1
② 数组有序 → 查找范围是固定的一段
第一次 a = nums [1] = -1查找范围：它后面 的数
[-1, -1, 0, 1, 2]第二次 a = nums [2] = -1查找范围：还是它后面 的数
[-1, 0, 1, 2]虽然起点稍微变了，但能凑成 1 的有效组合只有一组 ：
-1 + 2 = 1③ 结果就是：
两次找到的三元组完全一样：
[-1, -1, 2] [-1, -1, 2]因为数组有序，同一个数字，在后面能配对的数字组合是固定的。 只要 a 一样，找到的 b、c 一定一样，三元组就一定重复。
例子：
数组：
[-1, -1, -1, 2]目标：a + b + c = 0
① i = 0，a = nums[0] = -1
left = 1right = 3
i left right 0 1 2 3 [-1, -1, -1, 2]计算：a + b + c = (-1) + (-1) + 2 = 0 ✅
→ 得到组合：[-1, -1, 2]
② i = 1，a = nums[1] = -1
这里触发 a 去重：
if (i > 0 && nums[i] == nums[i-1]) { continue; }
nums[1] == nums[0]→ 都是 -1→ 直接 continue，跳过！ → 不执行双指针
③ i = 2，a = nums[2] = -1
同样触发去重：
nums[2] == nums[1]→ continue，跳过
④ i = 3，a = nums[3] = 2
left = 4，已经越界了，不找了。
最终结果
只得到 1 个 [-1, -1, 2] 没有重复
b，c去重：
数组（已排序）：
nums = [-3, -2, -1, 0, 1, 1, 1, 2]我们固定：
a = nums[0] = -3要找：
b + c = 3初始状态
left: 1 (-2) right: 7 (2)一步步移动后，最终会停在这里：
left=4 right=7 ↓ ↓ [-3, -2, -1, 0, 1, 1, 1, 2]此时：
b = 1 c = 2 1 + 2 = 3 ✔ 满足得到三元组：
[-3, 1, 2]情况 1：不去重 b、c（会出大问题）
找到后直接：
left++; right--;指针变成：
left=5 right=6 ↓ ↓ [-3, -2, -1, 0, 1, 1, 1, 2]
1 + 1 = 2 < 3→ left++又回到：
left=6 right=5循环乱了，还会再次找到
1和2，又生成一次[-3,1,2]结果就是：
[[-3,1,2], [-3,1,2], [-3,1,2] ...]全是重复的。
情况 2：对 b、c 去重（正确做法）
找到
b=1，c=2之后，先去重，再移动指针① 对 b 去重（跳过所有相同的 1）
while (left < right && nums[left] == nums[left + 1]) { left++; }数组里：
nums[4] = 1 nums[5] = 1 nums[6] = 1所以 left 会一口气从 4 → 6
② 对 c 去重（跳过所有相同的 2）
while (left < right && nums[right] == nums[right - 1]) { right--; }这里只有一个 2，不动。
③ 再正常移动
left++; right--;去重完的结果
left 直接跳过了所有重复的 1right 跳过了所有重复的 2
最终：
left > right循环结束，只得到一组 [-3,1,2]，没有任何重复。
关键：
- 最核心公式
三数之和：a + b + c = 0 → b + c = -a
看到了吗b + c 等于多少，完全由 a 决定
a = -1 → 要找 b + c = 1
a = -2 → 要找 b + c = 2
a = 0 → 要找 b + c = 0
a 不一样，要找的 b、c 完全不一样！
- 所以必须：
先固定一个 a → 在这个 a 的前提下，再去重 b、c
你想一下：
这一轮 a 是
-1，要找b+c=1你把 b、c 去重，找到所有不重复组合
完事了
再换下一个 a
如果 a 不固定，一边换 a 一边去重 b、c→ 逻辑直接乱套→ 根本不知道该找
b+c=？
- 用例子一眼看懂
数组：
[-1, -1, -1, 2]① 固定 a = nums [0] = -1
要找：b + c = 1 在后面
[-1, -1, 2]里双指针、去重 b、c→ 得到[-1, 2]② 下一个 a 还是 -1
直接 continue 跳过，不进双指针
③ 再下一个 a 还是 -1
继续 continue
④ a 变成 2
要找
b+c=-2，后面没数了，结束
- 为什么不能 "不固定 a" 直接去重 b、c
因为：
a 不同 → 目标不同
b、c 的意义完全不同
不能混在一起去重
必须一个 a 管一轮 b、c
这一轮的 b、c 只服务于当前这个 a
总结
b、c 是为当前这个 a 服务的 a 不固定，就不知道要找什么样的 b、c 所以必须：先固定 a → 再在它后面找 b、c 并去重
这就是三数之和的完整逻辑链：排序 → 遍历固定 a → a 去重 → 双指针找 b,c → b,c 去重 → 下一个 a
整体结构
整体流程就 4 大步：
1. 数组排序（必须排序！不然无法双指针+去重）
2. 遍历每一个数，当作 a = nums[i]
→ a 重复就跳过
3. 对每个 a，用 left = i+1、right = 末尾 找 b、c
4. 找到 a+b+c=0 就记录，然后给 b、c 去重，继续找混淆点：
i=0（a=-1）
left = 1，right=3 ← 初始化，开局
while(...) {
找到一组 b c
去重
left++ right-- ← 同一轮里继续找
}
i=1（a=-1）
left = 2，right=3 ← 又开局！
...left = i+1 → 换 a 时，重新开局
left++ → 同一 a 里，找下一组 b、c
结语：
如果对你有帮助，请**点赞，关注，收藏，**你的支持就是我最大的鼓励！
