Leetcode N数之和

最新推荐文章于 2025-03-27 19:39:11 发布
最新推荐文章于 2025-03-27 19:39:11 发布
阅读量447 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： Leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44645822/article/details/115730519
这篇博客主要探讨了LeetCode中与数之和相关的题目，包括两数、三数、四数之和的多种解法，涉及哈希映射、二分查找等算法，并提到了针对有序数组和BST的特定解决方案。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

题库

1 两数之和
15 三数之和
16 最接近的三数之和
18 四数之和
167两数之和-输入有序数组
170 两数之和-数据结构设计
259 较小的三数之和
371 两整数之和
633 平方数之和
653两数之和-输入BST
923三数之和的多种可能
1022 从根到叶的二进制数之和
1099 小于K的两数之和

模板

哈希map

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

二分

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> result = new LinkedList<>();
        // sort
        Arrays.sort(nums);
        // 3 foreach
        int n = nums.length;
        for (int i = 0; i < n; i++) {
            if (i > 0 && nums[i] == nums[i - 1]) continue;
            int t = -nums[i];
            int j = i + 1, k = n - 1;
            while (j < k) {
                if (nums[j] + nums[k] > t) {
                    k--;
                } else if (nums[j] + nums[k] < t) {
                    j++;
                } else {
                    // find
                    List<Integer> ans = new LinkedList<>();
                    ans.add(nums[i]);
                    ans.add(nums[j]);
                    ans.add(nums[k]);
                    result.add(ans);
                    // 去除临近相同的元素
                    while (j < k && nums[j] == nums[j + 1]) j++;
                    while (j < k && nums[k] == nums[k - 1]) k--;
                    j++;
                    k--;
                }
            }
        }
        return result;
    }
}

Nsums模板

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        Arrays.sort(nums);
        return nSumTarget(nums, 4, 0, target);
    }

    public List<List<Integer>> nSumTarget(int[] nums, int n, int start, int target){
        int sz = nums.length;
        List<List<Integer>> res = new ArrayList<>();
        if(n < 2 || sz < n){
            return res;
        }
        if(n == 2){
            int lo = start, hi = sz - 1;
            while(lo < hi){
                int sum = nums[lo] + nums[hi];
                int left = nums[lo], right = nums[hi];
                if(sum < target){
                    lo++;
                }else if(sum > target){
                    hi--;
                }else{
                    List<Integer> ans = new ArrayList<>();
                    ans.add(left);
                    ans.add(right);
                    res.add(ans);
                    while(lo < hi && nums[lo] == left) lo++;
                    while(lo < hi && nums[hi] == right) hi--;
                }
            }
        }else{
            for(int i = start; i < sz; i++){
                List<List<Integer>> sub = nSumTarget(nums, n - 1, i + 1, target - nums[i]);
                for(List<Integer> arr : sub){
                    arr.add(nums[i]);
                    res.add(arr);
                }
                while(i < sz - 1 && nums[i] == nums[i + 1]) i++;
            }
        }
        return res;
    }
}

树

class Solution {
    public int sumRootToLeaf(TreeNode root) {
        return dfs(root, 0);
    }

    private int dfs(TreeNode root, int sum){
        if(root == null) return 0;
        sum = 2 * sum + root.val;
        if(root.left == null && root.right == null){
            return sum;
        }
        return dfs(root.left, sum) + dfs(root.right, sum);
    }
}

题目

1 两数之和

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

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

15 三数之和

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

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        Arrays.sort(nums);
        List<List<Integer>> res = new ArrayList<>();
        int target = 0;
        int n = nums.length;
        for(int i = 0; i < n; i++){
            List<List<Integer>> tuples = twoSumtarget(nums, i + 1, target - nums[i]);
            for(List<Integer> tuple : tuples){
                tuple.add(nums[i]);
                res.add(tuple);
            }
            while(i < n - 1 && nums[i] == nums[i + 1]){
                i++;
            }
        }
        return res;
    }

    public List<List<Integer>> twoSumtarget(int[] nums, int start, int target){
        int lo = start, hi = nums.length - 1;
        List<List<Integer>> res = new ArrayList<>();
        while(lo < hi){
            int sum = nums[lo] + nums[hi];
            int left = nums[lo], right = nums[hi];
            if(sum < target){
                lo++;
            }else if(sum > target){
                hi--;
            }else{
                List<Integer> ans = new ArrayList<>();
                ans.add(left);
                ans.add(right);
                res.add(ans);
                while(lo < hi && nums[lo] == left) lo++;
                while(lo < hi && nums[hi] == right) hi--;
            }
        }
        return res;
    }
}
//时间复杂度O(n2)

// class Solution {
//     public List<List<Integer>> threeSum(int[] nums) {
//         List<List<Integer>> result = new LinkedList<>();
//         // sort
//         Arrays.sort(nums);
//         // 3 foreach
//         int n = nums.length;
//         for (int i = 0; i < n; i++) {
//             if (i > 0 && nums[i] == nums[i - 1]) continue;
//             int t = -nums[i];
//             int j = i + 1, k = n - 1;
//             while (j < k) {
//                 if (nums[j] + nums[k] > t) {
//                     k--;
//                 } else if (nums[j] + nums[k] < t) {
//                     j++;
//                 } else {
//                     // find
//                     List<Integer> ans = new LinkedList<>();
//                     ans.add(nums[i]);
//                     ans.add(nums[j]);
//                     ans.add(nums[k]);
//                     result.add(ans);
//                     // 去除临近相同的元素
//                     while (j < k && nums[j] == nums[j + 1]) j++;
//                     while (j < k && nums[k] == nums[k - 1]) k--;
//                     j++;
//                     k--;
//                 }
//             }
//         }
//         return result;
//     }
// }

16 最接近的三数之和

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

class Solution {
    public int threeSumClosest(int[] nums, int target) {
        // 排序
        Arrays.sort(nums);
        int closestNum = nums[0] + nums[1] + nums[2];
        for (int i = 0; i < nums.length - 2; i++) {
            int l = i + 1, r = nums.length - 1;
            while (l < r){
                int threeSum = nums[l] + nums[r] + nums[i];
                if (Math.abs(threeSum - target) < Math.abs(closestNum - target)) {
                    closestNum = threeSum;
                }
                if (threeSum > target) {
                    r--;
                } else if (threeSum < target) {
                    l++;
                } else {
                    // 如果已经等于target的话, 肯定是最接近的
                    return target;
                }

            }

        }
        return closestNum;
    }
}

18 四数之和

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

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        Arrays.sort(nums);
        return nSumTarget(nums, 4, 0, target);
    }

    public List<List<Integer>> nSumTarget(int[] nums, int n, int start, int target){
        int sz = nums.length;
        List<List<Integer>> res = new ArrayList<>();
        if(n < 2 || sz < n){
            return res;
        }
        if(n == 2){
            int lo = start, hi = sz - 1;
            while(lo < hi){
                int sum = nums[lo] + nums[hi];
                int left = nums[lo], right = nums[hi];
                if(sum < target){
                    lo++;
                }else if(sum > target){
                    hi--;
                }else{
                    List<Integer> ans = new ArrayList<>();
                    ans.add(left);
                    ans.add(right);
                    res.add(ans);
                    while(lo < hi && nums[lo] == left) lo++;
                    while(lo < hi && nums[hi] == right) hi--;
                }
            }
        }else{
            for(int i = start; i < sz; i++){
                List<List<Integer>> sub = nSumTarget(nums, n - 1, i + 1, target - nums[i]);
                for(List<Integer> arr : sub){
                    arr.add(nums[i]);
                    res.add(arr);
                }
                while(i < sz - 1 && nums[i] == nums[i + 1]) i++;
            }
        }
        return res;
    }
}

// public List<List<Integer>> fourSum(int[] nums, int target) {
//         //排序+双指针
//         Arrays.sort(nums);
//         List<List<Integer>> res = new ArrayList<>();
//         if(nums==null || nums.length<=3){
//             return res;
//         }
//         int len = nums.length;
//         for(int i = 0;i<len;i++){
//             if(i-1>=0 && nums[i]==nums[i-1]){
//                 continue;
//             }
//             for(int j=i+1;j<len;j++){
//                 if(j-1>=i+1 && nums[j-1]==nums[j]){
//                     continue;
//                 }
//                 int tr = target - nums[i] - nums[j];
//                 int left = j+1,right = len-1;
//                 while(left<right){
//                     if(nums[left]+nums[right]==tr){
//                         List<Integer> tp = new ArrayList<>();
//                         tp.add(nums[i]);
//                         tp.add(nums[j]);
//                         tp.add(nums[left]);
//                         tp.add(nums[right]);
//                         res.add(tp);
//                         while(left<right && nums[left]==nums[++left]);
//                         while(left<right && nums[right]==nums[--right]);
//                     }else if(nums[left]+nums[right]>tr){
//                         right--;
//                     }else{
//                         left++;
//                     }
//                 }
//             }
//         }
//         return res;
//     }

167两数之和-输入有序数组

输入：numbers = [2,7,11,15], target = 9
输出：[1,2]
解释：2 与 7 之和等于目标数 9 。因此 index1 = 1, index2 = 2 。

class Solution {
    public int[] twoSum(int[] numbers, int target) {
        if(numbers == null) return null;
        int i = 0, j = numbers.length - 1;
        while(i < j){
            int sum = numbers[i] + numbers[j];
            if(sum == target){
                return new int []{i+1,j+1};
            }else if(sum < target){
                i++;
            }else{
                j--;
            }
        }
        return new int[]{-1,-1};
    }
}

170 两数之和-数据结构设计

输入：
["TwoSum", "add", "add", "add", "find", "find"]
[[], [1], [3], [5], [4], [7]]
输出：
[null, null, null, null, true, false]

解释：
TwoSum twoSum = new TwoSum();
twoSum.add(1);   // [] --> [1]
twoSum.add(3);   // [1] --> [1,3]
twoSum.add(5);   // [1,3] --> [1,3,5]
twoSum.find(4);  // 1 + 3 = 4，返回 true
twoSum.find(7);  // 没有两个整数加起来等于 7 ，返回 false

import java.util.Collections;

class TwoSum {
  private ArrayList<Integer> nums;

  private Map<Integer, Integer> freq= new HashMap<>();

  /** Initialize your data structure here. */
  public TwoSum() {
    this.nums = new ArrayList<Integer>();
  }

  /** Add the number to an internal data structure.. */
  public void add(int number) {
    freq.put(number, freq.getOrDefault(number, 0) + 1);
  }

  /** Find if there exists any pair of numbers which sum is equal to the value. */
  public boolean find(int value) {
      for(Integer key : freq.keySet()){
          int other = value - key;
          if(other == key && freq.get(key) > 1){
              return true;
          }
          if(other != key && freq.containsKey(other)){
              return true;
          }
      }
      return false;
  }
}

/**
 * Your TwoSum object will be instantiated and called as such:
 * TwoSum obj = new TwoSum();
 * obj.add(number);
 * boolean param_2 = obj.find(value);
 */

259 较小的三数之和

输入: nums = [-2,0,1,3], target = 2
输出: 2 
解释: 因为一共有两个三元组满足累加和小于 2:
     [-2,0,1]
     [-2,0,3]

class Solution {
    public int threeSumSmaller(int[] nums, int target) {
        // 排序
        Arrays.sort(nums);
        int c = 0;
        for (int i = 0; i < nums.length - 2; i++) {
            int l = i + 1, r = nums.length - 1;
            while (l < r){
                int threeSum = nums[l] + nums[r] + nums[i];
                if (threeSum >= target) {
                    r--;
                } else if (threeSum < target) {
                    c += r - l;
                    l++;
                }
            }
        }
        return c;
    }
}

371 两整数之和

不使用运算符 + 和 - ，计算两整数a 、b 之和。

示例 1:
输入: a = 1, b = 2
输出: 3

class Solution {
    public int getSum(int a, int b) {
        return b == 0 ? a : getSum((a ^ b), (a & b) << 1);
    }
}

633 平方数之和

给定一个非负整数 c ，你要判断是否存在两个整数 a 和 b，使得 a2 + b2 = c 。

输入：c = 5
输出：true
解释：1 * 1 + 2 * 2 = 5

class Solution {
    public boolean judgeSquareSum(int target) {
        if(target < 0) return false;
        int i = 0,j = (int) Math.sqrt(target);
        while(i <= j){
            int powSum = i * i + j * j;
            if(powSum == target){
                return true;
            }else if(powSum > target){
                j--;
            }else{
                i++;
            }
        }
        return false;
    }
}

653两数之和-输入BST

输入: 
    5
   / \
  3   6
 / \   \
2   4   7

Target = 9

输出: True

public class Solution {
    public boolean findTarget(TreeNode root, int k) {
        List < Integer > list = new ArrayList();
        inorder(root, list);
        int l = 0, r = list.size() - 1;
        while (l < r) {
            int sum = list.get(l) + list.get(r);
            if (sum == k)
                return true;
            if (sum < k)
                l++;
            else
                r--;
        }
        return false;
    }
    public void inorder(TreeNode root, List < Integer > list) {
        if (root == null)
            return;
        inorder(root.left, list);
        list.add(root.val);
        inorder(root.right, list);
    }
}

923三数之和的多种可能

输入：A = [1,1,2,2,3,3,4,4,5,5], target = 8
输出：20
解释：
按值枚举（A[i]，A[j]，A[k]）：
(1, 2, 5) 出现 8 次；
(1, 3, 4) 出现 8 次；
(2, 2, 4) 出现 2 次；
(2, 3, 3) 出现 2 次。

class Solution {
    public int threeSumMulti(int[] A, int target) {
        int ret = 0, N = A.length;
        int mod=1000000007;
        Arrays.sort(A);
        for (int i = 0; i < N - 2; i++) {
            if (A[i] + A[i + 1] + A[i + 2] > target || A[i] + A[N - 2] + A[N - 1] < target) continue;  // 减枝
            int l = i + 1, r = N - 1;
            while (l < r) {
                int sum = A[i] + A[l] + A[r];
                if (sum < target) l++;
                else if (sum > target) r--;
                else {
                    if (A[l] == A[r]) { // 如果后两个数相同，则组合数为 C(len, 2)
                        int len = r - l + 1;
                        ret  = (ret + len * (len - 1) / 2) % mod;
                        break;
                    }
                    // 如果后两个数不同，且各自个数分为为lcnt, rcnt，则组合数为lcnt * rcnt
                    int lcnt = 1, rcnt = 1;
                    while (l + 1 < r && A[l + 1] == A[l]) 
                    {
                        l++; lcnt++;
                    }
                    while (r - 1 > l && A[r - 1] == A[r]){
                        r--; rcnt++;
                    }
                    l++; r--;
                    ret = (ret + lcnt * rcnt) % mod;
                }
            }
        }
        return ret;
    }
}

1022 从根到叶的二进制数之和

输入：root = [1,0,1,0,1,0,1]
输出：22
解释：(100) + (101) + (110) + (111) = 4 + 5 + 6 + 7 = 22

class Solution {
    public int sumRootToLeaf(TreeNode root) {
        return dfs(root, 0);
    }

    private int dfs(TreeNode root, int sum){
        if(root == null) return 0;
        sum = 2 * sum + root.val;
        if(root.left == null && root.right == null){
            return sum;
        }
        return dfs(root.left, sum) + dfs(root.right, sum);
    }
}

1099 小于K的两数之和

输入：nums = [34,23,1,24,75,33,54,8], k = 60
输出：58
解释：
34 和 24 相加得到 58，58 小于 60，满足题意。

class Solution {
   public int twoSumLessThanK(int[] A, int k) {
       Arrays.sort(A);
       int l = 0, r = A.length - 1;
       int result = Integer.MIN_VALUE;
       while (l < r) {
           if (A[l] + A[r] >= k) {
               r--;
           } else {
               result = Math.max(result, A[l] + A[r]);
               l++;
           }
       }
       return result == Integer.MIN_VALUE ? -1 : result;
   }
}
Leetcode---N数之和（两数之和、三数之和、四数之和的延伸,C++）
tox33的博客
03-07 926
Leetcode---N数之和（C++） （两数之和、三数之和、四数之和的延伸） N数之和问题的解决，参考别人的Python思路，使用C++进行了实现，实测AC，方便大家交流参考。 class Solution { public: vector&lt;vector&lt;int&gt;&gt; fourSum(vector&lt;int&gt;&amp; nums, int tar...
【leetcode】【题目小结】n数之和
lemonade13的博客
08-20 614
1. 2数之和 无序数组，找和为target的2个数字，返回下标。 解法：hash表记录之前遇到的数字，表中不存在互补的则继续向后找。 2. 2数之和-有序数组 有序数组，找和为target的2个数字。 解法：头尾双指针 3. 在BST上的2数之和 数据用BST形式储存。 解法1:BST中序遍历输出为有序数组，做法转为2。 解法2:hash表记录已遍历内容，做法类似1。 解法3:BST上的递归，看作从中间向两端的双指针。 4. 2数之和小于target 找出和小于t...
算法：两数之和
布里渊区
08-18 209
https://leetcode-cn.com/problems/two-sum/ 给定一个整数数组 nums和一个整数目标值 target，请你在该数组中找出 和为目标值 target的那两个整数，并返回它们的数组下标。 你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。 你可以按任意顺序返回答案。 /** * @param {number[]} nums * @param {number} target * @return {number[]} ...
leetcode笔记1—— “N数之和”类题
Blateyang的博客
02-01 1224
leetcode笔记1—— “N数之和”类题 相关题目 #1 两数之和 #15 三数之和 #18 四数之和 以三数之和为例： 给定一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？找出所有满足条件且不重复的三元组。 示例： 例如, 给定数组 nums = [-1, 0, 1, 2, -1, -4]， 满足要求的三元组集合为...
LeetCode 之 n 个数之和（Sum n）
DoubleFJ の Blog
11-19 5852
LeetCode 中有好几道题是求数字之和的，有 Sum 2、Sum 3 和 Sum 4 等。求和这种情况在我们实际开发中也是经常会遇到的，在这不妨拿出来我们把这归并到一起来说说。 无非就是数组中几个数字求和比较是否为目标值。且大多结果中是不能有重复的值。 大致我说下这个题意： 给定一个包含 m 个整数的数组 nums 和一个目标值 target，判断 nums 中是否存在 n 个元素，使得这 n...
LeetCode 四数之和
12-22
LeetCode 三数之和 题目 给定一个包含 n 个整数的数组 nums 和一个目标值 target，判断 nums 中是否存在四个元素 a，b，c 和 d ，使得 a + b + c + d 的值与 target 相等？找出所有满足条件且不重复的四元组。 注意...
Leetcode 四数之和
最新发布
985小菜鸡
03-27 1007
排序数组：便于双指针和去重操作双指针：利用有序数组快速找到两数之和去重处理：防止重复答案（i、j、left、right层层去重）long 类型：规避溢出风险//首先进行排序i < n - 3;i++) { //先确定第一个数//进行去重//然后确定第二个数j < n - 2;j++) {//去重//此时, 前两个数都确定了,然后开始初始化双指针//先计算四数之和//继续去重。
LeetCode 三数之和
12-22
文章目录三数之和题目解题思路图解代码实现实现结果 三数之和 题目来源：https://leetcode-cn.com/problems/3sum 题目 给定一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c...
两数之和—leetcode（Java版）
2201_76067045的博客
05-05 869
两数之和—leetcode
C语言实现LeetCode两数之和问题解答
在讨论"LeetCode 两数之和C语言源码"之前，我们首先需要了解C语言的基本知识。C语言是一种广泛使用的计算机编程语言，它是由Dennis Ritchie在1972年在AT&T的贝尔实验室为了实现UNIX操作系统而设计的。C语言以其强大...
Leetcode之n数之和
weixin_47382783的博客
04-14 1114
目录 1、两数之和 2、两数之和Ⅱ：输入有序数组 3、三数之和 4、四数之和 5、四数之和Ⅱ 6、总结 （1）HashMap （2）分治+HashMap （3）双指针 （4）场景总结 1、两数之和 来源：Leetcode 1：两数之和 题目描述： 给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。 你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复.
n数之和 Leetcode
qq_43344375的博客
10-10 716
n数之和一、两数之和( LC 1)1.题目2.思路3.题解二、三数之和(等于target）(LC 15)1.题目2.思路3.题解三、三数之和(最接近target）(LC 16)1.题目2.思路3.题解四、四数之和 (LC 18)1.题目2.思路3.题解五、四数之和（不同数组）(LC 454)1.题目2.思路3.题解六、总结 一、两数之和( LC 1) 1.题目 Given an array of integers nums and an integer target, return indices of t
2022-1-13 LeetCode N数之和（双指针+去重）
kkzzjx
01-13 336
一、两数之和（经典第一题） 暴力法 时间 O（n^2） 排序后双指针法 时间O(nlogn) 空间O（1） 哈希表法 时间O（n） 空间O（n） 这题的要求是在于会写哈希表法。 知识点有：unordered_map, find方法。（有一说一，不使用find方法想要写清楚的代码还是挺难的） class Solution { public: vector<int> twoSum(vector<int>& nums, int target) {
leetcode每日一题【Day10】——18. 四数之和
weixin_45366750的博客
08-26 292
题目：给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有和为 0 且不重复的三元组。 类型：找符合要求的三个数 思路：01-先把列表排序，第一个数nums[i]用for循环，剩下两个数在i后嵌套双指针的框架；02-在双指针的架构中，用while排除重复的情况，也就是while不合法就更新直到合法。 经验：（1）找一个数用二分，找两个数（无序用哈希，有序用指针），找三个数用排序后的遍历+指针；（2）在de..
LeetCode-N数之和类问题总结(双指针法)
much efforts, much luck
01-28 620
两数之和 给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那两个整数，并返回他们的数组下标。你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。 示例:给定 nums = [2, 7, 11, 15], target = 9。因为 nums[0] + nums[1] = 2 + 7 = 9 所以返回 [0, 1]。 分析：双指针法。 ...
LeetCode.N数之和
qq_39076073的博客
05-10 305
在 LeetCode 上，4Sum 就到头了，但是在写 3Sum 和 4Sum 的过程，实际上是遵循相同的模式的。 那么，如果求 100Sum 问题，怎么办呢？统一出一个 nSum 函数：实际上就是把之前的题目解法合并起来了，n == 2 时是 twoSum 的双指针解法，n > 2 时就是穷举第一个数字，然后递归调用计算 (n-1)Sum，组装答案。 需要注意的是，调用这个 nSum 函数之前一定要先给 nums 数组排序，因为 nSum 是一个递归函数，如果在 nSum 函数里调用排序函数，那么每
【Leetcode】N数之和总结篇（双指针法）
这是简介
02-03 734
双指针求解N数之和！
leetCode--n数之和--哈希表/双指针
aeipyuan
04-14 244
n数之和 两数之和 给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那两个整数，并返回他们的数组下标。不能重复利用这个数组中同样的元素。 题目链接：https://leetcode-cn.com/problems/two-sum/ 示例： 给定 nums = [2, 7, 11, 15], target = 9 因为 nums[0] + nums[1] = 2...
【N数之和】leetcode 1,15,18题 题解
qq_38702445的博客
05-21 502
两数、三数、四数之和的通解三数之和四数之和      leetcode上面的第一道题就是两数之和，这道题虽然很简单但是也蕴含着不少算法知识。但后面又接二连三地出现了“三数之和”、“四数之和”，便有聪明的同学想：难道就没有什么通解吗？事实上是有的，这也是本文的目的。 解这类问题的原则有以下两条 1，排序 2，使用hashSet检验重复 第一条就不用说了，如果不...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值