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

15. 3Sum(三数之和)

  • 1. 题目描述
  • 2. 暴力解法(Brute Force, Time Limit Exceeded)
    • 2.1 解题思路
    • 2.2 实例代码
      • 不使用Set
      • 使用Set
  • 3. 哈希表法(Hash Table)
    • 3.1 解题思路
    • 3.2 实例代码
  • 4. 双指针法(Two Pointers)
    • 4.1 解题思路
    • 4.2 实例代码
  • 5. 参考资料

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

你可能感兴趣的:(LeetCode-Medium,leetcode,c++)