6. 15. 三数之和_三个数之和为6java-CSDN博客

本文链接：https://blog.csdn.net/zry15671554200/article/details/108746598

博客链接： Coding Lemon’s blog Java知识、面试总结、LeetCode题目解析等持续更新

题目描述

先来看题目：

给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，> b，c ，使得 a + b + c = 0 ？请你找出所有满足条件且不重复的三元组。
注意：答案中不可以包含重复的三元组。
示例：
给定数组 nums = [-1, 0, 1, 2, -1, -4]，
满足要求的三元组集合为：
[
[-1, 0, 1],
[-1, -1, 2]
]
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/3sum

解题思路一

一开始想到的思路与第5篇—两数之和的题解题思路类似，先将给定的数组按从大到小排序（利用快排），然后遍历数组nums，取当前元素nums[i]当做target元素，再遍历nums数组，取数组中的2个元素的相加的值等于nums[i]的相反数，则存入结果list中。代码如下：

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> list = new ArrayList<>();
        //先将nums从大到小排序
        quickSort(nums,0,nums.length-1);
	//遍历nums数组
        for (int i = 0; i < nums.length; i++) {
	    //取目标值target等于nums[i]的相反数
            int target = -nums[i];
            HashMap<Integer, Integer> hashMap = new HashMap<>();
	    //如果nums[i]与前一个值相等，则为重复数据，跳过该数
            if(i>0 && nums[i]==nums[i-1]) continue;
            int sign = Integer.MIN_VALUE;
            //遍历查找数组中从i+1到数组末尾是否有两个数相加等于target值，若有则nums[i]与这两个数相加则为0,即为所求结果
            for (int j = i+1; j < nums.length; j++) {
                int difference = target - nums[j];
            //这里做一个判定，判断其中一个数sign是否在本次查询中出现过，若出现过说明有重复数据，则不添加进list
                if(hashMap.containsKey(difference) && sign != difference){
                    List<Integer> arrList = new ArrayList<>();
                    arrList.add(nums[i]);
                    arrList.add(difference);
                    arrList.add(nums[j]);
                    list.add(arrList);
                    sign = difference;
                }
                hashMap.put(nums[j],j);
            }
        }
        return list;
    }

    //从大到小排列 快排
    public static int[] quickSort(int[] nums, int left, int right) {
        if (nums == null || nums.length == 0) {
            return null;
        }
        if (left > right) {
            return nums;
        }
        int start = left;
        int end = right;
        int key = nums[start];

        while (start<end){
            //从右往左
            while (start<end && nums[end]<=key){
                end--;
            }
            if(nums[end]>=key){
                int temp = nums[end];
                nums[end] = nums[start];
                nums[start] = temp;
            }
            //从左往右
            while (start<end && nums[start]>= key){
                start++;
            }
            if(nums[start]<=key){
                int temp = nums[end];
                nums[end] = nums[start];
                nums[start] = temp;
            }
        }

        if(start>left) quickSort(nums,left,start-1);
        if(end<right) quickSort(nums,end+1,right);

        return nums;
    }
}

提交到LeetCode结果如下：

结果惨淡…

解题思路二

使用双指针方法：

首先对数组进行排序，排序后固定一个数 nums[i]，再使用左右指针指向 nums[i]后面的两端，数字分别为 nums[L] 和 nums[R]，计算三个数的和 sum 判断是否满足为 0，满足则添加进结果集
如果 nums[i]大于 0，则三数之和必然无法等于 0，结束循环
如果 nums[i] == nums[i-1]，则说明该数字重复，会导致结果重复，所以应该跳过
当 sum == 0 时，nums[L] == nums[L+1]则会导致结果重复，应该跳过，L++
当 sums == 0 时，nums[R] == nums[R−1] 则会导致结果重复，应该跳过，R–
代码如下：

    public List<List<Integer>> threeSum(int[] nums){
        List<List<Integer>> ans = new ArrayList<>();
        if(nums==null)return ans;
        int len = nums.length;
        if(len<3)return ans;
        //排序
        Arrays.sort(nums);
        for (int i = 0; i < len; i++) {
            //如果当前元素大于0则右边的L和R肯定都大于0，之后的都不满足
            if(nums[i]>0){
                break;
            }
            //如果当前元素与前一个元素相等，则为重复解，跳过
            if(i>0&&nums[i]==nums[i-1])continue;
            //取i右边两端元素
            int L = i+1;
            int R=len-1;
            while(L<R){
                int sum = nums[i]+nums[L]+nums[R];
                if(sum==0){
                    ans.add(Arrays.asList(nums[i],nums[L],nums[R]));
                    //如果L和L+1的值相等，则为重复解，跳过L+1这个值
                    while (L<R&&nums[L]==nums[L+1])L++;
                    //如果R和R-1的值相等，则为重复解，跳过R-1这个值
                    while (L<R&&nums[R]==nums[R-1])R--;
                    L++;
                    R--;
                }else if(sum<0){
                    //如果sum<0，说明L这端值小了，取L+1的值再判断一次
                    L++;
                }else {
                    //如果sum>0,说明R的值大了，取R-1的值进行判断
                    R--;
                }
            }
        }
        return ans;
    }