LeetCode-三数之和-Java

一、题目

给你一个整数数组 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

二、思路分析

        审题可知，本题要求返回所有和为 0 且不重复的三元组。这就表示代码中需要包含去重逻辑，这也是增添本题复杂性的地方，如果依然使用哈希法，会导致代码的去重逻辑非常复杂，但是使用双指针法，效率会有所提高，可读性也大大增强。

        想附上整体代码，再结合代码讲解。

public List<List<Integer>> threeSum(int[] nums) {
        // 1、初始化
        ArrayList<List<Integer>> resultList = new ArrayList<>();
        // 2、处理
        Arrays.sort(nums);
        for (int i = 0; i < nums.length; i++) {
            // 第一个元素 > 0，不可能存在这样的三元组
            if (nums[i] > 0) return resultList;
            // 2.1、去重第一个数
            if (i > 0 && nums[i] == nums[i - 1]) {
                continue;
            }
            // 2.2、定义左右指针，开始取第二个数和第三个数,并与0比较大小
            int left = i + 1;
            int right = nums.length - 1;
            while (right > left) {
                int sum = nums[left] + nums[right] + nums[i];
                if (sum > 0) {
                    right--;
                } else if (sum < 0) {
                    left++;
                } else {
                    resultList.add(Arrays.asList(nums[i], nums[left], nums[right]));
                    // 2.3、过滤第二个重复的数和第三个重复的数
                    while (right > left && nums[left] == nums[left + 1]) left++;
                    while (right > left && nums[right] == nums[right - 1]) right--;
                    left++;
                    right--;
                }
            }
        }
        // 3、返回结果
        return resultList;
    }

        那么在针对数组整体大的循环中，第一个数的去重逻辑是

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

        这个相信大家都理解，没什么好说的。关键是针对第二个数和第三个数的去重逻辑

else {
     resultList.add(Arrays.asList(nums[i], nums[left], nums[right]));
     // 2.2、过滤第二个重复的数和第三个重复的数
     while (right > left && nums[left] == nums[left + 1]) left++;
     while (right > left && nums[right] == nums[right - 1]) right--;
     left++;
     right--;
}

        首先第一点，为什么要在找到第一个三元组后，进行去重逻辑呢？可以看这样一个测试用例即(0,0,0,0,0,0)，很显然第一次检索就能拿到数组下标为(0,1,5)的组合，如果这时不对第二个第三个元素去重，就会导致出现重复的元组放进了result中，while循环限制下，使得left指针卡为5，right指针与之相同，本次大循环也随之结束。在下次大循环中，因为第一个数的限制，使得代码跳出循环，最终输出[0,0,0]的结果

        那么还有一个问题就是，为什么末尾要left++,right--呢？这是因为在while循环中，其实是找到了相同数字的最后一个位置。末尾再进行++，--操作是去获得一个与之前完全不同的新三元组再去进行判断。

三、代码（包括测试用例，建议自己debug看看）

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class ThreeNumSum {
    public static void main(String[] args) {
        ThreeNumSum solution = new ThreeNumSum();

        // 测试用例
        int[] nums1 = {-1,-1,-1,2,2,2};
        solution.threeSum(nums1);
        System.out.println("Test Case 1: " + solution.threeSum(nums1)); // 应该输出 [[-1, -1, 2], [-1, 0, 1]]

        /*int[] nums2 = {0, 0, 0, 0};
        System.out.println("Test Case 2: " + solution.threeSum(nums2)); // 应该输出 [[0, 0, 0]]

        int[] nums3 = {1, 2, -2, -1};
        System.out.println("Test Case 3: " + solution.threeSum(nums3)); // 应该输出 []

        int[] nums4 = {};
        System.out.println("Test Case 4: " + solution.threeSum(nums4)); // 应该输出 []

        int[] nums5 = {-2, 0, 1, 1, 2};
        System.out.println("Test Case 5: " + solution.threeSum(nums5)); // 应该输出 [[-2, 0, 2], [-1, 1, 0]]*/
    }

    public List<List<Integer>> threeSum(int[] nums) {
        // 1、初始化
        ArrayList<List<Integer>> resultList = new ArrayList<>();
        // 2、处理
        Arrays.sort(nums);
        for (int i = 0; i < nums.length; i++) {
            // 第一个元素 > 0，不可能存在这样的三元组
            if (nums[i] > 0) return resultList;
            // 2.1、去重第一个数
            if (i > 0 && nums[i] == nums[i - 1]) {
                continue;
            }
            // 2.1、定义左右指针，开始取第二个数和第三个数,并与0比较大小
            int left = i + 1;
            int right = nums.length - 1;
            while (right > left) {
                int sum = nums[left] + nums[right] + nums[i];
                if (sum > 0) {
                    right--;
                } else if (sum < 0) {
                    left++;
                } else {
                    resultList.add(Arrays.asList(nums[i], nums[left], nums[right]));
                    // 2.2、过滤第二个重复的数和第三个重复的数
                    while (right > left && nums[left] == nums[left + 1]) left++;
                    while (right > left && nums[right] == nums[right - 1]) right--;
                    left++;
                    right--;
                }
            }
        }
        // 3、返回结果
        return resultList;
    }
}