力扣hot100——15.三数之和

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 。

题解：

 1.哈希表

我一开始对此题的想法就是在经过一层遍历之后，将题目简化为求两数之和，即求两数之和的target等于0-nums[i]。通过哈希表将该题的时间复杂度简化到O(n^2)

java代码实现：

public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> list = new ArrayList<>();
        Arrays.sort(nums);  // 对数组进行排序

        for (int i = 0; i < nums.length - 2; i++) {
            // 跳过重复的 i 值
            if (i > 0 && nums[i] == nums[i - 1]) continue;

            HashMap<Integer, Integer> map = new HashMap<>();
            for (int j = i + 1; j < nums.length; j++) {
                int complement = -nums[i] - nums[j];
                
                if (map.containsKey(complement)) {
                    list.add(Arrays.asList(nums[i], nums[j], complement));
                    
                    // 跳过重复的 j 值以避免重复的三元组
                    while (j + 1 < nums.length && nums[j + 1] == nums[j]) j++;
                }

                map.put(nums[j], j);
            }
        }
        return list;
    }

值得关注的是，题目要求返回的三元组不能有重复，因此需要先将数组进行排序以跳过重复情况，如若把重复校验放在map.containKeys前面的话可能会去除掉[-2,1,1]这种情况，而在校验后用while循环巧妙的避免了所有重复的情况，如[-2,1,1,1,1,1,1]则后面的四个1都会跳过遍历

2.双指针

同样的思想，也是将内层两层的循环通过双指针法将时间复杂度降到O(n)，因为经过排序后数组中的数从小到大排序，所以可以将第三层循环改造成一个由右往左移动的指针，首先指向数组末尾，在遍历的过程中若三数之和大于0，则向左移动指针（但必须满足其在第二层循环的指针的右侧）

java代码实现：

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;
    }
}