最接近的三数之和：排序+双指针解法详解与优化

乐知网孙敏·2026-09-03·阅读 22 GEO检测（免费）

最接近的三数之和双指针LeetCode

|难度：普通|阅读约 14 分钟

直接聊聊这道题

如果你刷过LeetCode，应该知道第15题是"三数之和"，而第16题就是它"最接近的三数之和"。很多人觉得，这不就是三数之和加一个"求最接近"的条件吗？难度应该差不多。但实际上，这道题在面试里被问到的频率很高，而且它和15题的思路上有一个关键差异：15题要求三数之和等于0，去重是第一优先级；而16题没有固定目标值，只有一个target，你需要在所有可能的三元组里找出"和与target差距最小"的那一个。这个 "没有确切相等值" 的设定，让判断逻辑和边界处理完全不一样了。

我当年第一次做这道题时，第一反应是三重循环暴力解，结果提交直接超时。后来看了题解才意识到，这题的经典解法是"排序 + 双指针"，而且它还藏着不少细节。这篇文章我会完整拆解这道题的思路、代码、优化点、边界case，以及我从这道题里总结出的双指针套路，希望能帮到正在刷题准备面试，或者刚开始接触双指针这类题型的你。这篇文章不是单纯贴一份答案，而是会把每一步为什么这么做、有哪些坑、怎么调试讲透。

1. 先看题目本质：为什么暴力解法会超时

1.1 题目到底在要求什么

给你一个整数数组 nums 和一个目标值 target，要求从数组里找出三个整数，让它们的和与 target 的差最小。返回这三个数的和，不需要返回具体是哪三个数。

题目示例通常在说一个意思：比如 nums = [-1, 2, 1, -4], target = 1，这里最接近1的三数之和是 (-1 + 2 + 1) = 2，距离是 |2 - 1| = 1，而 (-1 + 2 + -4) = -3 距离是4，(2 + 1 + -4) = -1 距离是2，所以答案是2。

注意这里的措辞："最接近"可能有多个解，但它只要求返回和的值，不要求列出所有组合。这意味着你不需要做"去重"处理，不会因为多个组合得到同样的和而产生重复输出。这一点比15题简单一点，但也仅此而已。

1.2 三重循环为什么不可行

如果完全不思考，直接上三重循环：

python复制def threeSumClosest(nums, target):
    n = len(nums)
    best = float('inf')
    for i in range(n):
        for j in range(i + 1, n):
            for k in range(j + 1, n):
                s = nums[i] + nums[j] + nums[k]
                if abs(s - target) < abs(best - target):
                    best = s
    return best

这段代码逻辑完全正确，但时间复杂度是 O(n^3)。当 n 是几百的时候还能跑，但LeetCode的数据范围通常是 3 <= nums.length <= 1000，1000的三次方是10亿，这个运算量在现代计算机上基本要跑好几秒甚至十几秒，必然超时。

这其实也引出一个程序员的基本素养：拿到题先分析一下数据范围，再决定算法的量级。不要一上来就写循环，先估算复杂度。LeetCode题的 n 上限几乎就是提示你用 O(n^2) 或更优的算法。

1.3 为什么双指针能把时间复杂度降下来

双指针的核心思想是：在一维数组的遍历中，通过两个指针的移动，把"两重遍历"压缩成"一重遍历"。但前提是数组必须有序。

当你固定一个数 nums[i]，剩下两个数 nums[left] 和 nums[right] 就可以在 i 后面的区间里用双指针查找。因为数组有序，如果当前的和太大，右指针左移可以让和变小；如果太小，左指针右移可以让和变大。这样每次移动指针后，都检查一次是否更接近target，整个过程不需要回退，因此每个 i 只需要 O(n) 的时间来扫描剩余区间。

总时间复杂度是 O(n * log n) 排序 + O(n^2) 双指针扫描，即 O(n^2)，这比 O(n^3) 好了整整一个量级。对于1000个元素，1000^2只有100万次操作，非常轻松。

需要模型API调用？免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。

2. 主体思路拆解：排序 + 双指针的运行逻辑

2.1 为什么必须先排序

双指针能工作的基础是数组有序。试想一个无序数组，你让左指针和右指针分别指向头尾，当三数之和小于target时，你只知道"需要更大的数"，但左指针向右移动能不能保证下一个数一定更大？不能，因为数组无序，左边可能是一个更大的数，也可能是一个更小的数。无序的情况下，移动指针没有任何方向性，算法就不成立。

所以第一步一定是 sort(nums.begin(), nums.end())。排序在这个问题里不只是一个预处理，它直接决定了后续双指针移动策略的正确性。排序本身时间复杂度是 O(n log n)，在 O(n^2) 面前可以忽略不记。

2.2 核心代码框架

先用C++写一个标准实现：

cpp复制class Solution {
public:
    int threeSumClosest(vector<int>& nums, int target) {
        sort(nums.begin(), nums.end());
        int n = nums.size();
        int best = 1e7; // 初始化为一个大数

        // 枚举第一个数
        for (int i = 0; i < n; ++i) {
            // 保证和上一个枚举的数不重复（可以不加，但能加速）
            if (i > 0 && nums[i] == nums[i - 1]) continue;

            int left = i + 1, right = n - 1;
            while (left < right) {
                int sum = nums[i] + nums[left] + nums[right];
                // 如果 sum 与 target 更接近，更新 best
                if (abs(sum - target) < abs(best - target)) {
                    best = sum;
                }

                if (sum == target) {
                    // 精确相等，直接返回，不可能更接近了
                    return target;
                } else if (sum < target) {
                    // 和太小，左指针右移，让和变大
                    int leftValue = nums[left];
                    while (left < right && nums[left] == leftValue) ++left;
                } else {
                    // 和太大，右指针左移，让和变小
                    int rightValue = nums[right];
                    while (left < right && nums[right] == rightValue) --right;
                }
            }
        }
        return best;
    }
};

这段代码看起来很短，但每一个分支都有讲究。我逐个拆开讲。

2.3 固定一个数，双指针扫描剩余区间

外层 for 循环枚举第一个数 nums[i]，这个 i 的取值范围是 [0, n-3]（至少留两个位置给left和right）。但代码里写成 i < n 也不会有问题，因为当 i >= n-2 时，left 初始等于 i+1 已经等于 n-1 或更大，left < right 不成立，内层循环直接跳过，不影响结果。

内层 while 循环中，left 从 i+1 开始，right 从最后一个元素开始，两个指针相向移动。每次计算三数之和，如果比当前最佳值更接近target，就更新 best。

这里有个小细节：best 初始值一定要设成一个"足够大"的数，但不要直接用 INT_MAX，因为后面可能出现 abs(best - target)，如果 best 是 INT_MAX 而 target 是负数，INT_MAX - (-1000) 会溢出，结果变成一个很小的负数，导致错误更新。我见过不少初学者在这里踩坑。直接用 1e7 或者 nums[0] + nums[1] + nums[2]（排序后前三个数的和）作为初始值都是安全的。

2.4 指针移动的核心逻辑：小了不行，大了也不行

当 sum < target，说明当前三个数的和还不够大，需要找一个更大的三数组合。如何变大？既然数组有序且 nums[left] <= nums[right]，那么把 left 右移，就换成一个更大的数，三数和必然增大；把 right 左移，三数和反而减小，方向反了。所以这里只能右移 left。

反过来，当 sum > target，说明和太大，要把和变小。此时右移 left 会让和更大，不能这样做；左移 right 会换成更小的数，让三数和变小，所以移动 right。

为什么每个固定 i 下，双指针只需要 O(n) 次扫描就能覆盖所有组合？因为 left 和 right 每次只有一个移动，且是相向而行，left 最多移动到 right-1，right 最多移动到 left+1，两个指针加起来最多移动 n 步。每一次移动对应一种 nums[left] + nums[right] 组合，不会漏掉，也不会重复。这种"每个组合都被访问一次，且总共只访问O(n)次"的性质，就是双指针的精髓。

2.5 为什么 `sum == target` 可以直接返回

这是一个很重要的剪枝。如果三数之和已经精确等于target，那距离就是0，这是理论最小值，不可能有比0更小的距离了。下面的搜索不可能找到比"距离0"更优的解，所以直接返回target即可。这个优化看起来不起眼，但在大规模随机数据下能节省不少时间，尤其是当数组里恰好存在和为target的三元组时。

3. 代码实现里的细节：版本与优化对比

3.1 Python版本实现

很多用Python刷题的朋友可能更习惯Python的写法。我把同样的逻辑用Python写一遍，注意Python的 abs 函数和索引操作和C++有一些差异：

python复制def three_sum_closest(nums, target):
    nums.sort()
    n = len(nums)
    best = float('inf')

    for i in range(n):
        if i > 0 and nums[i] == nums[i - 1]:
            continue

        left = i + 1
        right = n - 1
        while left < right:
            s = nums[i] + nums[left] + nums[right]
            if abs(s - target) < abs(best - target):
                best = s

            if s == target:
                return target
            elif s < target:
                left += 1
            else:
                right -= 1

    return best

注意Python版里我没有在 left += 1 后额外跳过重复元素，这是为了代码简洁。因为不跳过重复元素最多导致重复计算几次相同的和，对正确性没有影响，对性能影响也有限。但在C++版里我加了跳过，这两者在逻辑上是等价的。

3.2 C++版与Python版的差异分析

C++版和Python版在算法思想上完全一致，但有几个细微差别：

C++版在移动指针时用 while 跳过重复元素，Python版没有。这是因为C++追求极致性能，重复元素的跳过能减少循环次数。而在Python里，多一次赋值操作的开销可能比直接跳过更大，所以不跳也行。
C++版本的 best 初始化为 1e7，Python版本初始化为 float('inf')，都能防止溢出问题。
两者在 s < target 时都做了 left += 1，在 s > target 时都做了 right -= 1，这是核心逻辑，不能颠倒。

3.3 关于去重：这里的去重是性能优化，不是正确性要求

我再强调一下：第16题不需要去重，因为要求返回的是"和的值"，不是"三元组列表"。即使有两个不同的三元组得到相同的和，答案不会变。那这个 if (i > 0 && nums[i] == nums[i - 1]) continue 到底在干嘛？

它的作用是：当外层循环枚举到和前一个相同的 nums[i] 时，内层双指针扫描的范围和前一次完全相同（因为左边固定值一样），计算出的所有三数和也会重复，这白白浪费了 O(n) 的时间。跳过重复的 i 能让最坏情况下的时间复杂度更好，尤其是数组里大量重复元素时，性能提升很明显。所以它更多的是一个"不改变正确性的性能优化"。

实际测试中，我对比过有无这行代码的运行时间，在一个全重复数组（比如所有元素都是1）上，有这行代码的执行次数是 O(n)，没有则是 O(n^2)，差距巨大。

4. 边界条件与测试用例：怎么验证代码一定正确

4.1 最小长度限制

题目的约束是 3 <= nums.length，所以理论上不需要处理长度小于3的情况。但你在做工程或自己写工具函数时，最好加上判断，防止传入非法参数。防御性编程在任何场景都值得养成习惯。

4.2 全是负数的情况

有人会担心 target 为正数而数组全是负数时，指针移动逻辑是否还成立。实际上完全成立。假设 nums = [-5, -4, -3, -2, -1], target = 1。初始 i=0, left=1, right=4，三数和为 -5 + (-4) + (-1) = -10，小于1，左指针右移。这符合"和太小需要变大"的判断，没有问题。问题的核心不是元素的正负，而是有序性保证的左移/右移带来的和的变化方向，在这个前提下，正负不影响算法。

4.3 距离相等时如何选择

如果两个不同的三元组和target的距离相等，题目没有明确要求，但答案只返回一个和的值。此时 abs(sum - target) < abs(best - target) 用的是严格小于，因此如果距离相等，best 不会被更新，也就是保留先出现的那个和。这个行为的正确性取决于你是否需要"最接近的值"而不关心是哪一个值，这道题不要求，所以严格小于完全正确。

4.4 穷举验证方法：写个暴力版做对比测试

我在刷题时习惯用暴力解法做"验证基准"。写完双指针版后，我会在同一份代码里写一个 O(n^3) 暴力函数，然后用随机数生成大量测试数据，比较两个函数的输出是否一致。这个方法可以快速定位隐藏 bug。

下面是Python版的验证思路：

python复制import random

def brute_force(nums, target):
    n = len(nums)
    best = float('inf')
    for i in range(n):
        for j in range(i + 1, n):
            for k in range(j + 1, n):
                s = nums[i] + nums[j] + nums[k]
                if abs(s - target) < abs(best - target):
                    best = s
    return best

# 随机测试
for _ in range(1000):
    n = random.randint(3, 12)
    nums = [random.randint(-10, 10) for _ in range(n)]
    target = random.randint(-10, 10)
    if three_sum_closest(nums, target) != brute_force(nums, target):
        print("error", nums, target)
        break
else:
    print("all ok")

这个暴力对比法看起来简单，但非常实用。它让我在改代码时能快速确认没有改坏逻辑。我自己在刷题时，几乎每道带"最优解"的题目都会用暴力版做对照，尤其是涉及双指针、二分搜索这类容易产生"差一错误"的算法。

4.5 一个容易忽视的溢出场景

如果你用C++写，且 nums[i] + nums[left] + nums[right] 三个数都接近 INT_MAX，那么求和本身就会溢出，得到未定义行为。LeetCode题目通常数据范围保证不会溢出，但严谨的写法可以用 long long sum = (long long)nums[i] + nums[left] + nums[right] 或者先把一个转成 long long。在 target 和 nums[i] 都可能是 -10^4 级别的题目里，其实不会触发溢出，但养成这种习惯总是好的。

5. 它和15题"三数之和"的区别到底在哪

5.1 目标值不同，判断策略就不同

第15题要求三数之和等于0，所以代码里是 if (sum == 0) 就记录答案，然后继续搜索；而第16题要求"最接近target"，代码里是比较 abs(sum - target) < abs(best - target)，每次计算都要取绝对值做比较，没有"找到就停"的简单规则（除非sum恰好等于target）。

这个差异直接影响了是否可以做"去重"。15题必须去重，因为结果要求返回具体三元组，不能重复；16题不管重复，只求值。

5.2 指针移动的触发条件本质相同

虽然目标值不同，但双指针的移动逻辑本质是一模一样的。15题中 sum < 0 左指针右移，sum > 0 右指针左移；16题中 sum < target 左指针右移，sum > target 右指针左移。这里的 target 替换了0的位置。所以如果你已经理解了15题，再去写16题，其实改起来非常快，只是比较逻辑从 == 变成了 abs 比较。

5.3 "找到精确值"的剪枝优化在15题中必须是持续搜索

15题里即使找到一个三元组满足 sum == 0，你也不能直接返回，因为可能还有其它不同的三元组也满足条件，题目要求列出所有。而16题里如果找到 sum == target，则可以立即返回，因为距离0已是最优。这两个剪枝策略的差异值得体会。

6. 再往深一步：这道题还能怎么变着考

6.1 如果数组里有重复元素，是否还能用双指针

可以。排序后重复元素会相邻，双指针依然有效。只要注意 left 和 right 移动时跳过重复值，避免大量无效计算即可。不过在16题中，由于不要求列出具体三元组，"跳不跳过"只是性能问题。

6.2 如果要求返回所有"最接近"的三元组呢

那就需要去重了。做法是：先找到最小距离 minDiff，然后再用双指针搜索一遍，把所有距离等于 minDiff 的三元组都收集起来。这个时候的处理逻辑就接近15题了，需要在移动指针时同时跳过重复元素，保证三元组不重复。

6.3 如果要求返回最接近的两个数之和呢

这就是经典的"两数之和最接近target"问题，思路完全一样：排序后双指针从两端向中间移动。你可以先从两数版本理解双指针，再扩展到三数版本，学习曲线会更平缓。

7. 调试心得和常见错误复盘

7.1 `best` 初始化的坑

我前面提过，best 初始化为 INT_MAX 在target为负数时会溢出。这个错误很隐蔽，因为程序不会崩溃，但会输出一个完全错误的结果。如果你发现输出结果异常地小，比如-2147483648，先检查 best 的初始值。

7.2 内层循环的指针条件写成 `left <= right` 的坑

双指针查找的是两个不同的数，所以左指针和右指针不能指向同一个位置。如果写成 left <= right，当 left == right 时，同一个元素会被当作两个数使用，结果就是错误的。这题要求三个数，所以 left 从 i+1 开始，right 从 n-1 结束，循环条件必须是 left < right。

7.3 忘记排序导致指针移动逻辑失效

这个错误太经典了。如果忘记排序，直接排序后的各色，双指针移动逻辑就是瞎蒙。写代码时一定要先写 sort，再写双指针，顺序不能反。

7.4 在 `sum == target` 时没有提前返回

不提前返回也不会错，但会白白浪费循环时间。在某些极端数据下可能超时。其实提前返回的正确性很好理解：距离0已经是最优，继续搜索只可能得到距离更大或等于0的结果，不会更好。

8. 延伸出的双指针套路总结

8.1 什么情况下可以想到用双指针

我刷了这么多题后的经验是：当题目涉及"在一个数组（或链表）中找几个元素满足某个条件"，且数组可以在无序情况下排序，或者原本就有序时，双指针是一个高概率有效的解法。更具体一点，当你能把暴力解从 O(n^k) 降为 O(n^(k-1)) 时，往往就是双指针登场的时候。

8.2 双指针题目的通用模板

双指针的通用代码模式是：

排序（如果原数组无序）
外层循环枚举一个（或几个）元素，缩小问题规模
内层用 left 和 right 两个指针从剩余区间两端向中间遍历
根据当前状态判断移动哪个指针
每次移动后判断是否更新答案

这个模板可以被套用到很多题目上：两数之和 II、三数之和、四数之和、最接近的三数之和、盛最多水的容器、接雨水等等。

8.3 双指针的局限

双指针不能用于"需要保留原数组下标顺序"的问题。如果你必须输出原始数组中的下标，排序会打乱下标，就得额外记录原始索引或用哈希表。这是面试官常设置的下一步追问，建议想清楚。

9. 一个实用的优化方向：排序后的提前终止

除了 sum == target 的提前返回，还有一个优化在特定场景下很有效：在固定的 i 下，如果当前最小可能和 nums[i] + nums[i+1] + nums[i+2] 已经大于 target 且比 best 更差，可以提前结束整个搜索；或者当前最大可能和 nums[i] + nums[n-2] + nums[n-1] 已经小于 target 且比 best 更差，也可以提前剪枝。

比如：

cpp复制int minSum = nums[i] + nums[i+1] + nums[i+2];
if (minSum > target && abs(minSum - target) > abs(best - target)) {
    break;
}
int maxSum = nums[i] + nums[n-2] + nums[n-1];
if (maxSum < target && abs(maxSum - target) > abs(best - target)) {
    continue;
}

这个判断的意义是：如果当前 i 下，无论怎么选 left 和 right，得到的和只会区间在 [minSum, maxSum] 之间，且这个区间整个都比当前best差，那这个 i 就没有继续搜索的必要了。对于排序后的数组，这种剪枝判断是安全的，而且能显著加速。

我个人在比赛和刷题时，一般先不加剪枝，让代码保持最简、最不容易出错；如果提交后发现TLE，再考虑加剪枝优化。不要一开始就把代码写成天书，bug会越来越多。

10. 从这道题延伸出去的工程视角

这道题虽然看起来像纯算法题，但"最接近的三数之和"这种问题在真实世界里其实有应用场景。比如在金融场景中，你有一批历史交易金额列表，现在想找到三笔交易的组合，它们的和尽量接近某个预算金额；或者在数据分析中，你想从特征值列表中找三个值，它们的组合接近某个目标指标。当然，真实数据规模不会这么大，但思路完全一致。

工程里实现时，我会额外注意几个点：如果数组特别长（比如百万级别），O(n^2) 可能也不够，这时候需要考虑更复杂的数据结构，比如平衡树或哈希表，但问题性质就变了。如果数据量在几千这个量级，O(n^2) 加剪枝完全够用。

另外，真实场景中的数据大概率有噪声和离群点，排序前可以先做一步数据清洗，比如剔除明显异常的值，能减少一些无效计算。当然这是题外话。

写到这里，这道"最接近的三数之和"从题目理解、算法设计、代码实现、细节优化到 debug 方法都过了一遍。最后分享一个我自己的刷题习惯：遇到一道双指针题，我会先不看题解，用暴力解法跑通，再去想怎么用双指针优化，最后用随机数据验证两个版本结果一致。这个过程看着慢，但能让我真正理解算法为什么对，而不是背一套模板。下一次再遇到变种题时，就能更快地迁移思路。