3
无重复字符的最长子串
中等高频
146
LRU缓存机制
中等高频
206
反转链表
简单高频
215
数组中的第K个最大元素
中等高频
25
K个一组翻转链表
困难高频
15
三数之和
中等高频
53
最大子数组和
中等高频
912
排序数组
中等高频
21
合并两个有序链表
简单高频
5
最长回文子串
中等高频
200
岛屿数量
中等高频
33
搜索旋转排序数组
中等高频
46
全排列
中等高频
88
合并两个有序数组
简单高频
20
有效的括号
简单高频
121
买卖股票的最佳时机
简单高频
236
二叉树的最近公共祖先
中等高频
92
反转链表 II
中等高频
103
二叉树的锯齿形层序遍历
中等高频
141
环形链表
简单高频
300
最长上升子序列
中等高频
54
螺旋矩阵
中等高频
143
重排链表
中等高频
23
合并K个排序链表
困难高频
415
字符串相加
简单高频
56
合并区间
中等高频
160
相交链表
简单高频
42
接雨水
困难高频
1143
最长公共子序列
中等高频
124
二叉树中的最大路径和
困难高频
93
复原IP地址
中等高频
82
删除排序链表中的重复元素 II
中等中频
19
删除链表的倒数第N个节点
中等中频
142
环形链表 II
中等中频
4
寻找两个正序数组的中位数
困难中频
199
二叉树的右视图
中等中频
102
二叉树的层序遍历
中等中频
165
比较版本号
中等中频
704
二分查找
简单中频
232
用栈实现队列
简单中频
22
括号生成
中等中频
94
二叉树的中序遍历
简单中频
239
滑动窗口最大值
困难中频
69
x 的平方根
简单中频
148
排序链表
中等中频
32
最长有效括号
困难中频
31
下一个排列
中等中频
8
字符串转换整数 (atoi)
中等中频
70
爬楼梯
简单中频
322
零钱兑换
中等中频
43
字符串相乘
中等中频
76
最小覆盖子串
困难中频
41
缺失的第一个正数
困难中频
105
从前序与中序遍历序列构造二叉树
中等中频
78
子集
中等中频
151
翻转字符串里的单词
中等中频
155
最小栈
简单中频
34
在排序数组中查找元素的第一个和最后一个位置
中等中频
394
字符串解码
中等中频
101
对称二叉树
简单中频
39
组合总和
中等中频
470
用 Rand7() 实现 Rand10()
中等低频
64
最小路径和
中等低频
104
二叉树的最大深度
简单低频
110
平衡二叉树
简单低频
144
二叉树的前序遍历
简单低频
48
旋转图像
中等低频
234
回文链表
简单低频
695
岛屿的最大面积
中等低频
122
买卖股票的最佳时机 II
简单低频
240
搜索二维矩阵 II
中等低频
221
最大正方形
中等低频
98
验证二叉搜索树
中等低频
543
二叉树的直径
简单低频
14
最长公共前缀
简单低频
179
最大数
中等低频
113
路径总和 II
中等低频
662
二叉树最大宽度
中等低频
62
不同路径
中等低频
198
打家劫舍
中等低频
152
乘积最大子数组
中等低频
560
和为K的子数组
中等低频
112
路径总和
简单低频
226
翻转二叉树
简单低频
209
长度最小的子数组
中等低频
227
基本计算器 II
中等低频
169
多数元素
简单低频
24
两两交换链表中的节点
中等低频
139
单词拆分
中等低频
283
移动零
简单低频
718
最长重复子数组
中等低频
1
两数之和
简单低频
2
两数相加
中等低频
#15
中等
高频
双指针

三数之和

这是一道围绕数组、双指针、排序展开的高频练习。建议先掌握「双指针」这套写法,再结合下方步骤讲解理解状态维护、边界处理和复杂度取舍。

数组
双指针
排序

题目分析

给你一个整数数组,要求找出所有和为 0 的三元组。

每个三元组里的三个位置必须不同,而且结果里不能有重复组合。

比如在 [-1, 0, 1, 2, -1, -4] 中,符合条件的答案有 [-1, -1, 2][-1, 0, 1]

一句话概括:

从数组里找出所有不重复的三元组,让它们的和等于 0

接下来怎么看推荐代码: 带着这个理解再看推荐代码时,重点观察这条主线:先排序,再固定第一个数,用左右双指针在后面寻找和为 0 的另外两个数。

推荐代码

推荐解法:双指针
时间复杂度: O(n^2)
空间复杂度: O(1)
核心思路: 先排序,再固定第一个数,用左右双指针在后面寻找和为 0 的另外两个数。
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        int n = nums.length;
        Arrays.sort(nums);
        List<List<Integer>> ans = new ArrayList<List<Integer>>();
        // 枚举 a
        for (int first = 0; first < n; ++first) {
            // 需要和上一次枚举的数不相同
            if (first > 0 && nums[first] == nums[first - 1]) {
                continue;
            }
            // c 对应的指针初始指向数组的最右端
            int third = n - 1;
            int target = -nums[first];
            // 枚举 b
            for (int second = first + 1; second < n; ++second) {
                // 需要和上一次枚举的数不相同
                if (second > first + 1 && nums[second] == nums[second - 1]) {
                    continue;
                }
                // 需要保证 b 的指针在 c 的指针的左侧
                while (second < third && nums[second] + nums[third] > target) {
                    --third;
                }
                // 如果指针重合,随着 b 后续的增加
                // 就不会有满足 a+b+c=0 并且 b<c 的 c 了,可以退出循环
                if (second == third) {
                    break;
                }
                if (nums[second] + nums[third] == target) {
                    List<Integer> list = new ArrayList<Integer>();
                    list.add(nums[first]);
                    list.add(nums[second]);
                    list.add(nums[third]);
                    ans.add(list);
                }
            }
        }
        return ans;
    }
}

结构化讲解

面试时怎么讲

开场思路

这题我会先排序,然后固定第一个数,把剩下部分转成有序数组里的两数之和问题。

核心过程

  1. 先排序,让双指针具备单调移动的基础。
  2. 外层枚举第一个数 nums[i],并跳过重复的起点。
  3. 内层用 leftright 夹逼:和小了左移,大了右移,等于 0 就收集答案。
  4. 每次命中后继续跳过左右两侧的重复值,保证结果不重复。

复杂度总结

时间复杂度 O(n^2),空间复杂度 O(1),不计答案存储。

面试补一句:这题真正要记住的是“排序 + 去重”,不是只记住双指针三个分支。

核心思路

三数之和的关键有两层:先把数组排序,把问题变成“有序数组里找两数和”;再在遍历过程中主动跳过重复值,保证结果不重不漏。

步骤讲解

1

先排序,把搜索空间变成有序

排序后,三元组中的后两个数就可以用左右双指针夹逼,而不需要暴力枚举所有组合。

为什么这样做:双指针成立的前提是数组有序,这样和太大时右指针左移、和太小时左指针右移才有意义。
对应代码提示:Arrays.sort(nums);
2

依次固定第一个数

i 从左到右枚举三元组的第一个数,后面的两个数只在 i 右侧寻找。

为什么这样做:这样可以把三数之和稳定拆成“固定一个数 + 两数之和”的模板。
对应代码提示:for (int i = 0; i < nums.length - 2; i++) { ... }
3

左右夹逼寻找剩下两个数

left = i + 1right = n - 1,计算三数之和;过大就缩右边,过小就扩左边,正好为 0 就记录答案。

为什么这样做:排序后,每次移动一个指针都能明确让总和朝目标靠近。
对应代码提示:if (sum < 0) left++; else if (sum > 0) right--; else answer.add(...);
4

在外层和内层都跳过重复值

固定第一个数时要跳过和前一个相同的值;找到一组答案后,左右指针也要越过相同元素。

为什么这样做:题目要的是不重复三元组,重复值如果不处理,会得到多份相同答案。
对应代码提示:while (left < right && nums[left] == nums[left - 1]) left++;

易错点

没排序就直接双指针

数组无序时,左右移动无法稳定判断和会变大还是变小,双指针逻辑就失效了。

正确理解:必须先排序,再做固定一个数 + 双指针夹逼。

只跳过外层重复,没跳过内层重复

即使 i 不重复,leftright 也可能反复落在同样的值上,导致重复三元组。

正确理解:记录答案后,继续移动左右指针并跳过相邻重复元素。

把返回条件写成是否存在

这题要求返回所有不重复三元组,不是找到一组就结束。

正确理解:命中后先记录结果,再继续移动指针搜索后续答案。

复杂度与适用判断

时间复杂度:O(n^2)
空间复杂度:O(1)
比其他方案更好在哪里:比三重循环暴力枚举少了一层搜索,把复杂度从 O(n^3) 降到 O(n^2)
适用判断:题目涉及有序数组、多数求和和去重组合时,优先考虑排序后再做双指针。

额外提醒

  • 排序不是附属步骤,而是把问题降维成双指针模板的核心前提。
  • 三数之和最容易丢分的地方通常不是指针移动,而是去重细节。
动画演示仅在桌面端提供,移动端请优先阅读推荐代码与结构化讲解。