双指针算法精讲：盛水容器移动矮边为何正确

刷算法题的人基本都见过盛水容器这道题，解法通常就叫双指针法：两个指针从数组两端出发，不断把矮的那一边往中间挪，十行代码不到就能跑出答案。可很多人的情况是：代码背得滚瓜烂熟，碰到面试官追问一句“为什么矮的可以被移走，高的不能移？”就有点接不上话。

这篇文章就围绕盛水容器和双指针法展开，把暴力解为什么不行、双指针到底省了什么、每一步收缩为什么不会漏解这三件事说透，后面再附上可以直接抄的代码和几类容易踩的坑。无论你是准备面试，还是刚开始学双指针想找一道代表性题目建立感觉，这篇都可以当一份参考笔记用。我会把那句“移动矮边”背后的数学依据用大白话拆开写清楚，而不是只给你一句“反正这是标准解法”。

1. 暴力解法为什么栽：两两组合的代价

1.1 先明确这道题在求什么

盛水容器的题目描述并不复杂：给定一个非负整数数组 height，height[i] 表示坐标 (i, 0) 到 (i, height[i]) 的一条竖线。我们需要从中选出两条竖线作为容器的左右壁，和 x 轴一起组成一个“直上直下”的容器，问这个容器最多能装多少水。

装水的量不是简单的“两条线高度取平均”之类，而是由短板效应决定的：一个两端高度不一样高的直桶，水会从矮的那边漏出去，所以实际有效高度是两条竖线中较矮的那个。面积公式就是：

面积 = min(height[left], height[right]) × (right - left)

注意中间那些柱子完全不参与，它们既不能当容器壁，也不影响容器内的水。这个模型很纯粹，干扰项越少，越能考察你对“状态收缩”的理解。

1.2 暴力的路线和它的复杂度

看到“选出两根线”，最简单的想法就是把所有组合都试一遍。外层枚举左墙，内层枚举右墙，每个组合算一次面积，用一个全局最大值记录下来。核心代码是两层循环：

python复制def max_area_bruteforce(height):
    n = len(height)
    ans = 0
    for i in range(n):
        for j in range(i + 1, n):
            area = min(height[i], height[j]) * (j - i)
            ans = max(ans, area)
    return ans

组合数量是 C(n, 2)，也就是 n×(n-1)/2。这个复杂度看起来人畜无害，但数值稍微一放大就露馅了。假设数组长度 n = 10^5，组合数大约是 50 亿次比较。就算评测环境每秒能跑一亿次基础运算，也要五十秒级别，任何 OJ 都不可能放过这种复杂度。

生活化一点讲，这就像把 100 个人拉出来两两配对打比赛，要打 4950 场；把人数放大到 1 万人，场次会变成将近 5000 万场。人数翻倍，比赛场次会翻四倍，这就是 O(n²) 的可怕之处。所以这道题只要数据规模稍微认真一点，暴力解法就注定不是正确方向。

有人可能会问：能不能提前剪枝？比如先按高度排序，高的优先匹配？可以，但排序会破坏原始下标，而下标差本身就是面积公式里的“宽度”，丢了位置信息，问题会变得更麻烦。更好的思路不是去优化组合数量，而是反过来想：到底有没有必要把每个组合都看一遍。

1.3 一个先导直觉：从最宽的地方开始

先把两个指针放在最左端和最右端，这时候得到了整个数组里可能出现的最大宽度。当前面积是 min(height[0], height[n-1]) × (n-1)。

这里面积由两部分组成：宽度和短板高度。如果从两边往里收缩，宽度一定会变小，至少减少 1；想让面积变大，唯一的希望是“新的短板高度”能高过原来的短板高度。所以问题就变成一个取舍问题：要么保持当前的宽度优势，要么牺牲一点宽度去换取更高的边界。

正是这个“宽度越小、越需要高度来补”的结构，给了我们一种用单调方向搜索的可能性。双指针的核心不是枚举所有组合，而是想办法证明某些组合永远不可能赢，从而把它们整片整片地剪掉。

2. 收缩的正确性：为什么放弃那条“矮边”不会漏掉最优

2.1 双指针移动规则与样例走查

先看标准解法长什么样：

python复制def max_area(height):
    left, right = 0, len(height) - 1
    ans = 0
    while left < right:
        area = min(height[left], height[right]) * (right - left)
        ans = max(ans, area)
        if height[left] < height[right]:
            left += 1
        else:
            right -= 1
    return ans

规则只有一句话：每次比较当前左右两根柱子的高度，移动相对较矮的那一侧。如果两边一样高，移动哪边都可以，通常写成移动右指针。

用力扣上的经典测试用例来走一遍：height = [1, 8, 6, 2, 5, 4, 8, 3, 7]。初始 left=0，right=8，两根柱子高度分别是 1 和 7，面积是 min(1,7)×8=8。左边太矮，于是 left 移动到下标 1。现在 height[left]=8，height[right]=7，面积 min(8,7)×7=49，这其实就是全局最优解。接着右边相对矮，right 往左挪，后面的面积都超不过 49。算法最后返回 49。

代码很好背，但为什么第二步之后还有那么多组合不用比了？这就是理解双指针法的分水岭。

2.2 一个简单但严谨的丢弃理由

我把证明拆成三步，每一步都很短，但连起来就能说明白整个算法为什么不会漏解。

假设当前左右指针分别在 l 和 r，两个高度分别是 h_l 和 h_r。先看 h_l < h_r 的情况，也就是左边较矮。

当前面积是：

S = h_l × (r - l)

现在考虑一个关键问题：如果我把右边界向内部移动，挪到某个位置 k，其中 l < k < r，新组合是“以 l 为左边界、以 k 为右边界”。这个组合的面积最大能到多少？

面积 = min(h_l, height[k]) × (k - l)

因为 min(h_l, height[k]) 永远不可能超过 h_l，而 k-l 又严格小于 r-l，所以这个面积一定小于 h_l × (r-l)，也就是小于当前面积 S。

这意味着什么？意味着只要当前左边界 l 是较矮的那一个，那么任何“仍然以 l 为左边界、右边界在区间内部的组合”都已经赢不了当前这一条了。既然以 l 为左边界的所有可能性都被当前结果压住了，那我们在后续搜索里永久丢弃 l 这根柱子，是没有任何损失的。

h_r < h_l 的情况完全对称，只是把“左边界”换成“右边界”来论证。h_l 和 h_r 相等的时候，丢哪边都安全，因为不管保留哪边，内部的组合都受到同样的面积上界约束。

2.3 为什么不能反过来移动“高边”

理解了上面的证明，就很容易回答那个经典的追问：“为什么移动较矮的那条边，而不是较高的那条？”

因为较矮的那条边是当前容器的“短板”，它的高度决定了这个桶最多能装多高。如果你把较高的那一边往内收，虽然有可能遇到一根更高的柱子，但容器另一端仍然是当前这个矮的。你在损失宽度，同时短板的实际高度不会因为另一侧变高而提升，除非你把矮边也换掉，但那就不是“只移动高边”能解决的事了。

换个更直观的说法：矮边像一个瓶颈。当前宽度下，瓶颈已经把容器高度的上限卡死了。任何以内侧某根柱子和这个瓶颈组成的容器，都不可能超过当前这个已经很宽的瓶颈容器。所以瓶颈本身已经完成了它的历史使命，继续留着它只会限制你探索更优解的空间。赶紧把它丢掉，让新的、可能更高的柱子成为边界，才是真正有希望的搜索方向。

3. 落地代码：常见写法和边界情况

3.1 最简 Python 版与逐行说明

前面那段 Python 代码可以直接用，但有几个点值得在写的时候注意。

第一，while left < right 保证了容器左右边界是同一条线的情况不会出现。如果数组长度小于 2，天然不存在两个不同位置，直接返回 0 即可。

第二，面积计算放在移动指针之前。顺序非常重要，你要先把“当前这对边界”的面积记录下来，再决定丢弃哪一侧。如果先把指针移动了，当前这对边界对应的面积就永久丢失了。

第三，if height[left] < height[right] 这个条件只决定移动方向，不参与面积计算。很多人初学时会误写成用面积大小来决定移动方向，这是不对的。我们移动的是“较矮的柱子的下标”，不是“面积更小的一侧”。

下面几个测试用例可以帮助验证实现：

边界用例 [1,1] 很能说明问题：两根柱子高度都是 1，中间距离是 1，面积就是 1。如果代码里 while 条件写错成 left <= right，左指针和右指针相遇时还会再算一次，虽然结果可能没错，但语义上已经越界了，在 C++ 里甚至可能访问到不存在的下标。

3.2 C++ 写法与一个可选微优化

C++ 版本和 Python 逻辑一致，重点在于类型和边界：

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

如果左指针和右指针相遇时你希望循环还能再优化一轮，可以用一个带跳跃的写法：每次算完当前面积之后，把所有高度小于等于当前短板高度的柱子直接跳过。逻辑是：当前短板已经给出了面积上界 h，任何高度不超过 h 的柱子留在端点位置，无论另一侧多高，面积都不可能超过 h × 当前宽度，而宽度在后续只会更小。

cpp复制int maxAreaFast(vector<int>& height) {
    int left = 0, right = (int)height.size() - 1;
    int ans = 0;
    while (left < right) {
        int h = min(height[left], height[right]);
        ans = max(ans, h * (right - left));
        while (left < right && height[left] <= h) {
            ++left;
        }
        while (left < right && height[right] <= h) {
            --right;
        }
    }
    return ans;
}

这个优化在数据量极大时可以省掉大量无效比较，但它要求你对“为什么可以跳”有把握。如果只是想把题目做对，普通双指针写法就够了；如果写跳跃版，务必注意内层 while 可能把 left 推过 right，所以一定要保留 left < right 的条件。

3.3 复杂度结论与数据对照

双指针法的时间复杂度是 O(n)，因为 left 和 right 一共只会相遇一次，整个过程最多移动 n-1 次。额外空间是 O(1)，不依赖任何额外的数组或栈。

用一个简单的数据对照来感受差距：

O(n) 和 O(n²) 在 n 小的时候差异不明显，一旦 n 到达十万级别，就是“完全跑不动”和“几乎瞬时完成”的差别。这也是很多面试官默认你不可能用暴力的原因。

4. 踩坑与串题：几个容易被问倒的细节

4.1 “移动矮柱后面积反而变小，是不是算法错了”

这是个非常常见的疑问。有些测试用例在移动矮边之后，当前面积确实比上一步小，比如 height = [5, 1, 4, 3]。

初始 left=0，right=3，面积是 min(5,3)×3=9。当前右边比较高？不对，这里 height[0]=5 大于 height[3]=3，所以矮边是右侧，移动 right 到下标 2。新组合是 height[0]=5 和 height[2]=4，面积是 min(5,4)×2=8，确实比 9 小。

如果你只盯着“当前面积有没有变大”，就会以为算法出问题了。但别忘了，我们维护的是一个历史最大值 ans，不是要求每一步的临时面积都单调递增。算法只需要保证最终不会漏掉最优解，允许中间过程出现回退。9 这个最大值仍然被记在 ans 里，后面即使一直找不到更大的，答案也不会低于 9。

4.2 相等高度时到底该移哪边

当 height[left] == height[right] 时，标准解通常走 else 分支，把右指针往左移。有读者会担心：万一最优解需要保留右边这根，丢掉它不就漏了吗？

前面证明已经覆盖了这种情况。左右等高时，任意一边都是当前容器的最短板。你丢掉左边，那么“以右边为右边界的内部组合”不会优于当前面积；你丢掉右边，那么“以左边为左边界的内部组合”同样不会优于当前面积。两边都可丢，关键是不要两边同时丢，否则你会跳过一对可能形成更优解的边界。

有一种错误的“优化”写法是：if height[left] == height[right] 时同时执行 left++ 和 right--。这看起来能加速收敛，但会跳过一些值得检查的宽度，破坏了每一步只丢一根柱子的不变量。比如 [2, 3, 4, 2] 这种情况，同时向内移动会直接从最外层跳到中间两个柱子，漏掉“下标 0 和 2”这类可能更优的组合。

4.3 把盛水容器和接雨水混在一起

这是我在帮别人看代码时遇到最多的串题。盛水容器和“接雨水”问题外观上很像，都用数组表示高度，都用到双指针，但问的东西完全不同。

盛水容器是“选两条线组成直桶”，只看选中的两根柱子，中间的柱子完全不参与。它求的是这一对边界能形成的最大面积，结果是单一数值。

接雨水则是给定整个地形剖面，每个宽度为 1 的柱子之间会有凹陷区域，下雨后这些区域会积水。它求的是整个区间里能接住的总水量，需要对每一个位置分析左右两侧的最高柱子。经典测试用例 height = [0,1,0,2,1,0,1,3,2,1,2,1] 的答案是 6。

两者的双指针解虽然都从两端往中间走，但接雨水的核心是维护左右两侧的最大值，按位置累加可存水量；盛水容器的核心是用短板和宽度计算当前桶面积，再丢掉短板。如果面试时没听清题目，把盛水容器答成了接雨水的思路，方向就完全跑偏了。

4.4 “为什么复杂度一定是 O(n)，而不是看着像 O(n)”

双指针每轮循环至少会移动一个指针，而且移动方向永远是从两端指向中间，不会回头。left 和 right 的相对位置不断缩小，最多 n-1 次相遇。这就意味着，哪怕 height 数组再长，循环次数也是线性的。

有的写法会在内部套一个 while 来跳过某些柱子，比如前面提到的跳跃优化，看起来像是嵌套循环，但内层循环每次都会消耗掉一个不会被再次使用的端点。所有内层移动的总次数仍然不超过 n，所以整体的均摊复杂度依然是 O(n)。这一点在面试被深挖时值得主动提一下，能体现出你对复杂度的理解不是停留在表面。

5. 从这道题抽离：对撞双指针的套路与迁移

5.1 三个判断信号

盛水容器做多了之后，很容易总结出一类“对撞指针”题型的套路：两个指针分别从数组两端出发，根据某种单调性向中间移动，最终在 O(n) 时间内找到满足条件的组合。

什么时候能想到用这种对撞指针？我自己的判断标准有三个。

第一，数据结构是线性结构，最典型的就是数组，也可能是有序链表。第二，候选答案是“两个端点组合”决定的，比如两个下标、两个元素。第三，存在一个可证明的安全丢弃规则，移动某一端的指针后，不会漏掉潜在的最优解。

盛水容器完美命中这三条：面积由左右两个下标共同决定；每次移动矮边都有上一节的证明托底；两个指针最终会相遇，覆盖完所有可能成为最优解的边界组合。

反过来，如果一个问题虽然有两个端点，但你移动任何一边都没有办法证明“不会漏解”，那对撞双指针就不一定适用，这时候可能需要排序、二分或者其他数据结构。

5.2 同类型的经典题清单

既然聊到对撞双指针，顺便列几个经常和它一起出现的题目。两数之和 II（输入有序数组）是典型的对撞双指针，因为数组有序，指针所指的两数之和和目标值的大小关系能决定移动哪一端。三数之和可以先固定一个数，再用双指针在剩余区间里找两数之和，本质上也是对撞思想的扩展。

还有一些看起来和数值没关系，但形式很像的题，比如验证回文串、反转字符串中的元音字母。回文串判断从两端向中间比较字符，遇到不匹配就能直接返回 false；反转元音字母则是左右指针各自找到元音后交换。这类题的共同点是端点之间有明确的比较或交换规则，向内收缩的过程不会影响已经处理过的部分。

5.3 面试答法建议

如果你是在面试中遇到这道题，我的建议是按照“暴力起点 → 优化动机 → 双指针推导 → 正确性论证 → 样例走查”的顺序来讲，不要上来就甩代码。

先把暴力算法说清楚：两层循环枚举所有左右边界，复杂度 O(n²)，在数据规模大时不可行。然后指出暴力做了很多无用功，因为所有以当前矮边为边界、另一侧靠内的组合其实都不可能超过当前较宽组合的面积，可以成片剪掉。接着讲双指针从两端出发，维护一个记录最大值的变量。最后用经典测试用例 height = [1,8,6,2,5,4,8,3,7] 快速走一遍，说明为什么移动几步后就能拿到 49，以及为什么后续收缩不会漏掉更大的解。

我自己以前刷这道题时，第一遍也是把代码背完就走了。后来被朋友连环追问“为什么不是移高的那边”才意识到，双指针法真正值钱的不是那十行代码，而是“我可以丢掉这个端点”的判断过程。你在纸上写推导的每一步，其实都是在训练一种边界思维：不用看完所有可能性，也能知道哪些可能性已经被当前信息覆盖。后来我每刷一道对撞指针题，都先写证明再写代码，而不是反过来。这个习惯对理解双指针类问题帮助很大。