题目:
给你一个整数数组 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
来源:力扣(LeetCode)
链接:https://leetcode.cn/problems/1fGaJU
思路:
解法一、排序+三指针(一固定,俩移动)
和上一道题剑指 Offer II 006. 排序数组中两个数字之和类比,首先对原数组进行升序排列Arrays.sort(nums)。
从头到尾扫描一遍,固定第一个元素i,其他俩指针分别为该元素右侧的第一个和最后一个,用这俩指针所指元素之和与(0-i)的大小进行判断。和>(0-i),右指针左移;和<(0-i),左指针右移;若等于,则将这三个元素加入一个动态数组中,并且如果左指针元素仍小于右指针元素的话,同时将右指针左移和左指针右移(避免遗漏三元组)。
然后将所有答案加入HashSet,自动去重,返回时再转回ArrayList(有点笨)。
时间复杂度:O(n^2)(其中,数组排序的时间复杂度为 O(nlogn),外层循环的时间复杂度为 O(n),内层循环的时间复杂度为 O(n),因此总时间复杂度为 O(nlogn + n^2) = O(n^2)),空间复杂度:O(n)(哈希集合用于存储答案,最坏情况下需要存储 O(n) 个元素)
执行用时:184 ms, 在所有 Java 提交中击败了11.37%的用户
内存消耗:46.1 MB, 在所有 Java 提交中击败了7.96%的用户
class Solution {
public List<List<Integer>> threeSum(int[] nums) {
HashSet<ArrayList<Integer>> ans = new HashSet<ArrayList<Integer>>();
Arrays.sort(nums);
for(int i = 0; i < nums.length; i++){
int low = i + 1, high = nums.length - 1;
while(low < high){
if(nums[low] + nums[high] == 0 - nums[i]){
ArrayList<Integer> a = new ArrayList<Integer>();
a.add(nums[i]);
a.add(nums[low]);
a.add(nums[high]);
ans.add(a);
low++;
high--;
}else if(nums[low] + nums[high] < 0 - nums[i]){
low++;
}else{
high--;
}
}
}
return new ArrayList<>(ans);
}
}
解法二、排序+双指针(用算法去重代替结构去重)
排序是为了避免重复三元组。也就是说,我们枚举的三元组 (a,b,c) 满足 a≤b≤c,保证了只有 (a,b,c) 这个顺序会被枚举到,而 (b,a,c)、(c,b,a) 等等这些不会。
排序后,对于每一重循环而言,相邻两次枚举的元素不能相同,否则也会造成三元组重复。
如果我们固定了前两重循环枚举到的元素 a 和 b,那么只有唯一的 c 满足 a+b+c=0。当第二重循环往后枚举一个元素 b ′时,由于 b ′>b,那么满足 a+b ′+c ′ =0 的 c ′ 一定有 c ′<c,即 c ′ 在数组中一定出现在 c 的左侧。也就是说,我们可以从小到大枚举 b,同时从大到小枚举 c,即第二重循环和第三重循环实际上是并列的关系。有了这样的发现,我们就可以保持第二重循环不变,而将第三重循环变成一个从数组最右端开始向左移动的指针。
时间复杂度:O(n^2),空间复杂度:O(logn)(我们忽略存储答案的空间,额外的排序的空间复杂度为 O(logN)。然而我们修改了输入的数组 nums,在实际情况下不一定允许,因此也可以看成使用了一个额外的数组存储了 nums 的副本并进行排序,空间复杂度为 O(N))。
执行用时:20 ms, 在所有 Java 提交中击败了90.32%的用户
内存消耗:45.8 MB, 在所有 Java 提交中击败了38.28%的用户
class Solution {
public List<List<Integer>> threeSum(int[] nums) {
int n = nums.length;
Arrays.sort(nums);
List<List<Integer>> ans = new ArrayList<List<Integer>>();
// 枚举 a
for (int first = 0; first < n; ++first) {
// 需要和上一次枚举的数不相同
if (first > 0 && nums[first] == nums[first - 1]) {
continue;
}
// c 对应的指针初始指向数组的最右端
int third = n - 1;
int target = -nums[first];
// 枚举 b
for (int second = first + 1; second < n; ++second) {
// 需要和上一次枚举的数不相同
if (second > first + 1 && nums[second] == nums[second - 1]) {
continue;
}
// 需要保证 b 的指针在 c 的指针的左侧
while (second < third && nums[second] + nums[third] > target) {
--third;
}
// 如果指针重合,随着 b 后续的增加
// 就不会有满足 a+b+c=0 并且 b<c 的 c 了,可以退出循环
if (second == third) {
break;
}
if (nums[second] + nums[third] == target) {
List<Integer> list = new ArrayList<Integer>();
list.add(nums[first]);
list.add(nums[second]);
list.add(nums[third]);
ans.add(list);
}
}
}
return ans;
}
}