【Leetcode哈希表 15. 三数之和】C++ 「超难，看完必会」

🎈个人主页：算法诗人
✨收录专栏：算法诗人Leetcode揭秘之旅
🎉欢迎 👍点赞✍评论⭐收藏
🤝希望我的文章能对你们有所帮助，有不足的地方请在评论区留言指正，大家一起学习交流！🤗

---

---

Leetcode题目链接

15. 三数之和

---

一、题目描述

给你一个整数数组 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

二、解题思路

如果这道题使用哈希表去解决会比较难，其中的去重操作非常容易出错，感兴趣的朋友可以自己去写一下感受它的难度，我这里给出一个示例代码以供参考。

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int>> result;
        sort(nums.begin(), nums.end());
        // 找出a + b + c = 0
        // a = nums[i], b = nums[j], c = -(a + b)
        for (int i = 0; i < nums.size(); i++) {
            // 排序之后如果第一个元素已经大于零，那么不可能凑成三元组
            if (nums[i] > 0) {
                break;
            }
            if (i > 0 && nums[i] == nums[i - 1]) { //三元组元素a去重
                continue;
            }
            unordered_set<int> set;
            for (int j = i + 1; j < nums.size(); j++) {
                if (j > i + 2
                        && nums[j] == nums[j-1]
                        && nums[j-1] == nums[j-2]) { // 三元组元素b去重
                    continue;
                }
                int c = 0 - (nums[i] + nums[j]);
                if (set.find(c) != set.end()) {
                    result.push_back({nums[i], nums[j], c});
                    set.erase(c);// 三元组元素c去重
                } else {
                    set.insert(nums[j]);
                }
            }
        }
        return result;
    }
};

时间复杂度：O(n log n) + O(n^2)，其中主要的贡献来自排序和双层循环。在大 O 表示法中，通常我们会忽略常数因子，因此这段代码的时间复杂度可以近似表示为 O(n^2)。
空间复杂度：O(n)。这是因为哈希集合的空间复杂度是 O(n)，并且结果向量的空间复杂度也是 O(n)。其他的变量和数据结构使用的空间是常数级别的，因此对于输入规模为 n 的情况，总的空间复杂度为 O(n)。

本道题我们采用双指针的方法会比较简单明了，整体思路是通过固定一个元素，使用双指针在剩余数组中找到满足条件的两个数，得到所有不重复的三元组。在处理过程中，利用排序和去重操作避免了重复计算。

完整的思路如下，有点烧脑，可以配合下面的示例代码一起来思考：

1. 排序数组： 首先对输入的数组 nums 进行升序排序，这是为了方便后续的双指针遍历。
2. 外层循环固定一个元素： 使用 for 循环遍历排序后的数组，将当前元素固定为 nums[i]。
3. 提前结束条件： 如果当前固定的元素 nums[i] 大于零，由于数组已经排序，后续的元素必然也大于零，因此不可能存在三个数的和为零，可以直接返回结果。
4. 去重： 在循环中，如果 i 大于零且当前元素与前一个元素相同，说明已经处理过相同的元素，为了避免重复计算，跳过当前循环。
5. 双指针遍历剩余数组： 使用左右两个指针，left 初始化为 i + 1，right 初始化为数组末尾。
6. 内层循环找到三数之和： 在内层循环中，通过 while 循环遍历左右指针，计算当前三个数的和 sum = nums[i] + nums[left] + nums[right]。
7. 判断和的大小：
   如果 sum > 0，说明右边的数太大，需要将右指针左移。
   如果 sum < 0，说明左边的数太小，需要将左指针右移。
   如果 sum == 0，说明找到一个三元组，将其加入结果集，并进行去重操作。
8. 返回结果： 最终返回找到的所有三元组。

三、示例代码

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int>> result;
        sort(nums.begin(), nums.end());

        for(int i = 0; i < nums.size(); i++)
        {
            if(nums[i] > 0)
            {
                return result;
            }
            if(i > 0 && nums[i] == nums[i-1])
            {
                continue;
            }
            int left = i + 1;
            int right = nums.size() - 1;
            while(left < right)
            {
                if(nums[i] + nums[left] + nums[right] > 0)
                    right--;
                else if(nums[i] + nums[left] + nums[right] < 0)
                    left++;
                else
                {
                    result.push_back({nums[i], nums[left], nums[right]});

                    while(left < right && nums[left] == nums[left + 1])
                        left++;
                    while(left < right && nums[right] == nums[right - 1])
                        right--;
                    
                    left++;
                    right--;
                }
            }
        }
    return result;
    }
};

时间复杂度：O(n log n) + O(n^2)，其中主要的贡献来自排序和双层循环。在大 O 表示法中，通常我们会忽略常数因子，因此这段代码的时间复杂度可以近似表示为 O(n^2)。
空间复杂度：O(n)。这是因为哈希集合的空间复杂度是 O(n)，并且结果向量的空间复杂度也是 O(n)。其他的变量和数据结构使用的空间是常数级别的，因此对于输入规模为 n 的情况，总的空间复杂度为 O(n)。

去重极容易出错的点！！！(让我崩溃破防）

1. 错误去重a方法，将会漏掉 {-1,-1,2} 这种情况

//极容易出现的错误方法
if (nums[i] == nums[i + 1]) {
	continue;
}

这是一种极容易出现的错误去重方法，提前判断下一个 a，导致{-1,-1,2} 这种情况被漏掉，其实这是因为我们把b当成了下一个a去去重了。正确的方法应该是通过与上一个a进行比较来判断现在的a是否需要去重。

//正确的方法
if (i > 0 && nums[i] == nums[i - 1]) {
	continue;
}

2. b, c 的去重时机也很重要

b, c 的去重一定要放在把符合条件的组合放入result之后，不然会漏掉了 0,0,0 这种三元组。

结尾碎碎念
“这次的算法解析只是冰山一角，未来我将持续分享更多有趣的算法问题，并提供更深入的解析。如果你对这个系列感兴趣，不要错过即将到来的更新！点赞、关注、收藏，如果有不同的解法欢迎留下你的评论，你们的支持就是我更新的最大动力。让我们一起探索更多算法的奇妙世界，这不仅是为了迎接面试挑战，更是为了成为在编程领域中游刃有余的专家。感谢大家的支持，期待未来更多的相遇和共同成长！”