ICode9

精准搜索请尝试: 精确搜索
首页 > 其他分享> 文章详细

【leetcode】 15. 三数之和

2022-05-19 01:32:46  阅读:28  来源: 互联网

标签:right 15 nums int 三数 list result leetcode left


题目

给你一个包含 n 个整数的数组 nums,判断 nums 中是否存在三个元素 a,b,c ,使得 a + b + c = 0 ?请你找出所有和为 0 且不重复的三元组。

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

示例 1:

输入:nums = [-1,0,1,2,-1,-4]
输出:[[-1,-1,2],[-1,0,1]]

示例 2:

输入:nums = []
输出:[]

示例 3:

输入:nums = [0]
输出:[]

解答

三数之和的暴力解法是写一个三重循环,这样的时间复杂度是O(n^3)。
但是可以通过双指针法,将两重循环变成一重循环,这样的话时间复杂度就会变成O(n^2)。然后再进一步通过各种剪枝的操作,进一步加快计算速度。
因为使用到了双指针法,所以必然要先对数组进行排序,这样才能通过比较大小来判断该移动哪个指针。


    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> result = new ArrayList<>();

        // 先排序,Arrays.sort()的时间复杂度O(n*log(n))
        Arrays.sort(nums);

        for (int i = 0; i < nums.length - 2; i++) {
            // left在i+1的位置,right在末尾的位置,不断向中间搜索
            // 这也是i的循环,为什么结束条件是 i < nums.length - 2 的原因
            int left = i + 1;
            int right = nums.length - 1;

            while (left < right) {
                int sum = nums[left] + nums[right] + nums[i];

                if (sum == 0) {
                    // Case1. 三个数的和为0,则找到了我们想要的三个数
                    ArrayList<Integer> list = new ArrayList<>();
                    list.add(nums[i]);
                    list.add(nums[left]);
                    list.add(nums[right]);
                    result.add(list);

                    left++;
                    right--;
                } else if (sum < 0) {
                    // Case2. 三个数的和小于0,则说明这三个数太小了,则把左边的指针往右边挪一下
                    left++;
                } else {
                    // Case3. 三个数的和大于0,则说明这三个数太大了,则把右边的指针往左边挪一下
                    right--;
                }
            }
        }

        return result;
    }

如上,其实就实现了一个for循环+双指针搜索的思想。
但是这其实是有问题的。问题就在于题干说的答案中不可以包含重复的三元组

  • Case1. [-2, -1, -1, 0, 1],用如上代码搜索,会得到两个重复的答案[-1, 0, 1][-1, 0, 1]
  • Case2. [-2, -1, 0, 1, 1],用如上代码搜索,会得到两个重复的答案[-1, 0, 1][-1, 0, 1]

原因就在于:

  1. i的值可能会重复(如Case1);
  2. leftright的值可能会重复(如Case2)

所以接下来我们需要去进行去重。
去重可以有三种方法:

  1. 在循环前,先把nums去重。如,把nums放进set;
  2. 把包含结果的list放进result之前,先判断一下result是否contains这个list;
  3. 在循环的时候加入一些去重的操作

    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> result = new ArrayList<>();
        Arrays.sort(nums);

        for (int i = 0; i < nums.length - 2; i++) {
            // 1. 对i去重
            if (i != 0 && nums[i - 1] == nums[i]) {
                continue;
            }

            int left = i + 1;
            int right = nums.length - 1;

            while (left < right) {
                int sum = nums[left] + nums[right] + nums[i];

                if (sum == 0) {
                    ArrayList<Integer> list = new ArrayList<>();
                    list.add(nums[i]);
                    list.add(nums[left]);
                    list.add(nums[right]);
                    result.add(list);

                    // 2. 对left的值去重
                    while (left < right && nums[left] == nums[left + 1]) {
                        left++;
                    }
                    // 2. 对right的值去重
                    while (left < right && nums[right] == nums[right - 1]) {
                        right--;
                    }

                    left++;
                    right--;
                } else if (sum < 0) {
                    left++;
                } else {
                    right--;
                }
            }
        }

        return result;
    }

好,到现在,这个代码已经是一个能够解决三数相加问题的一个代码了。程序用时:

那么我们再尝试优化剪枝,加快一下计算的速度。


    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> result = new ArrayList<>();
        
        // 1. 如果nums的length小于3,则不可能会有和为0的三个元素,直接return
        if (nums.length < 3) {
            return result;
        }

        Arrays.sort(nums);

        // 2. 如果排序之后,最小的三个元素和大于0,则不可能会有和为0的三个元素,直接return
        if (nums[0] + nums[1] + nums[2] > 0) {
            return result;
        }

        for (int i = 0; i < nums.length - 2; i++) {
            if (i != 0 && nums[i - 1] == nums[i]) {
                continue;
            }

            // 3. 如果i和之后的两个最小的元素的和大于0,则i及i之后的元素都找不到和为0的三个元素,直接break循环
            if (nums[i] + nums[i + 1] + nums[i + 2] > 0) {
                break;
            }

            int left = i + 1;
            int right = nums.length - 1;

            while (left < right) {
                int sum = nums[left] + nums[right] + nums[i];

                if (sum == 0) {
                    ArrayList<Integer> list = new ArrayList<>();
                    list.add(nums[i]);
                    list.add(nums[left]);
                    list.add(nums[right]);
                    result.add(list);

                    // 2. 对left的值去重
                    while (left < right && nums[left] == nums[left + 1]) {
                        left++;
                    }
                    // 2. 对right的值去重
                    while (left < right && nums[right] == nums[right - 1]) {
                        right--;
                    }

                    left++;
                    right--;
                } else if (sum < 0) {
                    left++;
                } else {
                    right--;
                }
            }
        }

        return result;
    }

这样,就完成了一个三数之和的题目。程序用时:

标签:right,15,nums,int,三数,list,result,leetcode,left
来源: https://www.cnblogs.com/daheww/p/16284447.html

专注分享技术,共同学习,共同进步。侵权联系[admin#icode9.com]

Copyright (C)ICode9.com, All Rights Reserved.

ICode9版权所有