15. 3Sum（三数之和）三种解法（C++ & 注释）

1. 题目描述

给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有满足条件且不重复的三元组。

注意：答案中不可以包含重复的三元组。

示例：

给定数组 nums = [-1, 0, 1, 2, -1, -4]
满足要求的三元组集合为： [ [-1, 0, 1], [-1, -1, 2] ]

题目链接：中文题目；英文题目

2. 暴力解法（Brute Force, Time Limit Exceeded）

2.1 解题思路

直接三个for循环检查所有三元组是否符合题意。注意这里要用sort函数排序，跳过当层循环内的重复数字，但需要排除首个数字的情况。只是这个方法不出所料的超时啦~

举个例子：

[0, 0, -1, 0, 1, 2, -1, -4, -2, -2]
排序后：[-4, -2, -2, -1, -1, -1, 0, 0, 0, 1, 2]

以第一层循环为例，如果不跳过重复数字，那-2会产生两个相同的答案，而我们只需要一个就行，所以我们查找第一个数字，跳过后面相同的数字即可。

另外，这里也可以用set来排除重复答案，只是需要额外的空间和时间去遍历set，来得到最终的答案。

2.2 实例代码

不使用Set

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        int len = nums.size();
        vector<vector<int>> ans;

        sort(nums.begin(), nums.end());
        for (int i = 0; i < len - 2; i++) {
            if (i != 0 && nums[i] == nums[i - 1]) continue; // 跳过第一层循环中的重复数字
            for (int j = i + 1; j < len; j++) {
                if (j - 1 != i && nums[j] == nums[j - 1]) continue; // 跳过第二层循环中的重复数字
                for (int k = j + 1; k < len; k++)
                    if (!(k - 1 != j && nums[k] == nums[k - 1])  // 跳过第三层循环中的重复数字
                        && nums[i] + nums[j] + nums[k] == 0) {
                        vector<int> v = { nums[i], nums[j], nums[k] };
                        ans.push_back(v);
                    }
            }
        }

        return ans;
    }
};

使用Set

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        int len = nums.size();
        set<vector<int>> s;

        sort(nums.begin(), nums.end());
        for (int i = 0; i < len - 2; i++) {
            for (int j = i + 1; j < len; j++) {
                for (int k = j + 1; k < len; k++)
                    if (nums[i] + nums[j] + nums[k] == 0) {
                        vector<int> v = { nums[i], nums[j], nums[k] };
                        s.insert(v);
                    }
            }
        }

        vector<vector<int>> ans;
        for (const vector<int>& v : s) ans.push_back(v);
        return ans;
    }
};

3. 哈希表法（Hash Table）

3.1 解题思路

那么如果接着上面暴力解法的思路，有没有一种方法可以减少时间复杂度呢？根据题意我们需要寻找三个数，他们满足这样的条件：nums[i] + nums[j] + nums[k] = 0，所以如果我们知道nums[i]和nums[j]，就可以计算出对应的nums[k]，所以我们在遍历nums[j]的时候，如果在map中没有存储-num[i] - nums[j]，我们就将nums[j]存储到map中，方便下次查找；反之，如果找到了，则把答案保存起来，并且跳过和nums[j]相同的数字，开始下一次查找。利用哈希表查找速度快，来提升时间复杂度，用空间换时间。

3.2 实例代码

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        int len = nums.size();
        vector<vector<int>> ans;

        sort(nums.begin(), nums.end());
        for (int i = 0; i < len; i++) {
            if (i != 0 && nums[i] == nums[i - 1]) continue; // 跳过i代表的重复数字
            unordered_map<int, int> m;
            for (int j = i + 1; j < len; j++) {
                if (m.count(-nums[i] - nums[j])) {
                    ans.push_back({ nums[i], nums[j], -nums[i] - nums[j] });
                    while (j + 1 < len && nums[j] == nums[j + 1]) j++; // 跳过j代表的重复数字
                }
                else m.insert(pair<int, int>(nums[j], j)); // 我们是在nums[i]后面的数字寻找nums[j]和nums[k]（即-nums[i] - nums[j]），所以这里存储nums[j]
            }
        }
        
        return ans;
    }
};

4. 双指针法（Two Pointers）

4.1 解题思路

其实当我们固定了nums[i]，我们可以在剩余部分的数字中，从左右边界开始往中间开始检查，如果nums[i] + nums[left] + nums[right] > 0，则right–，右边界往左移动；如果nums[i] + nums[left] + nums[right] < 0，则left++，左边界往右移动；如果等于0，先保存答案，然后left++，right–，然后往中间检查，跳过与加入答案的左右边界数字相同的数字。比如：

0	1	2	3	4	5	6	7	8
-2	-2	-1	-1	0	1	2	4	5

当i = 0，left = 1，right = 7，加入答案之后，left右移动一格，right左移动一格，即检查nums[2] == nums[1]？检查nums[7] == nums[6]？

4.2 实例代码

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        int len = nums.size();
        vector<vector<int>> ans;

        sort(nums.begin(), nums.end());
        for (int i = 0; i < len; i++) {
            int left = i + 1, right = len - 1;
            if (i != 0 && nums[i] == nums[i - 1]) continue; // 跳过nums[i]所表示的重复数字
            while (left < right) {
                if (nums[i] + nums[left] + nums[right] == 0) {
                    ans.push_back({ nums[i], nums[left], nums[right] });
                    left++;
                    right--;
                    while (left < right && nums[left] == nums[left - 1]) left++; // 跳过左边界重复数字
                    while (left < right && nums[right] == nums[right + 1]) right--; // 跳过右边界重复数字
                }
                else if (nums[i] + nums[left] + nums[right] > 0) right--;
                else left++;
            }
        }   
        return ans;
    }
};

5. 参考资料

1. LeetCode——15. 3Sum

---