LeetCode15-三数之和

注意：答案中不可以包含重复的三元组

    示例一：
    输入：nums = [-1,0,1,2,-1,-4]
    输出：[[-1,-1,2],[-1,0,1]]

    示例二：
    输入：nums = []
    输出：[]

    示例三：
    输入：nums = [0]
    输出：[]

提示:

0 <= nums.length <= 3000
-10^5 <= nums[i] <= 10^5

  一个数组中要找三个元素，使其相加之和等于 0， 即 a + b + c = 0 , 那么我们是否可以将其转换为 b + c = 0 - a, 假设 a 已知 ，那么我们是不是就降级为两数之和了，思路就很清晰了， 但是还有一个问题 “答案中不可以包含重复的三元组”, 也就是说不能有重复解，试想一下如果数组有序， a ,b 都是一个比较小的元素，在有解的情况下是不是有且只有一个稍大的数 c 使得 a + b + c = 0 。

/**
     * 排序 + 双指针
     * 数组排序后，从最小的那个元素开始遍历，
     * 每个元素如果有解则必然对应其它的两个数组元素
     * 使用指针L标记i+1(当前元素的下一个元素)，指针R标记n(数组最后一个元素)
     * 右边指针R左移,左边指针L右移，直到L>=R
     * 在这个过程中如果存在 nums[i] + nums[L] + nums[R] == 0 , 则nums[i] ， nums[L] ， nums[R] 为一组三元组解
     *
     * @param nums
     * @return
     */
    public static List<List<Integer>> reslove(int[] nums) {
        List<List<Integer>> result = new ArrayList<>();
        if (nums == null || nums.length < 3) {
            return result;
        }

        //数组排序
        nums = Arrays.stream(nums).sorted().toArray();

        if (nums[nums.length - 1] == 0 && nums[0] == 0) {
            result.add(new ArrayList<Integer>() {{
                add(0);
                add(0);
                add(0);
            }});
            return result;
        }

        int n = nums.length;
        for (int i = 0; i < nums.length; i++) {
            int L = i + 1;
            int R = n - 1;

            while (L < R) {
                int count = nums[i] + nums[L] + nums[R];
                if (count == 0) {
                    List<Integer> o1 = new ArrayList<>(4);
                    o1.add(nums[i]);
                    o1.add(nums[L]);
                    o1.add(nums[R]);
                    result.add(o1);

                    //偏移到最后一个相同的数
                    while (L < R && nums[L] == nums[L + 1]) {
                        L = L + 1;
                    }
                    /*while (L < R && nums[R] == nums[R - 1]) {
                        R = R - 1;
                    }*/
                    //偏移到最后一个相同的数
                    while (i < L && nums[i] == nums[i+1]) {
                        i = i + 1;
                    }
                    if(L < R){
                        L = L + 1;
                        R = R - 1;
                        continue;
                    }

                }else if (count > 0) {
                    R = R - 1;
                } else {
                    L = L + 1;
                }
            }
        }
        return result;
    }

public static void main(String[] args) {
        List<List<Integer>> lists = reslove(new int[]{-2, -3, 0, 0, -2});
        System.out.println(lists.toString());

        List<List<Integer>> lists1 = reslove(new int[]{-1, 0, 1, 2, -1, -4});
        System.out.println(lists1.toString());

        List<List<Integer>> lists2 = reslove(new int[]{-1, 0, 1, 2, -1, -4});
        System.out.println(lists2.toString());

        List<List<Integer>> lists3 = reslove(new int[]{1, 0, 0, 0});
        System.out.println(lists3.toString());

        List<List<Integer>> lists4 = reslove(new int[]{-1, -1, -1, 0, 1, 1, 0, 1, 1});
        System.out.println(lists4.toString());
    }

ps : 有重复元素的情况下，很容易忽略一些特殊情况，如元素全为零， 元素为多个 -1 ， 0 ， 1 ， 有多个重复元素时要把指针偏移到最后一个相等的位置。