15.三数之和

题目

给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请你返回所有和为 0 且不重复的三元组。

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

提示：

• 3 <= nums.length <= 3000
• -105 <= nums[i] <= 105

---

示例

示例 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个for循环遍历所有情况进行暴力搜索找到最终答案。

在这里我将暴力搜索的方式稍微进行了一点点优化（真滴仅有一点点，完全不建议使用，亲测提交后会超时！！！）。

首先将nums数组进行排序，然后通过搜索找到了第一个大于等于0的数，标记其位置为mid。

因为三个数的和为零，无非就是以下这几种情况：

• 三个数都是0。
• 一正一负加一个0。
• 两负一正。
• 两正一负。

所以我们可以用这个mid作为分界（边界条件和000的特例需要考虑一下）：

• 一种情况是在mid左侧找两个数，在右侧找一个数
• 另一种情况是在mid左侧找一个数，在右侧找两个数

以下是完整代码：

#include<iostream>
#include<cstdlib>
#include<vector>
#include<algorithm>

using namespace std;

vector<vector<int>> threeSum(vector<int>& nums){
    vector<vector<int>> res;
    if(nums.size() < 3){
        return res;
    }

    sort(nums.begin(), nums.end());
    int mid = 0;  // 记录0或者最小正数的位置
    for(mid; mid < nums.size(); mid++){
        if(nums[mid] >= 0){
            break;
        }
    }

    if(nums[mid] == 0 && mid + 1 < nums.size() && nums[mid + 1] == 0 && mid + 2 < nums.size() && nums[mid + 2] == 0){
        res.push_back({0, 0, 0});
    }

    for(int i = 0; i < mid - 1; i++){
        for(int j = i + 1; j < mid; j++){
            for(int k = mid; k < nums.size(); k++){
                if(nums[i] + nums[j] + nums[k] == 0){
                    int flag = 0;  // 没有重复值
                    vector<int> temp = {nums[i], nums[j], nums[k]};
                    sort(temp.begin(), temp.end());
                    for(auto v : res){
                        if(v == temp){
                            flag = 1;
                            break;
                        }
                    }
                    if(flag == 0){
                        res.push_back(temp);
                    }
                }
            }
        }
    }

    for(int k = 0; k < mid; k++){
        for(int i = mid; i < nums.size() - 1; i++){
            for(int j = i + 1; j < nums.size(); j++){
                if(nums[i] + nums[j] + nums[k] == 0){
                    int flag = 0;  // 没有重复值
                    vector<int> temp = {nums[k], nums[i], nums[j]};
                    sort(temp.begin(), temp.end());
                    for(auto v : res){
                        if(v == temp){
                            flag = 1;
                            break;
                        }
                    }
                    if(flag == 0){
                        res.push_back(temp);
                    }
                }
            }
        }
    }

    return res;
}

int main(void){
    vector<int> nums = {-1, 0, 1, 2, -1, -4};
    vector<vector<int>> res = threeSum(nums);
    cout << "[";
    for(int i = 0; i < res.size(); i++){
        cout << "[";
        for(int j = 0; j < res[i].size(); j++){
            if(j == res[i].size() - 1){
                cout << res[i][j];
            }else{
                cout << res[i][j] << ",";
            }
        }
        if(i == res.size() - 1){
            cout << "]";
        }else{
            cout << "],";
        }
    }
    cout << "]" << endl;
    system("pause");
    return 0;
}

---

方法二：排序+双指针

特例判断：对数组的大小进行一个判断，如果nums.size()小于3，可以直接返回结果为空。

先对nums进行排序。

排序后固定一个数nums[i]：

• 如果nums[i]大于0，说明后面任意三个数的和一定会大于零，此时结束循环。
• 如果nams[i]==nums[i-1]，说明数字出现重复的情况，应该跳过。

再使用两个指针L和R分别指向i后面数组的两端，即i+1和nums.size()-1。

计算nums[i]，nums[L]，nums[R]三个数的和判断其是否等于0，此时有三种情况需要分别进行讨论：

• 如果等于0，找到结果，调整L、R的位置继续寻找（需要判断去重）。
• 如果大于0，说明nums[R]太大，需要将R左移。
• 如果小于0，说明nums[L]太小，需要将L右移。

 以下为完整代码：

#include<iostream>
#include<cstdlib>
#include<vector>
#include<algorithm>

using namespace std;

vector<vector<int>> threeSum(vector<int>& nums){
    vector<vector<int>> res = {};

    if(nums.size() < 3){  // 如果数组的长度小于3，直接返回空
        return res;
    }

    sort(nums.begin(), nums.end());  // 对数组进行排序

    for(int i = 0; i < nums.size(); i++){
        if(nums[i] > 0){  // nums[i] > 0，后面的数都大于0，不可能相加等于0
            return res;
        }

        if(i > 0 && nums[i] == nums[i-1]){  // 去重
            continue;
        }

        int L = i + 1;
        int R = nums.size() - 1;
        while (L < R){
            if(nums[i] + nums[L] + nums[R] == 0){  // 找到答案
                res.push_back({nums[i], nums[L], nums[R]});
                while(L < R && nums[L] == nums[L+1]){
                    L++;
                }
                while(L < R && nums[R] == nums[R-1]){
                    R--;
                }
                L++;
                R--;
            }else if(nums[i] + nums[L] + nums[R] < 0){  // 和太小，L右移
                L++;
            }else{  // 和太大，R左移
                R--;
            }
        }
    }
    return res;
} 

int main(void){
    vector<int> nums = {-1, 0, 1, 2, -1, -4};
    vector<vector<int>> res = threeSum(nums);
    cout << "[";
    for(int i = 0; i < res.size(); i++){
        cout << "[";
        for(int j = 0; j < res[i].size(); j++){
            if(j == res[i].size() - 1){
                cout << res[i][j];
            }else{
                cout << res[i][j] << ",";
            }
        }
        if(i == res.size() - 1){
            cout << "]";
        }else{
            cout << "],";
        }
    }
    cout << "]" << endl;
    system("pause");
    return 0;
}

---

方法三：map记录

这题类比于《1.两数之和》这道题目，我们可以先使用map来进行存储，以降低时间复杂度。

首先使用map记录每个数字出现的次数，然后对map的key数组进行排序（这个数组包含了所有不重复的数字），然后在这个数组里面搜索到另外两个数组和自己相加等于0的值。

这里分为三种情况：

• 三个数完全相同，即0， 0， 0的情况。
• 两个数相同。
• 三个数都不同。

以下是完整代码：

#include<iostream>
#include<cstdlib>
#include<vector>
#include<algorithm>
#include<map>

using namespace std;

vector<vector<int>> threeSum(vector<int>& nums){
    vector<vector<int>> res;

    map<int, int> counter;  // 记录每个数字出现的次数
    for(int value : nums){
        counter[value]++;
    }

    vector<int> uniqNums;  // 存储不重复的数字
    for(auto& entry : counter){
        uniqNums.push_back(entry.first);
    }

    sort(uniqNums.begin(), uniqNums.end());  // 排序

    for(int i = 0; i < uniqNums.size(); i++){
        if(uniqNums[i] * 3 == 0 && counter[uniqNums[i]] >= 3){  // 0的情况
            res.push_back({uniqNums[i], uniqNums[i], uniqNums[i]});
        }
        for(int j = i + 1; j < uniqNums.size(); j++){  // 两个不同的数
            if(uniqNums[i] * 2 + uniqNums[j] == 0 && counter[uniqNums[i]] > 1){  
                res.push_back({uniqNums[i], uniqNums[i], uniqNums[j]});
            }
            if(uniqNums[j] * 2 + uniqNums[i] == 0 && counter[uniqNums[j]] > 1){
                res.push_back({uniqNums[i], uniqNums[j], uniqNums[j]});
            }
            int c = 0 - uniqNums[i] - uniqNums[j];  // 三个不同的数
            if (c > uniqNums[j] && counter[c] > 0){  // c > uniqNums[j]是为了去重
                res.push_back({uniqNums[i], uniqNums[j], c});
            }
        }
    }
    return res;
}


int main(void){
    vector<int> nums = {-1, 0, 1, 2, -1, -4};
    vector<vector<int>> res = threeSum(nums);
    cout << "[";
    for(int i = 0; i < res.size(); i++){
        cout << "[";
        for(int j = 0; j < res[i].size(); j++){
            if(j == res[i].size() - 1){
                cout << res[i][j];
            }else{
                cout << res[i][j] << ",";
            }
        }
        if(i == res.size() - 1){
            cout << "]";
        }else{
            cout << "],";
        }
    }
    cout << "]" << endl;
    system("pause");
    return 0;
}

---

参考资料

15. 三数之和 - 力扣（LeetCode）

0015.3 Sum | LeetCode Cookbook (halfrost.com)