《leetcode》两数之和，三数之和，四数之和《双指针》

1. 两数之和

难度简单12203

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

示例 1：

输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

示例 2：

输入：nums = [3,2,4], target = 6
输出：[1,2]

示例 3：

输入：nums = [3,3], target = 6
输出：[0,1]

提示：

• 2 <= nums.length <= 104
• -109 <= nums[i] <= 109
• -109 <= target <= 109
• 只会存在一个有效答案

**进阶：**你可以想出一个时间复杂度小于 O(n2) 的算法吗？

代码：

class Solution {
    public int[] twoSum(int[] nums, int target) {
        //Map  O(n) O(n)
        Map<Integer, Integer> map = new HashMap<Integer, Integer>();
        for (int i = 0; i < nums.length; ++i) {
            if (map.containsKey(target - nums[i])) {
                return new int[]{map.get(target - nums[i]), i};
            }
           	map.put(nums[i], i);
        }
        return new int[0];
    }
}

15. 三数之和

难度中等3805

给你一个包含 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]
输出：[]

提示：

• 0 <= nums.length <= 3000
• -105 <= nums[i] <= 105

代码：

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>>list=new ArrayList<>();
        int n=nums.length;
        if(n<3)
            return list;
        Arrays.sort(nums);
        //O(n^2) 
        for(int i=0;i<n;i++)
        {
            //正序排列，nums[i]>0 nums[L]>0 nums[R]>0
            if(nums[i]>0||(i>0&&nums[i]==nums[i-1]))
                continue;
            int L=i+1;
            int R=n-1;
            while(L<R)
            {
                int sum=nums[L]+nums[R]+nums[i];
                //System.out.println(nums[i]+" "+nums[L]+" "+nums[R]);
                //System.out.println(i+" "+L+" "+R);
                if(sum==0)
                {
                    List<Integer> arr=new ArrayList<>();
                    arr.add(nums[i]);
                    arr.add(nums[L]);
                    arr.add(nums[R]);
                    list.add(arr);
                    
                   //保证不重复
                    while(L<R && nums[L]==nums[L+1] )//去重
                        L++;
                    while(L<R && nums[R]==nums[R-1])
                        R--;
                    L++;
                    R--;
                }else if(sum>0) R--;
                else L++;
            }
        }
        return list;

    }
}

18. 四数之和

难度中等962

给你一个由 n 个整数组成的数组 nums ，和一个目标值 target 。请你找出并返回满足下述全部条件且不重复的四元组 [nums[a], nums[b], nums[c], nums[d]] ：

• 0 <= a, b, c, d < n
• a、b、c 和 d 互不相同
• nums[a] + nums[b] + nums[c] + nums[d] == target

你可以按 任意顺序 返回答案 。

示例 1：

输入：nums = [1,0,-1,0,-2,2], target = 0
输出：[[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]

示例 2：

输入：nums = [2,2,2,2,2], target = 8
输出：[[2,2,2,2]]

提示：

• 1 <= nums.length <= 200
• -109 <= nums[i] <= 109
• -109 <= target <= 109

代码：

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        List<List<Integer>> re = new ArrayList<List<Integer>>(); // 定义一个返回值
        if(nums==null||nums.length<4) return re;
        Arrays.sort(nums);
        int n=nums.length;
        //保证有4个数
        for(int i=0;i<n-3;i++)
        {
            //去重
            if(i>0&&nums[i]==nums[i-1]) continue;
            //剪枝，获取当前最小值，如果当前最小值都大于target，那么后面也没有满足target的结果
            if(nums[i]+nums[i+1]+nums[i+2]+nums[i+3]>target) break;
            //当前值的最大组合值，如果小于target，返回值
            if(nums[i]+nums[n-3]+nums[n-2]+nums[n-1]<target) continue;

            for(int j=i+1;j<n-2;j++)
            {
                // 当j的值与前面的值相等时忽略
                if(j>i+1&&nums[j]==nums[j-1]) continue;

                //剪枝，获取当前最小值，如果当前最小值都大于target，那么后面也没有满足target的结果
                if(nums[i]+nums[j]+nums[i+2]+nums[i+3]>target) break;
                //当前值的最大组合值，如果小于target，返回值
                if(nums[i]+nums[j]+nums[n-2]+nums[n-1]<target) continue;

                int l=j+1,r=n-1;
                while(l<r)
                {
                    long sum=nums[i]+nums[j]+nums[l]+nums[r];
                    if(sum==target)
                    {
                        re.add(Arrays.asList(nums[i], nums[j], nums[l], nums[r]));
                        //去重
                        // left先+1之后,和它前面的left-1进行比较,若后+1,则和它后面的left+1进行比较
                        l++;
                        while (l < r && nums[l] == nums[l - 1]) l++;
                        r--;
                        while (l < r && nums[r] == nums[r + 1]) r--;
                        
                    }else if(sum>target)
                        r--;
                    else
                        l++;
                }
            }
        }
        return re;
    }
}