盛最多水的容器：双指针算法原理、证明与面试实战解析

在 LeetCode 上刷题的同学，应该都绕不过第 11 题“盛最多水的容器”。这道题在面试里出现的频率相当高，我认识的好几个同事在模拟面试环节都遇到过它。题目本身并不复杂，但它是一道典型的“看着很容易，想明白不容易”的题——暴力解法谁都会写，但能不能想到双指针，并且能严谨地证明为什么双指针不会漏掉最优解，这就区分开了初级和中级开发者的思维水平。

这道题的核心场景其实很朴实：给你一组非负整数，每个数代表一根垂直于 x 轴的柱子高度，你需要找出两根柱子，加上 x 轴围成的容器，能够装下最多的水。用大白话说，就是在一排高低不一的木板里，挑两块板子，让它们之间能兜住的水最多。水的高度由较矮的那块板决定，宽度就是两块板之间的距离。

这篇文章我会从题目本质出发，把暴力解、双指针解、正确性证明、代码实现、边界情况、常见变形和面试追问方向全部拆开讲一遍。适合准备算法面试的求职者，也适合想把手上的题目真正吃透的在校学生。文章里用的都是我个人在刷题和实际写代码时积累的经验，有些是踩过坑以后才明白的，希望能帮你少走弯路。

1. 题目拆解：盛最多水的容器到底在问什么

1.1 理解题意和生活化类比

先把这个题目的场景还原一下。假设有一排高度参差不齐的墙，每堵墙的底部都在同一条水平线上，往这个由两堵墙围成的槽里倒水，水面能到的高度取决于较矮的那堵墙，因为水会从矮墙那边溢出去。两堵墙相隔越远，槽就越宽，能装的水就越多。

这个场景对应到数组上就是：给定一个整数数组 height，height[i] 表示第 i 个位置上的墙的高度。我们要找两个下标 i 和 j（i < j），让这两堵墙围成的容器盛水量最大。盛水量的计算公式是：

容量 = min(height[i], height[j]) * (j - i)

也就是“矮墙的高度”乘以“两墙之间的水平距离”。注意这里不考虑墙体本身的厚度，也不用管容器底面是什么形状，所有墙都在同一条直线上，这是题目的简化设定。

我常拿这个题目跟生活中的场景类比：你在河边看到一排木桩，想找两根木桩之间拉一张防水布来蓄水。防水布的高度取决于矮的那根桩能撑多高，两根桩隔得越远，布的面积就越大。你的目标就是让“矮桩高度 x 桩距”这个乘积最大。这个类比基本完全贴切。

1.2 输入输出示例

来看一个具体的例子。假设输入数组是：

height = [1, 8, 6, 2, 5, 4, 8, 3, 7]

肉眼观察一下，下标 1 的高度是 8，下标 8 的高度是 7，它们之间的距离是 7，矮墙高度是 7，所以容量是 7 x 7 = 49。这是不是最大呢？如果选下标 1 和下标 6，高度分别是 8 和 8，距离是 5，容量是 8 x 5 = 40，比 49 小。如果选下标 2 和下标 8，高度是 6 和 7，距离是 6，容量是 6 x 6 = 36，也小于 49。

所以这个数组的答案就是 49。这个例子是 LeetCode 官方示例，也是我刷题时反复拿来验证思路的标准用例，后面讲双指针步骤的时候还会回来看它。

1.3 这个题目想考察的核心能力

从面试官的角度看，这道题主要考察三个层面的东西。

第一，能不能把文字描述快速抽象成一个数学模型。很多人读完题就开始写代码，没有意识到核心就是“矮板乘距离”这个公式。一旦公式写出来，问题就成功了一半。

第二，能不能从暴力解法中提炼出冗余计算，并找到消除冗余的方向。暴力解是所有下标对都算一遍，时间 O(n²)，数据量一大就完蛋。双指针的核心思想是：每次只移动高度较低的那根指针，因为较高的那根指针如果移动，容器宽度变小而高度不可能变大，结果必然不优。

第三，能不能严谨地证明双指针的正确性。这一点是很多人翻车的重灾区。大家都能说出“移动矮的指针”这个结论，但问一句“为什么移动矮的不会漏掉最优解”，就答不上来了。我在面试中见过不少候选人，能写出代码但说不清楚原理，最终评价还是上不去。

2. 从暴力到双指针：一条清晰的思维路径

2.1 暴力枚举：一切问题的起点

遇到这个题，绝大多数人的第一反应是双重循环枚举所有下标对 i 和 j，对每一对都计算容量，然后取最大值。

def maxArea_bruteforce(height): n = len(height) max_area = 0 for i in range(n): for j in range(i + 1, n): area = min(height[i], height[j]) * (j - i) max_area = max(max_area, area) return max_area

这个写法非常简单直观，但时间复杂度是 O(n²)。如果数组长度到了 10 万级别，就要计算大约 50 亿次，在普通机器上根本跑不动。LeetCode 上这个题目的数据范围是 n 最大到 10^5，暴力解法会直接超时。

不过我不建议直接跳到最优解。从暴力开始推演的好处是，你能清楚地看到计算过程中存在大量的重复和无效比较，从而自然想到优化的方向。比如当我们将 i 固定住，j 从右往左移动时，如果当前的 height[j] 比较矮，即使距离很远，容量也被矮墙卡死了。这种“矮墙决定上限”的特征，才是优化破局的钥匙。

2.2 双端逼近：为什么会想到用两个指针

如果从两端开始考虑，也就是先把距离拉到最大，然后用两个指针往中间收缩，每次计算当前容器容量并更新答案，就能避免枚举所有组合。关键在于，收缩时到底该移动哪一边的指针？

答案是移动较矮的那一边。原因是：容器的高度由较矮的墙决定。如果我们移动较高的那一边，不管新的墙有多高，容器的高度都不可能超过原来较矮的那一边，而宽度却在不断缩小。换句话说，移动高墙的结果只有两种：容量不变或变小，绝无变大的可能。反过来，移动矮墙，虽然宽度变小，但新墙有可能更高，从而让整体容量变大。

这个推理是整个算法的灵魂。

2.3 从反证角度理解“移动矮墙不会错过最优解”

为了彻底说清楚，我们可以做一个反证推理。假设最优解对应的两根柱子是下标 left_opt 和 right_opt。在我们双指针收缩的过程中，总会有一个时刻，某个指针正好指在 left_opt 或 right_opt 上。如果此时另一个指针还没有到达对应位置，必然会有一个指针停在“最优范围之外”的某一端。

现在分情况讨论：如果左指针在 left_opt 左边，右指针还没到 right_opt，那么当前容器的水力公式中，矮墙高度一定不会超过 height[left_opt]，因为移动矮墙规则会让我们倾向于收缩矮端。但重点是，只要我们每次移动的都是当前较矮的那一端，最终左指针会一直向右移动，直到到达 left_opt，而右指针在这个过程中不会越过 right_opt——否则就意味着在某个时刻，右指针那一侧的高度一直矮于 optimal 对中较矮的高度，这与最优解的定义矛盾。

这个逻辑听起来有点绕，我在面试时喜欢用一个更朴素的解释，大家更容易接受：我们手里拿的宽度是全体区间里最大的，此时的水量由两端较矮者决定。如果固定这端不动，另一端无论怎么往里收，宽度只会变小，高度又不超过当前矮端，面积不可能超过当前值，所以当前这端“已经尽力了”，可以放心丢弃。丢弃时自然要丢矮的那端，因为高的一端还可能成为后续计算的“高度担当”。

这个推理过程实际上就是贪心思想的体现，每一步丢弃一个“永远不可能成为最优解一部分”的端点，剩下的区间继续搜索。

3. 核心代码实现与原理验证

3.1 Python 实现与逐行讲解

先给出最常用的 Python 解法，代码非常简洁。

def maxArea(height): left = 0 right = len(height) - 1 max_area = 0 while left < right: # 当前容器的宽和高 h = min(height[left], height[right]) w = right - left area = h * w max_area = max(max_area, area) # 移动较矮的那一侧 if height[left] < height[right]: left += 1 else: right -= 1 return max_area

代码逻辑一共就四步。初始化左右指针指向数组两端，计算当前面积并更新最大值，比较两端高度后移动较矮端，重复直到两指针相遇。循环终止的条件是 left >= right，因为只要两个指针重叠，宽度变成 0，不可能再有正的容量。

这里有一个细节值得注意：当 height[left] == height[right] 时，上面的代码选择移动右指针。其实此时移动左指针也一样，因为无论移动哪一边，下一步的宽度都减 1，而新的高度最多等于当前高度，不会出现某一边移动后被另一边超越并能带来更大收益的情况。我实测过这两种写法，结果完全一致。

3.2 C++ 实现与对比

在面试中，C++ 也是高频手写语言。实现如下：

int maxArea(vector<int>& height) { int left = 0, right = height.size() - 1; int max_area = 0; while (left < right) { int h = min(height[left], height[right]); int w = right - left; max_area = max(max_area, h * w); if (height[left] < height[right]) { left++; } else { right--; } } return max_area; }

C++ 和 Python 的写法几乎没有差别。唯一需要注意的是 vector.size() 返回的是 size_t 类型，如果直接用 int 接收，在数组长度超过 int 上限时会有风险。不过这题的 n 最大 10^5，int 完全够用，但面试时顺手用 auto 或转换为 int 体现的细节功底，容易给面试官留下好印象。

3.3 用示例数据手动演算双指针过程

拿前面的例子 height = [1, 8, 6, 2, 5, 4, 8, 3, 7] 来手动跑一遍，帮助你建立体感。

• 初始 left = 0, right = 8，高度分别是 1 和 7，宽度 8，容量 = min(1, 7) x 8 = 8。1 比 7 矮，左指针右移。
• left = 1, right = 8，高度 8 和 7，宽度 7，容量 = min(8, 7) x 7 = 49。8 比 7 高，右指针左移。
• left = 1, right = 7，高度 8 和 3，宽度 6，容量 = 3 x 6 = 18。8 比 3 高，右指针左移。
• left = 1, right = 6，高度 8 和 8，宽度 5，容量 = 8 x 5 = 40。相等，按代码右指针左移。
• left = 1, right = 5，高度 8 和 4，宽度 4，容量 = 4 x 4 = 16。右移。
• left = 1, right = 4，高度 8 和 5，宽度 3，容量 = 5 x 3 = 15。右移。
• left = 1, right = 3，高度 8 和 2，宽度 2，容量 = 2 x 2 = 4。右移。
• left = 1, right = 2，高度 8 和 6，宽度 1，容量 = 6 x 1 = 6。右移。
• left = 2, right = 2，循环结束。

最大值是第二步得到的 49，正确。整个流程一共进行了 8 次计算，而暴力枚举要算 36 次。数据规模小的时候看不出差距，一旦 n 到万级，差距就是数量级的碾压。

3.4 复杂度分析：为什么双指针是 O(n)

时间复杂度是 O(n)，因为 left 和 right 指针从两端向中间移动，每一步只移动一个指针，总共最多移动 n 次。空间复杂度是 O(1)，只用了几个临时变量。

对比一下暴力解法的 O(n²)，双指针在数据规模达到 10^5 时优势非常明显：暴力大约需要 50 亿次操作，双指针只需要 10 万次。这种量级的差距在真实项目中意味着程序从不可用变成秒回。刷题时遇到这一类“两端逼近”的题目，可以先想想能不能用双指针把复杂度降一个量级。

4. 关键证明：双指针为什么不会漏掉最优解

4.1 形式化证明的思路框架

证明的核心是说明：在每一步中，我们丢弃的那一端（较矮的一端）不可能成为最优解中不可缺少的那一侧更高的墙。严格来说，是“较矮的这一端与当前另一端组合产生的容量，已经不可能是全局最优”，所以丢弃它是安全的。

我们维护两个指针 left 和 right，假设当前 height[left] < height[right]。那么当前容量 = height[left] * (right - left)。现在思考：以 left 为左边界，任意右边界 j 在 (left, right] 之间，形成的容器容量 = min(height[left], height[j]) * (j - left)。因为 j - left < right - left，且 min(height[left], height[j]) <= height[left]，所以这个容量必然小于等于 height[left] * (right - left)，也就是当前容量。

换句话说，只要左指针指着当前的 left，无论右指针再往哪移，容量都不可能超过当前值。这说明以当前 left 为左边界的“最优解候选”已经被完全探索完毕，left 这个位置在后续过程中不可能再产生更大的容量，所以可以放心地把 left 加 1，丢弃这个左边界。

4.2 一个帮助理解的极端场景

假设数组是 [10, 1, 1, 1, 1, 1, 1, 1, 1, 1, 100]，最优解显然是下标 0 和 10，容量 = min(10, 100) x 10 = 100。我们用双指针来走一遍。

初始 left = 0, right = 10，高度 10 和 100，容量 = 10 x 10 = 100。由于 10 < 100，左指针右移。接下来 height[left] 都是 1，右指针是 100，所以每次都是左指针右移，右指针始终不动。直到 left = 10，循环结束，最大值仍然是 100。

你有没有发现，这里左指针一路从 0 移到 10，但右指针从头到尾都没动过。原因就是右指针指向的 100 一直是当前两端中较高的那一个，按照规则它永远不会被移动。反过来想，如果我们在某一步移走了右指针，那就等于放弃了一个可能的高度最高点，这是绝对不划算的。左指针不断右移，正是在排除所有“以 10 开头”的候选区间，因为那些区间的宽度在缩小，而高度上限被 10 卡死，不可能超过当前 100 的容量。

4.3 相等高度时的处理细节

当 height[left] == height[right] 时，很多人会纠结移动哪边。前面说过随便移动哪边结果都一样。但从证明的角度看，此时两端的容量 = height[left] * (right - left)，无论移动哪一边，新的容量都不可能超过这个值。因为移动后宽度减 1，而高度取两端较小值，至多等于 height[left]。所以两边都不会遗漏任何潜在最优解。

我在代码里默认写了 else 分支移动右指针，这是个人习惯。如果你写成 height[left] <= height[right] 时移动左指针，同样能通过所有测试用例。这个细节不是考点，但搞清楚背后的数学原理能让你在面试中更自信。

5. 边界情况与常见坑位分析

5.1 最少柱子数量

如果数组长度小于 2，就没法构成容器，答案应该是 0。输入 height = [7]，输出 0。输入 height = []，输出 0。LeetCode 的题目说明里没有明确说最小长度，但按常理推，长度不足 2 时直接返回 0 是合理的。实际刷题时，很多解法从 left = 0, right = len(height) - 1 开始，如果 right <= 0，while 循环根本不会执行，max_area 初始值为 0，天然正确。但如果你写的是先求 n 再判断，也能保住边界。

有一种容易错的写法是这样：初始化 max_area 为负无穷或 height[0] * 1，一旦数组为空就会出问题。我建议 max_area 一律初始化为 0，因为容量最小值就是 0，不存在负容量。

5.2 所有柱子等高的情况

输入 height = [5, 5, 5, 5, 5]，任何两根柱子围成的容量都是 5 x 距离，最大的是两端：5 x 4 = 20。双指针第一次计算就得到 20，后续每次容量都在变小，最终 max_area 仍然是 20。这时候无论移动哪边指针，结果都一样，算法完全正确。

这个例子看着简单，但它能确认一个直觉：容器容量由矮墙和宽度共同决定。如果所有墙一样高，那容量的唯一变量就是距离，找最远的两端一定是最优。

5.3 容量非常大时是否需要考虑溢出

在 Python 里，整数可以无限大，完全不用担心溢出。但如果你用 C++ 或 Java 写，int 最大值约 21 亿，而 height[i] 最大是 10^4，n 最大是 10^5，理论上最大的容量 = 10^4 x 10^5 = 10^9，在 int 范围内但非常接近上限 2,147,483,647。所以 C++ 用 int 存储 max_area 是安全的。不过为了保险起见，很多人在面试回答中会主动说“用 long long 更稳妥”，这属于加分项，能体现对数据范围敏感。

5.4 原地修改数组与额外空间的取舍

这道题的双指针解法空间复杂度已经是最优的 O(1)，不存在更省空间的写法。你不需要复制数组，也不需要排序，因为排序会破坏下标，导致宽度计算完全失效。我见过有同学想过先按高度排序再计算，这是常见的错误思路。排序后你虽然能快速知道最大高度，但两两之间的距离信息已经丢失，问题性质完全改变了。

还有一种想法是用前缀和或线段树，这属于过度设计。这道题的约束是数组本身无序，双指针 O(n) 已经是最优时间复杂度，因为确定最优解至少要扫一遍数据。任何 O(n log n) 或更高复杂度的解法都是不必要的。

6. 面试中的变形考法与应对策略

6.1 面试官追问的常见方向

题目本身只是开胃菜，面试官通常会在你写完代码后抛出几个追问，考察你的理解深度。

第一个追问：为什么从两端开始而不是从一端开始？这背后的逻辑是，宽度最大化才能为后续的高度比较提供最大空间。如果我们从一端开始，另一个端点遍历整条数组，本质上还是 O(n²)。只有双端同时收缩，才能把两个维度（宽度和高度）同时纳入每一步的决策中。

第二个追问：如果数组中存在负数怎么办？这个题的约束是 height[i] 为非负整数，但如果放宽到负数，容器高度的概念就失效了——高度不可能是负数。所以不存在合法的推广场景。这个追问更多是在考察你是否有敏锐的约束条件意识。

第三个追问：如果要把“盛最多水的容器”改成“盛最多雨的容器”，又该怎么算？这就是另一道经典题目“接雨水”了。两题容易混淆，但思路完全不同。接雨水需要用单调栈或动态规划计算每个位置能存多少水，而不是找两个边界。建议把这两题放在一起对比学习，效果会很好。

6.2 变形一：找出最大容量的具体下标

有些面试官会加一个条件：不只返回最大容量，还返回构成最大容量的那两根柱子的下标。这个简单，在更新 max_area 时同步记录 left 和 right 即可。

def maxAreaWithIndex(height): left, right = 0, len(height) - 1 max_area = 0 best_left, best_right = -1, -1 while left < right: area = min(height[left], height[right]) * (right - left) if area > max_area: max_area = area best_left, best_right = left, right if height[left] < height[right]: left += 1 else: right -= 1 return max_area, best_left, best_right

这里要注意，如果存在多个相同的最大容量，我们记录的是第一个找到的。要不要记录所有组合取决于具体需求，通常情况下一个答案就够了。

6.3 变形二：最多可以盛水的位置之一，但不是端点

这个变形看起来和原题不太一样，但实际上是把二维问题压缩成一维。给定一个二维矩阵，每个格子代表高度，找一个子矩形灌水之类的场景，原题的思路还可以迁移，不过复杂度会显著上升。这类题一般作为 hard 级别出现，如果你能理解双指针解决一维问题的本质，再去做二维版本会顺畅很多。

我个人建议把原题的标准解法练到可以在 5 分钟内默写出来，再去做这些变形。基础不牢，地动山摇。

7. 实际工程中类似的“双指针”思想应用

7.1 有序数组的两数之和

LeetCode 第 167 题“两数之和 II - 输入有序数组”，也是双指针的经典应用。数组已经升序排列，要找两个数之和等于目标值。左指针指向开头，右指针指向结尾，每次比较两数之和与目标值的关系，决定左移还是右移。这和盛水的容器有异曲同工之妙，核心都是利用有序性来指导指针移动方向。

如果数组无序，需要先排序再用双指针，但那样会丢失原始下标信息。所以具体场景要具体判断，并不是所有题目都适合双指针。

7.2 字符串/数组原地去重

LeetCode 第 26 题“删除有序数组中的重复项”，也是双指针，但这里的两个指针都在同侧运动，一个快指针负责遍历，一个慢指针负责记录不重复元素的位置。这种“快慢指针”和“左右对撞指针”统称为双指针家族，但它们思考方式不同，不能混为一谈。

盛最多水的容器属于“左右对撞”类型，它的特征是：每一步缩小搜索区间，丢弃一部分不可能的解。判断一道题是否适合对撞双指针，有一个简单标准：最优解是否和区间的两个端点密切相关，并且越靠两端越有优势。

7.3 流量控制与负载均衡场景下的类比

从工程视角来看，这道题的思维模式其实很接近“在资源约束下寻找最大吞吐量”的问题。比如在一个限流系统中，上游有两个服务节点，一个处理能力强但距离远，一个处理能力弱但距离近，我们要找一个组合使得整体吞吐最大。较弱的节点就像矮墙，它决定了系统的瓶颈。每次收缩时可以优先淘汰瓶颈节点，寻找更强的替代者。

当然，真实系统比这复杂得多，但这种“识别瓶颈、优先优化瓶颈”的思路，恰恰就是双指针带给我们的工程启示。这也是我为什么推荐大家都认真学一学这类题目，算法结构和工程思维往往是相通的。

8. 常见错误与排查技巧速查表

8.1 出错场景一览

8.2 排查技巧和调试建议

实际操作中排查这类问题的最高效手段，是在循环内部打印 left、right、height[left]、height[right] 和 area 的值。比如你发现最终结果是错的，把每一步打出来，很快就能定位是哪一步的分支比较写反了。对于小程序，print 调试往往比单步断点更快，尤其是在你已经基本确定是逻辑问题时。

另外，我建议准备一组简单的测试用例集，每次写完解法先跑一遍。比如：

height = [1, 1] => 1 height = [1, 2, 1] => 2 height = [4, 3, 2, 1, 4] => 16 height = [1, 8, 6, 2, 5, 4, 8, 3, 7] => 49

这四个用例能覆盖：两元素、三元素、递增递减混合、官方案例。跑通它们，再提交 LeetCode 基本就稳了。我以前新学一道题时，会先在本地写好这组用例，确认无误后再去在线评测，省了很多反复提交的次数。

8.3 性能优化的一点点补充

这道题的 O(n) 解法已经是最优，不太可能再优化时间。但如果你在大规模数据集上运行，可以考虑局部性优化：比如避免频繁访问 height 数组，把 height[left] 和 height[right] 各缓存到局部变量里。在 C++ 中这种写法能减少内存访问，有轻微性能提升；在 Python 中效果不明显，但代码可读性会更好。

int maxArea(vector<int>& height) { int left = 0, right = height.size() - 1; int max_area = 0; while (left < right) { int hl = height[left], hr = height[right]; int h = min(hl, hr); max_area = max(max_area, h * (right - left)); if (hl < hr) left++; else right--; } return max_area; }

这样还有一个附带好处：比较用的是局部变量，后续对指针移动方向的分支判断更直观。

9. 个人经验与总结建议

这道题我在不同阶段刷过好几遍，第一遍只会暴力，第二遍背下了双指针但说不清原理，直到第三遍才真正把证明过程想通。后来在模拟面试中我也出过这道题，观察到大部分候选人的表现都卡在“原理说不清”这一步。会写代码的人很多，但能把自己的代码为什么正确讲明白的人并不多。

如果你正在准备面试，我建议不要只满足于通过测试，一定要把“为什么移动矮指针”这个问题的回答练成肌肉记忆。面试官听到你能用“当前矮端与任意右端组合都不可能超过当前容量”来回答时，印象分会明显上升。

另一个实用的建议是把这道题的解法整理进自己的算法模板库。双指针对撞是一类非常高频的题型，除了盛水容器，还有三数之和、最长回文子串等题目都用到类似思路。把这类题归纳到一起，刷题效率会高很多。

最后分享一个小技巧：在纸上画一个坐标系，把数组下标作为 x 轴，高度作为 y 轴，每次移动指针时用笔划掉一行或一列候选区间，你就会直观地看到搜索空间在一格一格缩小。我每次给同学讲题都推荐这个方法，效果比直接看代码好得多。

这道题虽然只是 LeetCode 上的第 11 题，但它代表的思维模式贯穿了很多更复杂的算法场景。愿你在刷题的路上，不仅能手写答案，更能理解答案背后的道理，这样遇到任何变体都不会慌。