力扣网-三数之和等于0

最新推荐文章于 2023-07-20 10:14:30 发布
最新推荐文章于 2023-07-20 10:14:30 发布
阅读量507 收藏
点赞数
分类专栏： 笔试 文章标签： 笔试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lk142500/article/details/122856553
版权

问题简介

在这里插入图片描述
在这里插入图片描述

编程思路

  • 三层循环-暴力方法必须掌握
  • 双向遍历
    • image-20220210105937281

代码实现

第一个版本

ThreeNum类

import java.util.Objects;

/**
 * 三数之和等于0
 *
 * @author songquanheng
 * 2022/2/10-8:52
 */
public class ThreeNum {
    private Integer a;
    private Integer b;
    private Integer c;

    public ThreeNum(Integer a, Integer b, Integer c) {
        this.a = a;
        this.b = b;
        this.c = c;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        ThreeNum threeNum = (ThreeNum) o;
        return Objects.equals(a, threeNum.a) &&
                Objects.equals(b, threeNum.b) &&
                Objects.equals(c, threeNum.c);
    }

    @Override
    public int hashCode() {

        return Objects.hash(a, b, c);
    }

    public Integer getA() {
        return a;
    }

    public void setA(Integer a) {
        this.a = a;
    }

    public Integer getB() {
        return b;
    }

    public void setB(Integer b) {
        this.b = b;
    }

    public Integer getC() {
        return c;
    }

    public void setC(Integer c) {
        this.c = c;
    }
}

主体方法

    public List<List<Integer>> threeSum(int[] nums) {
        Set<ThreeNum> result = new HashSet<>();
        for(int i=0; i<nums.length; i++) {
            for(int j=i+1;j<nums.length; j++) {
                for (int k=j+1; k<nums.length; k++) {
                    if (nums[i] + nums[j] + nums[k] != 0) {
                        continue;
                    }
                    List<Integer> list = new ArrayList<>(Arrays.asList(nums[i], nums[j], nums[k]));
                    Collections.sort(list);
                    result.add(new ThreeNum(list.get(0), list.get(1), list.get(2)));
                }
            }
        }
        List<List<Integer>> res = new ArrayList<>();
        for (ThreeNum threeNum : result) {
            List<Integer> temp = new ArrayList<>();
            temp.addAll(Arrays.asList(threeNum.getA(), threeNum.getB(), threeNum.getC()));
            res.add(temp);

        }

        return res;
    }

image-20220210091452321

 通过了315/318个测试用例，说明算法主题思想是正确的。

第二个版本

 在构造过程中进行了排序，我们首先对于nums数组进行排序。

ThreeNum类没有变化。

主体方法

    public List<List<Integer>> threeSum(int[] nums) {
        List<Integer> param = Arrays.stream(nums)
                .boxed().sorted().collect(Collectors.toList());

        Set<ThreeNum> result = new HashSet<>();
        int size = param.size();
        for(int i = 0; i< size; i++) {
            for(int j=i+1;j<size; j++) {
                for (int k=j+1; k<size; k++) {
                    Integer first = param.get(i);
                    Integer second = param.get(j);
                    Integer third = param.get(k);
                    if (first + second + third != 0) {
                        continue;
                    }

                    result.add(new ThreeNum(first, second, third));
                }
            }
        }
        List<List<Integer>> res = new ArrayList<>();
        for (ThreeNum threeNum : result) {
            List<Integer> temp = new ArrayList<>();
            temp.addAll(Arrays.asList(threeNum.getA(), threeNum.getB(), threeNum.getC()));
            res.add(temp);

        }

        return res;
    }

image-20220210092825124

转化为二层循环-实质上还是三层循环

    public List<List<Integer>> threeSum(int[] nums) {
        List<Integer> param = Arrays.stream(nums)
                .boxed().sorted().collect(Collectors.toList());

        Set<ThreeNum> result = new HashSet<>();
        int size = param.size();
        for (int i = 0; i < size; i++) {

            for (int j = i + 1; j < size; j++) {
                Integer first = param.get(i);
                Integer second = param.get(j);
                Integer thirdShould = 0 - first - second;
                if (param.lastIndexOf(thirdShould) > j) {
                    result.add(new ThreeNum(first, second, thirdShould));
                } else {
                    continue;
                }

            }
        }
        List<List<Integer>> res = new ArrayList<>();
        for (ThreeNum threeNum : result) {
            List<Integer> temp = new ArrayList<>();
            temp.addAll(Arrays.asList(threeNum.getA(), threeNum.getB(), threeNum.getC()));
            res.add(temp);

        }

        return res;
    }

第三个版本

主体方法

    public List<List<Integer>> threeSum(int[] nums) {
        List<Integer> param = Arrays.stream(nums)
                .boxed().sorted().collect(Collectors.toList());

        Set<ThreeNum> result = new HashSet<>();
        int size = param.size();
        for (int i = 0; i < size; i++) {
            Integer first = param.get(i);
            for (int j = i + 1; j < size; j++) {
                Integer second = param.get(j);
                Integer thirdShould = 0 - first - second;

                for (int k=j+1; k<size; k++) {
                    if (param.get(k)>thirdShould) {
                        break;
                    }
                    if (param.get(k).equals(thirdShould)) {
                        result.add(new ThreeNum(first, second, thirdShould));

                    }

                }

            }
        }
        List<List<Integer>> res = new ArrayList<>();
        for (ThreeNum threeNum : result) {
            List<Integer> temp = new ArrayList<>();
            temp.addAll(Arrays.asList(threeNum.getA(), threeNum.getB(), threeNum.getC()));
            res.add(temp);

        }

        return res;
    }

参考别人思想-左右移动

 到此，笔者已经黔驴技穷了，只好参考别人的思路了。

image-20220210102341351

第一个版本

 说到底这个思想与盛最多的水是异曲同工的事情。

    public List<List<Integer>> threeSum(int[] nums) {
        List<Integer> param = Arrays.stream(nums)
                .boxed().sorted().collect(Collectors.toList());

        Set<ThreeNum> result = new HashSet<>();
        int size = param.size();
        for (int i = 0; i < size; i++) {
            Integer first = param.get(i);
            int j = i + 1;
            int k = size - 1;
            while (j < k) {
                Integer second = param.get(j);
                Integer third = param.get(k);
                int sum = first + second + third;
                if (sum > 0) {
                    k--;
                } else if (sum < 0) {
                    j++;
                } else {
                    result.add(new ThreeNum(first, second, third));
                    break;
                }
            }

        }
        List<List<Integer>> res = new ArrayList<>();
        for (ThreeNum threeNum : result) {
            List<Integer> temp = new ArrayList<>();
            temp.addAll(Arrays.asList(threeNum.getA(), threeNum.getB(), threeNum.getC()));
            res.add(temp);

        }

        return res;
    }

image-20220210103331053

image-20220210103536505

 如果直接break，则只会找到一组解

[[-2, 0, 2]]

而

[-2, 1, 1]会丢失掉

所以，不是找到一个就返回，而是找到一组解之后，继续移动指针。

所以

image-20220210104833281

主体方法-AC版本

    public List<List<Integer>> threeSum(int[] nums) {
        List<Integer> param = Arrays.stream(nums)
                .boxed().sorted().collect(Collectors.toList());

        Set<ThreeNum> result = new HashSet<>();
        int size = param.size();
        for (int i = 0; i < size; i++) {
            Integer first = param.get(i);
            int j = i + 1;
            int k = size - 1;
            while (j < k) {
                Integer second = param.get(j);
                Integer third = param.get(k);
                int sum = first + second + third;
                if (sum > 0) {
                    k--;
                } else if (sum < 0) {
                    j++;
                } else {
                    result.add(new ThreeNum(first, second, third));
                    j++;
                    k--;
                }
            }

        }
        List<List<Integer>> res = new ArrayList<>();
        for (ThreeNum threeNum : result) {
            List<Integer> temp = new ArrayList<>();
            temp.addAll(Arrays.asList(threeNum.getA(), threeNum.getB(), threeNum.getC()));
            res.add(temp);

        }

        return res;
    }

image-20220210104916957

优化

image-20220210105708761

引入去重移除ThreeNum类

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

        for (int i = 0; i < nums.length; i++) {
            if (nums[i] > 0) {
                return result;
            }

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

            int left = i + 1;
            int right = nums.length - 1;
            while (right > left) {
                int sum = nums[i] + nums[left] + nums[right];
                if (sum > 0) {
                    right--;
                } else if (sum < 0) {
                    left++;
                } else {
                    result.add(Arrays.asList(nums[i], nums[left], nums[right]));
					// 这个地方是关键
                    while (right > left && nums[right] == nums[right - 1]) right--;
                    while (right > left && nums[left] == nums[left + 1]) left++;
                    
                    right--; 
                    left++;
                }
            }
        }
        return result;
    }
}

总结

 昨天和父母聊天，聊的很晚，自己以后要扩充心凉心眼小是藏不住的。自己一定要把心整的很大。海纳百川有容乃大，一定不要心里装太多不满的事情，要看开放下，达观处世。

思影影思
关注
专栏目录
力扣--累加数
wolfGuiDao的博客
08-25 646
力扣–累加数 文章目录力扣--累加数一、问题描述二、分析三、代码 一、问题描述 二、分析 这道题第一眼看可能觉得比较简单，枚举前后3个位置，判断这3个位置的数字是否满足题目的要求（第三个数 = 前两个数之和） 但是看到后面的用例就会发现问题：199100199==》这3个数不一定是1位数，可能是多位数，所以都需要进行枚举 定义i,j,k分别代表第一个数字、第二个数字和第三个数字的起始下标，这样好处在于计算各个字符串时都很方便。 第一个数字的起始下标一定是0，但是第二和第三个数字的起始下标不
力扣---两数之和、三数之和
m0_71536793的博客
02-04 245
数组、排序、哈希、双指针
力扣-----三数和为0
shen_chengfeng的博客
06-21 307
链接：https://leetcode-cn.com/problems/3sum 给你一个包含 n 个整数的数组nums，判断nums中是否存在三个元素 a，b，c ，使得a + b + c = 0 ？请你找出所有满足条件且不重复的三元组。 注意：答案中不可以包含重复的三元组。 示例： 给定数组 nums = [-1, 0, 1, 2, -1, -4]， 满足要求的三元组集合为： [ [-1, 0, 1], [-1, -1, 2] ] int Compare...
Algorithm：三数之和为0
xikangsoon的博客
06-08 387
#include <iostream> #include <vector> #include <algorithm> using namespace std; class solution { public: vector<vector<int> > getThreeSum(vector<int> &nums) { vector<int> arr = nums; vector.
三数之和(等于0)
苟且偷生小菜鸟
07-13 526
系列文章目录 提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加 例如：第一章 Python 机器学习入门之pandas的使用 提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 目录 系列文章目录 文章目录 前言 一、pandas是什么？ 二、使用步骤 1.引入库 2.读入数据 总结 文章目录 系列文章目录 前言 一、pandas是什么？ 二、使用步骤 1.引入库 2.读入数据 总结 前言 提示：这里可以添加本文要记录
leetcode 刷题 三元组问题 三数之和等于0
usstmiracle的博客
05-23 1778
15. 三数之和 难度中等2128收藏分享切换为英文关注反馈 给你一个包含n个整数的数组nums，判断nums中是否存在三个元素a，b，c ，使得a + b + c =0 ？请你找出所有满足条件且不重复的三元组。 注意：答案中不可以包含重复的三元组。 示例： 给定数组 nums = [-1, 0, 1, 2, -1, -4]; 满足要求的三元组集合为： [ [-1, 0, 1], [-1, -1, 2] ] 这是一道非常典型的题目，值得我们细细研究。题意十分简单，在一...
力扣刷题（2）：三数之和
友友们好呀
03-18 558
力扣刷题（2）：三数之和1 问题描述2 问题分析3 python实现4 逐步分析 1 问题描述 给定一个包含n个整数的数组 nums，判断 nums 中是否存在3个元素 $ a、b、c$，使得 a+b+c=0a+b+c=0a+b+c=0。 找出所有满足条件且不重复的三元组。 注意：答案中不可以包含重复的三元组。 例如，给定数组 nums=[−1,0,1,2,−1,−4]nums=[-1,0,1,2,-1,-4]nums=[−1,0,1,2,−1,−4]，满足要求的三元组集合为[[−1,0,1]，[−1,−1
js算法--力扣-两数之和
丑小鸭变黑天鹅的博客
12-13 1859
两数之和一、算法描述二、解题思路 一、算法描述 二、解题思路 首先说明我的性能一般的思路，下面会介绍大神的解题思路 看一下，我写的代码 我的思路比较暴力 直接遍历传进来的数组，最外层从第0个开始循环遍历，嵌套的一层，从后往前遍历（但是除了自身），如果发现两个数字相加等于targe，就返回这两个数在数组中的下标。 举个例子，现在给了一个数组 [2,7,11,15], 然后target是9， 那么最终答案应该是返回[0,1] 第一步：i=0,j=3 ,nums[0]+nums[3] !== target 第
Python算法题源代码-LeetCode(力扣)-腐烂的橘子
02-22
在给定的 m x n 网格 grid 中，每个单元格可以有以下三个值之一： 值 0 代表空单元格；值 1 代表新鲜橘子；值 2 代表腐烂的橘子。 每分钟，腐烂的橘子 周围 4 个方向上相邻 的新鲜橘子都会腐烂。 返回 直到...
力扣：15三数之和（python）（csdn）————程序.pdf
12-05
该题目是力扣（LeetCode）上的第15题，名为“三数之和”（Three Sum）。题目要求在一个整数数组nums中找到所有和为0的三个元素的组合。提供的解决方案是用Python语言实现的，主要通过统计数组中每个数字出现的次数，...
力扣LeetCode第15题三数之和
weixin_44061444的博客
04-19 289
力扣LeetCode第15题三数之和
LeetCode 15题：数字序列三数之和为0——Python与C语言
weixin_73699630的博客
07-20 747
要自己不断思考，然后学习别人的想法与思维，这样可以认识到自己的不足，也能让自己获得一些额外知识。
力扣：三数之和
狗子的学习笔记
11-26 546
给定一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？找出所有满足条件且不重复的三元组。 注意：答案中不可以包含重复的三元组。 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/3sum 例如, 给定数组 nums = [-1, 0, 1, 2, -1, -4]，...
力扣第15题-三数之和(JavaScript语言)
qq_39417912的博客
02-23 310
思路(双指针) （ps：这是目前为止做的最难的题目。细节太多，坑太多。。。） 三重循环超时，坑也多。 先将数组排好序。观察要使三数加起来等于0，第一个数a固定好，另外两个数b和c呈现此起彼伏的规则，b和c的查找可以双指针进行一次遍历即可。这样就将三重循环降为二重循环。 但是坑还是多。。。具体实现看代码。。。自己写真的会遇见各种坑。。。 代码 /** * @param {number[]} nums * @return {number[][]} */ var threeSum = function(nu
​力扣解法汇总15-三数之和
分享+记录
12-07 403
原题链接：力扣 描述： 给你一个包含 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] 输出：[] 来源：力扣（LeetCode） 链接：ht...
[力扣刷题]15. 三数之和【C语言】
m0_46184560的博客
03-25 1603
思路详解： 1.将数组从小到大排序 2.首先固定左边第i个数字，转换为两数求和问题 3.用双指针使得left=i+1,right=numSize-1; 4.移动左右指针，满足条件则保存起来，当left==right时，i++并执行第2步骤 难点：去除重复的三元组 1.如果固定的数字判断过后，相同，则跳过。 if(i>0&&nums[i]==nums[i-1]){ continue; } 2.同样，双指针指定的数字已经保存后相同，也跳过。 left
【leetcode】15.整数数组，三数之和为0
周洲 （Julie）
05-19 1262
打卡第1周 题目： 给定一个包含n个整数的数组nums，判断nums中是否存在三个元素a，b，c ，使得a + b + c =0 ？找出所有满足条件且不重复的三元组。 注意：答案中不可以包含重复的三元组。 例如, 给定数组 nums = [-1, 0, 1, 2, -1, -4]， 满足要求的三元组集合为： [ [-1, 0, 1], [-1, -1, 2] ]...
力扣15题：三数之和Java解法 逐行精讲 【排序+双指针】
超哥的博客
08-09 510
题目描述：给你一个包含 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] 输出：[] 解决方案：排序+双指针法 难点 本题目的难点，在于如何去重，利用排序+双指.
力扣15.三数之和(
LNsupermali的博客
11-27 530
力扣15.三数之和(
力扣第三题 java
最新发布
07-04
力扣（LeetCode）是一个非常受欢迎的在线算法练习平台，其第3题是经典的“两数之和”，题目英文标题为 "Two Sum"。这是一个简单的数组操作问题，目标是给定一个整数数组 nums 和一个目标值 target，找出数组中两个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值