【leetcode-双指针】两数之和/三数之和/四数之和

最新推荐文章于 2022-02-28 21:25:49 发布

Hung武

最新推荐文章于 2022-02-28 21:25:49 发布

阅读量480

点赞数

分类专栏： leetcode

本文链接：https://blog.csdn.net/qq_31478771/article/details/114177285

版权

leetcode 专栏收录该内容

87 篇文章 1 订阅

订阅专栏

两数之和

给定一个整数数组 nums 和一个整数目标值 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]

暴力匹配

class Solution {
    public int[] twoSum(int[] nums, int target) {
        int length = nums.length;
        for (int i = 0; i < length; i++) {
            for (int j = i + 1; j < length; j++) {
                if (nums[i] + nums[j] == target) {
                    return new int[]{i, j};
                }
            }
        }
        return new int[0];
    }
}

哈希表

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

两数之和（输入有序数组）

给定一个已按照升序排列的整数数组 numbers ，请你从数组中找出两个数满足相加之和等于目标数 target 。
函数应该以长度为 2 的整数数组的形式返回这两个数的下标值。numbers 的下标从 1 开始计数，所以答案数组应当满足 1 <= answer[0] < answer[1] <= numbers.length 。
你可以假设每个输入只对应唯一的答案，而且你不可以重复使用相同的元素。

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

示例 2：
输入：numbers = [2,3,4], target = 6
输出：[1,3]

示例 3：
输入：numbers = [-1,0], target = -1
输出：[1,2]

二分查找

class Solution {
    public int[] twoSum(int[] numbers, int target) {
        int len = numbers.length;
        for (int i = 0; i < len; ++i) {
            int left = i + 1, right = len - 1;
            while (left <= right) {
                int mid = (right - left) / 2 + left;
                if (numbers[mid] == target - numbers[i])
                    return new int[]{i + 1, mid + 1};
                else if (numbers[mid] > target - numbers[i])
                    right = mid - 1;
                else
                    left = mid + 1;
            }
        }
        return new int[]{-1, -1};
    }
}

双指针

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

两数之和 IV - 输入 BST

给定一个二叉搜索树和一个目标结果，如果 BST 中存在两个元素且它们的和等于给定的目标结果，则返回 true。

案例 1:
输入:

Target = 9
输出: True

案例 2:
输入:

Target = 28
输出: False

中序遍历+双指针

class Solution {
    public boolean findTarget(TreeNode root, int k) {
        List<Integer> list = new ArrayList<>();
        inorder(list, root);
        if (list.size() < 2)
            return false;
        int i = 0, j = list.size() - 1;
        while (i < j) {
            int sum = list.get(i) + list.get(j);
            if (sum == k)
                return true;
            if (sum < k)
                i++;
            else
                j--;
        }
        return false;
    }

    private void inorder(List<Integer> list, TreeNode root) {
        if (root == null)
            return;
        inorder(list, root.left);
        list.add(root.val);
        inorder(list, root.right);
    }
}

递归查找

class Solution {
    private TreeNode root;
    public boolean findTarget(TreeNode root, int k) {
        this.root = root;
        return recursion(root, k);
    }

    private boolean recursion(TreeNode node, int k) {
        if (node == null)
            return false;
        
        int val = k - node.val;
        if (val == node.val) 
            return recursion(node.left, k) | recursion(node.right, k);
        else if (findSingleNum(root, val))
            return true;
        else
            return recursion(node.left, k) | recursion(node.right, k);
    }

    private boolean findSingleNum(TreeNode node, int k) {
        if (node == null)
            return false;

        if (node.val == k)
            return true;
        else if (node.val < k)
            return findSingleNum(node.right, k);
        else
            return findSingleNum(node.left, k);
    }
}

三数之和

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

双指针法

排序后通过双指针查找，注意去重。

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        int length = nums.length;
        List<List<Integer>> results = new ArrayList<List<Integer>>();
        if (length < 3) {
            return results;
        }
        
        Arrays.sort(nums);
        for (int i = 0; i < length; ++i) {
            if (nums[i] > 0) {
                break;
            }
            if (i > 0 && nums[i] == nums[i - 1]) {
                continue;
            }

            int j = i + 1;
            int k = length - 1;
            while (j < k) {
                int sum = nums[i] + nums[j] + nums[k];
                if (sum == 0) {
                    results.add(Arrays.asList(nums[i], nums[j],nums[k]));
                    while (j < k && nums[k] == nums[--k]);
                    while (j < k && nums[j] == nums[++j]);
                } else if (sum > 0) {
                    while (j < k && nums[k] == nums[--k]);
                } else {
                    while (j < k && nums[j] == nums[++j]);
                }
            } 
        }
        return results;
    }
}

最接近的三数之和

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

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

排序+双指针

class Solution {
    public int threeSumClosest(int[] nums, int target) {
        int length = nums.length;
        Arrays.sort(nums);

        int result = 100000;
        for (int i = 0; i < length; ++i) {
            if (i > 0 && nums[i] == nums[i - 1]) {
                continue;
            }

            int j = i + 1;
            int k = length - 1;
            while (j < k) {
                int sum = nums[i] + nums[j] + nums[k];
                if (sum == target) {
                    return target;
                }

                if (Math.abs(result - target) > Math.abs(sum - target)) {
                    result = sum;
                }

                if (sum > target) {
                    while (j < k && nums[k] == nums[--k]);
                } else {
                    while (j < k && nums[j] == nums[++j]);
                }
            } 
        }
        return result;
    }
}

四数之和

给定一个包含 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]
]

双指针法

四数之和的双指针解法是两层for循环nums[i] + nums[j]为确定值，依然是循环内有 p 和 q 作为双指针，找出nums[i] + nums[j] + nums[p] + nums[q] == target的情况

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        List<List<Integer>> results= new ArrayList<>();
        int len = nums.length;
        if (len < 4) {
            return results;
        }
        Arrays.sort(nums);
        for (int i = 0; i < len - 3; i++) {
            if ((i > 0 && nums[i] == nums[i - 1]) || (nums[i] + nums[len-3] + nums[len-2] + nums[len-1] < target)) {
                continue;
            }
            if (nums[i] + nums[i + 1] + nums[i + 2] + nums[i + 3] > target) {
                break;
            }
            for (int j = i + 1; j < len - 2; j++) {
                if ((j > i + 1 && nums[j] == nums[j - 1]) || (nums[i] + nums[j] + nums[len-2] + nums[len-1] < target)) {
                    continue;
                }
                if (nums[i] + nums[j] + nums[j + 1] + nums[j + 2] > target) {
                    break;
                }

                int p = j + 1, q = len - 1;
                while (p < q) {
                    int sum = nums[i] + nums[j] + nums[p] + nums[q];
                    if (sum == target) {
                        results.add(Arrays.asList(nums[i], nums[j], nums[p], nums[q]));
                        while (p < q && nums[q] == nums[--q]);
                        while (p < q && nums[p] == nums[++p]);
                    } else if (sum > target) {
                        int count = 0;
                        while (p < q && nums[q] == nums[--q]) {
                            count += 1;
                        }
                        System.out.println(count);
                    } else {
                        int count = 0;
                        while (p < q && nums[p] == nums[++p]) {
                            count += 1;
                        }
                        System.out.println(count);
                    }
                }
            }
        }
        return results;
    }
}