力扣热门100题——三数之和(排序+双指针)

5、三数之和

1.问题描述

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

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

2.示例

示例 1:

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

输入:nums = []
输出:[]
示例 3:

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

3.提示

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

4.具体解法(排序+双指针)

//第一想法肯定是暴力循环遍历,但是三个数的和,O(n^3)的时间复杂度,一定会超时
//任意一个三元组的和都为 0。如果我们直接使用三重循环枚举三元组,会得到 O(N^3)个满足题目要求的三元组(其中 N 是数组的长度)时间复杂度至少为 O(N^3)
//在这之后,我们还需要使用哈希表进行去重操作,得到不包含重复三元组的最终答案,又消耗了大量的空间。
//这个做法的时间复杂度和空间复杂度都很高,因此我们要换一种思路来考虑这个问题。

//无奈只能去看题解了
//方法一:排序 + 双指针
//不重复的本质是什么?我们保持三重循环的大框架不变,只需要保证:
//第二重循环枚举到的元素不小于当前第一重循环枚举到的元素;第三重循环枚举到的元素不小于当前第二重循环枚举到的元素。
//也就是说,我们枚举的三元组(a,b,c) 满足a≤b≤c,保证了只有(a,b,c) 这个顺序会被枚举到,而(b,a,c)、(c,b,a) 等等这些不会,这样就减少了重复。
//要实现这一点,我们可以将数组中的元素从小到大进行排序,随后使用普通的三重循环就可以满足上面的要求。

//上面一段就是告诉我们为什么要先排序,排序可以减少重复的顺序组合,只有一个从小到大的顺序会被搜索到
//同时,对于每一重循环而言,相邻两次枚举的元素不能相同,否则也会造成重复。(注意是每一重循环之间,而不是不同的重之间)
//例如(123334),我们遍历了(123),第三重的下一个还会是,那就肯定重复了,所以应该跳过的所有的3,直接进入4的情况

//以上可以基本实现了要求,但是还没有跳出O(n^3)三重循环的大框架
//我们发现,当我们固定了前两重的内容a和b,其实三重有且仅有唯一的元素是成立的(a+b+c=0)
//当第二重循环往后枚举一个元素时,b2肯定是大于b的,所以一定会有c2<c,也就是c2一定会出现在c的左侧
//也就是说,我们可以从小到大枚举 bb,同时从大到小枚举 cc,即第二重循环和第三重循环实际上是并列的关系。
//了这样的发现,我们就可以保持第二重循环不变,而将第三重循环变成一个从数组最右端开始向左移动的指针

//这个方法就是我们常说的「双指针」,
//当我们需要枚举数组中的两个元素时,如果我们发现随着第一个元素的递增,第二个元素是递减的,
//那么就可以使用双指针的方法,将枚举的时间复杂度从 O(N^2)减少至 O(N)。
//为什么是 O(N) 呢?这是因为在枚举的过程每一步中,「左指针」会向右移动一个位置(也就是题目中的 b)
//而「右指针」会向左移动若干个位置,这个与数组的元素有关,但我们知道它一共会移动的位置数为 O(N)
//均摊下来,每次也向左移动一个位置,因此时间复杂度为O(N)。

//还有第一重循环,时间复杂度为 O(N),因此枚举的总时间复杂度为 O(N^2)
//由于排序的时间复杂度为O(NlogN),在渐进意义下小于前者,因此算法的总时间复杂度为 O(N^2)

//上面很多的解释,理解之后,我总结来说就是两个部分,为什么排序,和如何使用双指针
//排序可以为双指针的使用提供前提,并且可以减少重复的出现
//双指针可以将双重循环变成一重循环,但需要在一些特殊的场景,比如这个题的有序中,而且数字的特点也有你大我小的特点


/*
class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        int n = nums.length;
        Arrays.sort(nums);
        List<List<Integer>> ans = new ArrayList<List<Integer>>();//存结果的列表,注意他的泛型是List集合
        // 枚举 a
        for (int first = 0; first < n; ++first) {
            // 需要和上一次枚举的数不相同
            if (first > 0 && nums[first] == nums[first - 1]) {//只有first>0才有first-1这个存在,所以得加上这个部分判断
                continue;
            }
            // c 对应的指针初始指向数组的最右端
            int third = n - 1;
            int target = -nums[first];//要找第一层循环那个数的负数(-a=b+c)
            // 枚举 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;
    }
}
 */
 
 //方法二:暴力加去除重复
 //首先按照第一题两数之和的思路,我们可以固定一个数traget,再利用两数之和的思想去map中存取或查找(-1)*target - num[j]
 //但是会超时,学习一下思路就好
 /*
  // 暴力
    public List<List<Integer>> threeSum(int[] nums) {
        if (nums == null || nums.length == 0){
            return null;
        }
        List<List<Integer>> lists = new ArrayList<>();
        Map<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            int target = nums[i];
            for (int j = i + 1; j < nums.length; j++) {
                List<Integer> list = new ArrayList<>();
                list.add(target);
                int tmp = target*(-1) - nums[j];
                if (map.containsKey(tmp) && map.get(tmp) != i) {
                    list.add(nums[j]);
                    list.add(tmp);
                    lists.add(list);
                }
                map.put(nums[j],j);
            }
        }
        return dupRemoval(lists);
    }

    // 去重
    private List<List<Integer>> dupRemoval(List<List<Integer>> lists) {
        if (lists.size() == 1) return lists;
        int i = 0;
        while (lists.get(i+1) != null) {
            if (lists.get(i).retainAll(lists.get(i+1))) {
                lists.remove(i+1);
            }
        }
        return lists;
    }
*/

5.收获

  • 指针可以将双重循环变成一重循环,但需要在一些特殊的场景,比如这个题的有序中,而且数字的特点也有你大我小的特点

  • 接触到排序的思路了,可以为很多算法提供前提帮助

  • 数组的排序有方法 Arrays.sort(nums);直接类名调用,Arrays类中有很多对数组的操作,要有使用它的想法和思路

  • 本题的难点在于如何去除重复解

  • 还可以在官方代码上加上一些特别的判断,比如第一层的元素,也就是第一个数就是大于零的,那么没必要继续,直接break就行了,因为和不可能为零了(排过序的),还有就是数组长度小于3,的直接返回[]就行

  • 1
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值