双指针——两数之和，三数之和

山语山

于 2024-08-05 16:18:51 发布

阅读量1k

点赞数 7

文章标签：算法 java github leetcode

本文链接：https://blog.csdn.net/qq_43556680/article/details/140928088

版权

1.两数之和

给定一个整数数组 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 <= 10^4
-10^9 <= nums[i] <= 10^9
-10^9 <= target <= 10^9
只会存在一个有效答案

解题思路1：
「对撞双指针」
在数组的左右各有一个指针，向中间遍历。指针指向的两数和为s，
则s=nums[i]+nums[j]，判断s和target的大小：
s>target，则右指针向左移，j=j-1
s<target，则左指针向右移，j=j+1
s=target，返回[nums[i],nums[j]]

代码

var twoSum = function(nums, target) {
    let i = 0, j = nums.length - 1
    while(i < j) {
        s = nums[i] + nums[j]
        if(s > target) j--
        else if(s < target) i++
        else return [nums[i], nums[j]]
    }
};

解题思路2：
「使用Map查找」

我们先将数组中的元素item存储到Map中，然后在使用map[target-item]即可查看是否存在与item相匹配的数。

代码：

var twoSum = function(nums, target) {
  let map = {}
  nums.forEach((item) => map[item] = item)
  for (item of nums) {
    if(map[target-item]) return [item, map[target-item]]
  }
}

运行时间和内存消耗对比，先运行的双指针，所以上边是使用Map，下边是双指针。
在这里插入图片描述
双指针和Map对比

「分析」：

从时间复杂度来说，Map很明显花费了更多的时间，先遍历一遍元素生成Map，再遍历一遍访问Map，时间复杂度为O(2n)；双指针法两个指针向中间遍历，只需要遍历一次元素，时间复杂度为O(n)。
空间复杂度上来看，使用Map会额外创建O(n)的空间；双指针法创建两个指针，空间复杂度为O(2n)。

2.三数之和

给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请你返回所有和为 0 且不重复的三元组。

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

示例 1：

输入：nums = [-1,0,1,2,-1,-4]
输出：[[-1,-1,2],[-1,0,1]]
解释：
nums[0] + nums[1] + nums[2] = (-1) + 0 + 1 = 0 。
nums[1] + nums[2] + nums[4] = 0 + 1 + (-1) = 0 。
nums[0] + nums[3] + nums[4] = (-1) + 2 + (-1) = 0 。
不同的三元组是 [-1,0,1] 和 [-1,-1,2] 。
注意，输出的顺序和三元组的顺序并不重要。
示例 2：

输入：nums = [0,1,1]
输出：[]
解释：唯一可能的三元组和不为 0 。
示例 3：

输入：nums = [0,0,0]
输出：[[0,0,0]]
解释：唯一可能的三元组和为 0 。

解题思路：
「双指针法」

暴力解题需要三重循环，时间复杂度为O(n3)，而我们在代码中应该尽量避免这么多层循环，除非每层的数据特别少。

两数之和，我们使用了双指针法，将O(n2)的时间复杂度降低到了O(n)，在这个问题里，我们可以使用遍历+双指针，将原本O(n3)的时间复杂度降低到O(n2)。

双指针法的思路如下，先将数组排序，之后遍历元素，对于每个元素nums[i]，
在nums[i]~nums[nums.length-1]中使用双指针遍历，则s = nums[i] + nums[l] + nums[r]，然后判断s是否等于0。

我们之所以将数组排序，是因为可以得到一个好的跳出循环条件：**排序后，元素是升序的，
当nums[i]大于0的时候，后边的元素也肯定是大于0，s大于0，则可以跳出循环。
排序的时间复杂度为O(nLogn)，时间复杂度并不算高，当数据量很大的情况，肯定换来提前结束循环肯定是稳赚不赔。

代码：

var threeSum = function(nums) {
 let res = []
 if (nums.length < 3) return []
 nums.sort((a, b) => a - b)
 for(let i = 0; i < nums.length; i++) {
  if(nums[i] > 0) break
  if(i > 0 && nums[i] == nums[i - 1]) continue
  let l = i + 1, r = nums.length - 1
  while(l < r) {
   const s = nums[i] + nums[l] + nums[r]
   if(s == 0){
    res.push([nums[i], nums[l], nums[r]])
    while(l < r && nums[l] == nums[l+1]) l++
    while(l < r && nums[r] == nums[r-1]) r--
    l++
    r--
   } 
   else if (s < 0) l++
   else if (s > 0) r--
  }
 }
  return res
};

时间复杂度O(n2)，nums[i]遍历O(n)，nums[l] + nums[r]遍历O(n)，越到后边，每层遍历的次数越少，总的遍历过程呈现一个倒三角的过程。

3.最接近的三数之和

给你一个长度为 n 的整数数组 nums 和一个目标值 target。请你从 nums 中选出三个整数，使它们的和与 target 最接近。

返回这三个数的和。

假定每组输入只存在恰好一个解。

示例 1：

输入：nums = [-1,2,1,-4], target = 1
输出：2
解释：与 target 最接近的和是 2 (-1 + 2 + 1 = 2) 。
示例 2：

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

解题思路：
给定一个包括 n 个整数的数组 nums 和 一个目标值 target。找出 nums 中的三个整数，使得它们的和
与 target 最接近。返回这三个数的和。假定每组输入只存在唯一答案。

例如，给定数组 nums = [-1，2，1，-4], 和 target = 1.

与 target 最接近的三个数的和为 2. (-1 + 2 + 1 = 2).

想法和上题类似，对于每个外层循环确定的数，内层循环双指针扫描数组右边剩下的数，每次得到的 3 个数都拿来更新一次结果。

代码：

class Solution {
public:
    int threeSumClosest(vector<int>& nums, int target) {
        sort(nums.begin(), nums.end());
        int size = nums.size();
        int start, end, res = nums[0], minn = 999999999, t;
        // 外层循环先确定一个数，之后双指针扫描数组右边剩下的数，对于每次找到的两个数，
        // 通过这 3 个数的和来更新结果
        for (int i = 0; i < size - 2; i++) {
            start = i + 1, end = size - 1;
            // 双指针扫描是否存在两个数等于 -nums[i] 
            while (start < end) {
                t = nums[start] + nums[end] + nums[i];
                // 当前 3 个数和等于 target
                if (t == target) {
                    res = t;
                    minn = 0;
                    start++;
                    end--;
                // 当前 3 个数和小于 target
                } else if (t < target) {
                    if (target - t < minn) {
                        minn = target - t;
                        res = t;
                    }
                    start++;
                // 当前 3 个数和大于于 target
                } else {
                    if (t - target < minn) {
                        minn = t - target;
                        res = t;
                    }
                    end--;
                }
            }
            // 去 i 重复，提高运行效率
            while (i < size - 2 && nums[i] == nums[i+1]) {
                i++;
            }
        }
        return res;
    }
};

4.四数之和

给你一个由 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]]

解题思路：
在题目中，从给定一个包含 n 个整数的数组 nums 和一个目标值 target，判断 nums 中是否存在四个元素 a，b，c 和 d ，使得 a + b + c + d 的值与 target 相等？找出所有满足条件且不重复的四元组。

注意：

答案中不可以包含重复的四元组。

示例：

给定数组 nums = [1, 0, -1, 0, -2, 2]，和 target = 0。

满足要求的四元组集合为：

[
 [-1,  0, 0, 1],
 [-2, -1, 1, 2],
 [-2,  0, 0, 2]
]

首先，将数组从小到大排序，之后先使用双层循环范围为（0 ~ size-3）的循环确定较小的两个数，剩下的两个数通过设定两个指针头尾扫描右边循环没有遍历倒的数的，在找到一个解之后，因为数组中的数字可能有重复，需要去重，同样的对于外面的双层循环中，在每一次循环末尾也需要判断去重。

代码：

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>> res;
        // 从小到大对数组进行排序
        sort(nums.begin(), nums.end());
        int size = nums.size();
        int curSum;
        int start, end;
        vector<int> save;
        // 留有最少两个最右边的数用于双指针扫描
        for (int i = 0; i < size - 3; i++) {
            for (int j = i + 1; j < size - 2; j++) {
                curSum = nums[i] + nums[j];
                start = j + 1, end = size - 1;
                // 双指针扫描
                while (start < end) {
                    // 找到一个解
                    if (nums[start] + nums[end] == target - curSum) {
                        save.clear();
                        save.push_back(nums[i]);
                        save.push_back(nums[j]);
                        save.push_back(nums[start]);
                        save.push_back(nums[end]);
                        res.push_back(save);
                        start++;
                        end--;
                        // 去 start 重复
                        while (start < end && nums[start] == nums[start-1]) {
                            start++;
                        }
                        // 去 end 重复
                        while (start < end && nums[end] == nums[end+1]) {
                            end--;
                        }
                    // 四数之和大于 target ，end 指针减一
                    } else if (nums[start] + nums[end] > target - curSum) {
                        end--;
                    // 四数之和小于 target ，start 指针加一
                    } else {
                        start++;
                    }
                }
                // 去 j 重复
                while (j < size - 2 && nums[j] == nums[j+1]) {
                    j++;
                }
            }
            // 去 i 重复
            while (i < size - 3 && nums[i] == nums[i+1]) {
                i++;
            }
        }
        return res;
    }
};