Leetcode_15_三数之和_双指针

九幽孤翎

已于 2022-02-26 14:32:31 修改

阅读量152

点赞数

CC 4.0 BY-SA版权

分类专栏： daily_algorithm 双指针文章标签： leetcode 算法数据结构

于 2021-04-28 15:15:01 首次发布

本文链接：https://blog.youkuaiyun.com/HDUCheater/article/details/116233046

daily_algorithm 同时被 2 个专栏收录

230 篇文章

订阅专栏

双指针

5 篇文章

订阅专栏

本文探讨了如何通过优化二分查找实现三数之和问题，从复杂度O(n^2)提升到线性时间复杂度O(n)。介绍了两种方法：无脑二分查找与双指针技巧的应用。

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

先来个无脑二分查找的做法
先排序
然后依此遍历第一个和第二个元素
用二分的方式寻找第三个元素
为了不重复，i或j每个循环后都会过滤掉后面相同的数

import java.util.Arrays;
import java.util.HashMap;
import java.util.List;

//leetcode submit region begin(Prohibit modification and deletion)
class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        Arrays.sort(nums);
        int len = nums.length;
        List<List<Integer>> ans = new ArrayList<List<Integer>>();
        for (int i = 0; i < len; i++) {
            for (int j = i + 1; j < len; j++) {
                int sum = nums[i] + nums[j];
                if (sum > 0) {
                    break;
                }
                int index = Arrays.binarySearch(nums, j + 1, len, -sum);
                if (index >= 0) {
                    ans.add(Arrays.asList(nums[i], nums[j], nums[index]));
                }
                while (j + 1 < len && nums[j] == nums[j + 1]) {
                    j++;
                }
            }
            while (i + 1 < len && nums[i] == nums[i + 1]) {
                i++;
            }
        }
        return ans;
    }
}
//leetcode submit region end(Prohibit modification and deletion)

可以优化的方案是第二重循环和第三重循环
第二个数和第三个数的和是恒定的，所以第二个数往右边动的时候，第三个数一定是往左动
就可以采用双指针的方法来将平方级的时间复杂度降至线性，使得总时间复杂度为O(n²)

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> ans = new ArrayList<>();
        Arrays.sort(nums);
        int len = nums.length;
        // i为第一个数的index
        for(int i = 0;i < len - 2;i++) {
            // k为第三个数的index
            // j为第二个数的index
            int k = len;
            for(int j = i + 1;j < k;j ++) {
                int sum = - nums[i] - nums[j];
                // 如果sum < 0，代表nums[j] > 0，所以nums[k]必然>0，必然不可能=sum
                if(sum < 0) {
                    break;
                }
                // 找到k的值
                int index = Arrays.binarySearch(nums, j + 1, k, sum);
                if(index >= 0) {
                    k = index;
                    ans.add(Arrays.asList(nums[i], nums[j], nums[k]));
                }
                while(j+1 <k && nums[j] == nums[j+1]) {
                    j++;
                }
            }
            while(i+1 <len - 2 && nums[i] == nums[i+1]) {
                i++;
            }
        }
        return ans;
    }
}
//leetcode submit region end(Prohibit modification and deletion)