代码随想录二刷 ｜哈希表 ｜ 三数之和

题目描述

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

解题思路 & 代码实现

哈希法

使用两层for循环确定 a 和 b 的数值，可以使用哈希法来确定 0-(a+b) 是否在数组里出现过，其实这个思路是正确的，但是有一个非常棘手的问题，就是题目中说的不可以包含重复的三元组。

首先将数组排序，这样数组就是从小到大排列的，进入第一个for循环来确定a的值：

sort(nums.begin(), nums.end());
// a = nums[i]
for (int i = 0; i < nums.size(); i++) {}

此时第一个坑出现了：因为数组是升序排列的，如果nums[0] > 0，那么无论如何也不能凑出三元组了

if (nums[i] > 0) break;

接下来是第二个坑：a的去重问题。题目中说不允许有重复的三元组，如何理解这个重复呢？

对重复的理解

这个重复有两层，第一层是对a、b、c三个元素共同而言，第二重是对单个元素而言。

我们寻找的三个元素a、b、c，只有保证{a, b, c}这个顺序被找到，而{a, c, b}、{b, a,c}等这些不会被找到，才能做到第一层不重复，那么如何让a、b、c固定在自己的位置呢？

那就是让数组升序排列。

假设有这样的数组nums = {-1, 0, 1, 2, -1, -4}，我们发现有这两个三元组是重复的：

nums[0] + nums[1] + nums[2] = (-1) + 0 + 1 = 0 , {-1, 0, 1}
nums[1] + nums[2] + nums[4] = 0 + 1 + (-1) = 0 , {0, 1, -1}

它们的特点是，a、b、c的大小不固定，有时b最大，有时c最大，如果采用升序排列，让a <= b<= c，那么a、b、c的位置就固定下来了。

再具体一些，我们要做的就是排序数组，让三元组{a, b, c}满足a <= b <= c。

而对于单个位置上而言，相邻的两个元素不可以相同。

例如假设我们排序了一个数组后：

[-2, -1, 0, 1, 1, 2, 2, 3]

我们找到一个三元组为{-2, 0, -2}，而c的下一个元素仍然为2，也会出现一个{-2, 0, 2}，这样也造成了重复。

前面通过排序，解决了第一层重复的问题，接下来再来看看a、b、c都是如何去重的。

a的去重

作为第一个数，a的去重比较容易想到，那就是满足相邻元素不相同这一条即可，所以，如果nums[i] == nums[i + 1]，就跳过i指向的元素，继续遍历。

这也是一个坑，如果我们这样写，就错过了这种情况{-1, -1, 2}，当遍历到a = -1时，发现下一个元素也是-1，那么a就跳过第一个-1指向第二个-1，这就会导致b取不到原本应该由它取的第二个-1，这组数据就直接pass了。

因此，我们应该让nums[i]与它的前一个数，也就是nums[i - 1]相比较，而i - 1这个下标还需要有意义，所以最终的去重逻辑如下：

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

b的去重

第二个数同理，也要满足相邻元素不相同这一条，但是就不能像对 a 那样简单考虑了。我们需要想到的是，如果测试用例为nums={0, 0, 0};，那么b在取0时会发现条件不满足了：

if (j > i + 1 && nums[j] == nums[j - 1]){
	continue;
}

此时nums[j] = 0, nums[j - 1] = 0， j会跳过第二个0，取第三个0，发现也不满足，会结束循环，最后输出的是[];也就是一个三元组也没取到，而{0, 0, 0}是满足条件的。

因此，为了保证这种情况也能取到，需要这样做：

if (j > i + 2 && nums[j] == nums[j - 1] && nums[j - 1] == nums[j - 2]){
	continue;
}

此时 i = 0，j = 1，不满足条件，不会跳过这个0，因此这个0会被取到。

c的去重

c的去重比较简单，先说寻找c的逻辑。

因为我们使用哈希法寻找c，因此在寻找到c后将三元组插入set中，如果没寻找到，就将nums[j]插入到set中，因为数组是递增的，所以c只会大于等于a、b，因此插入set时放入当前的最小值nums[j]，这样当下次寻找时就能找到 c 了。

再说去重的逻辑，因为找到了三元组，因此这个三元组的排列就是唯一的，我们要保证下次再找到c时，是一个全新的三元组，因此在找到后，需要删掉set中的c。

例如，假设nums = {-1, -1, 2, 2};我门找到的三元组是{-1, -1, 2}，而c的下一个取值依然为2，所以我们需要删掉set中的2，这样下次在set中寻找时就不会找到重复的三元组了。

代码如下：

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（也就是 - (a + b)的去重）
} else {
	set.insert(nums[j]);
}

整体代码如下：

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++) {
			// 排序之后第一个元素大于0，就不可能凑成三元组
			if (nums[i] > 0) break;
			// a（也就是nums[i]）的去重
			if (i > 0 && nums[i] == nums[i - 1]) {
				continue;
			}
			unordered_set<int> set;
			for (int j = i + 1; j < nums.size(); j++) {
				// b（也就是nums[j]）的去重
				if (j > i + 2 && nums[j] == nums[j - 1] && nums[j - 1] == nums[j - 2]){
					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（也就是 - (a + b)的去重）
				} else {
					set.insert(nums[j]);
				}
			}
		}
		return result;
	}
};

可见哈希法虽然乍一看逻辑很简单，但实际写起来麻烦重重，接下来介绍另一种方法。

双指针法

以这个nums数组来举例，首先将数组排序，然后有一层for循环，i 从下标0的地方开始，同时定义一个下标left 指向 i+1的位置上，定义下标right在数组结尾的位置上。

在数组中找到 abc 使得a + b +c =0，我们这里相当于 a = nums[i]，b = nums[left]，c = nums[right]。

如果nums[i] + nums[left] + nums[right] > 0，就说明此时三数之和大了，因为数组是排序后了，所以right下标就应该向左移动，这样才能让三数之和小一些。

如果nums[i] + nums[left] + nums[right] < 0，说明此时三数之和小了，left就向右移动，才能让三数之和大一些，直到left与right相遇为止。

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;
			// a的去重
			if (i > 0 && nums[i] == nums[i - 1]) continue;
			
			int left = i + 1;
			int right = nums.size() - 1;
			
			while (right > left) {
				if (nums[i] + nums[left] + nums[right] > 0) right--;
				else if (nums[i] + nums[left] + nums[right] < 0) left++;
				else {
					result.push_back(vector<int>{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;
	}
};

心细的人会发现，b、c的去重逻辑统统放在了后面，也就是找到三元组后再去重，为什么不在找b、c的时候去重呢？例如：

if (nums[i] + nums[left] + nums[right] > 0) {
	right--;
	while (right > left && nums[right] == nums[right - 1]) right--;
} else if (nums[i] + nums[left] + nums[right] < 0) {
	left++;
	while (right > left && nums[left] == nums[left + 1]) left++;
}

其实去重逻辑的代码是一样的，只是位置不同，不放在前面的原因是，如果在找到三元组前就去重，有可能会导致right <= left了，这样就会漏掉{0, 0, 0}这中情况。