单调栈详解：Java求最大子矩阵面积（LeetCode 85）

今天聊一个特别典型的算法题：求最大子矩阵的大小。后台很多人问过Java版本该怎么写，尤其是面试前刷题，这道题出现频率相当高。它是LeetCode 85题（Maximal Rectangle）的变体，也常以“给定一个由0和1组成的矩阵，找出只包含1的最大矩形面积”的形式出现。我在用Java实现的时候踩过一些坑，也总结了一套比较通用的解题框架，今天完整地拆出来讲清楚，从思路推导到代码实现再到常见坑位，一次说透。

先说这道题适合谁来看：正在准备面试的同学、刷LeetCode想系统掌握单调栈应用的、以及工作中需要处理二维数组最优区域计算的Java工程师。无论你是刚学数据结构还是已经有段时间没碰算法了，只要跟着这篇的思路走，代码可以直接抄，但更重要的是把“为什么这么解”想明白。

1. 核心思路拆解：二维问题怎么降成一维

1.1 最大子矩阵问题的本质

我们面对的输入是一个二维数组，比如：

java复制int[][] matrix = {
    {1, 0, 1, 0, 0},
    {1, 0, 1, 1, 1},
    {1, 1, 1, 1, 1},
    {1, 0, 0, 1, 0}
};

要找的是：只包含1的最大矩形，返回这个矩形的面积。注意这里要求的是“矩形”而不是“正方形”，两者在解法上差异很大。如果是最大全1正方形，可以用DP压缩到二维空间做状态转移；但矩形因为长宽不固定，状态转移不方便，常见的高效做法就是用柱状图 + 单调栈，也就是把二维问题拆成一维问题逐个解决。

这个思路的核心逻辑是：对于矩阵的每一行，都以这一行作为矩形的底边，向上看连续的1，把它当作柱状图中柱子的高度。然后对每一行形成的柱状图，计算最大矩形面积。遍历完所有行，答案自然就出来了。

1.2 为什么用单调栈而不是暴力枚举

暴力做法其实很好想：枚举矩形左上角和右下角，然后检查这个区域内是否全是1，复杂度是O(n³·m³)级别，根本没法用。换成前缀和优化后复杂度仍然很高，处理大矩阵时会超时。

单调栈的思路则完全不同，它能在O(n)时间内求出一个柱状图中最大的矩形面积。配合逐行扫描，整个二维矩阵的复杂度是O(m·n)，m是行数，n是列数，这是目前公认最优雅的做法。而且代码量不大，背下来也不难，面试时可以手写出来。

打个比方：柱状图求最大矩形，就像你在看一排高低不一的建筑，想找一个最大的矩形广告牌横跨其中。这个广告牌的宽取决于最短的那栋楼，所以你需要在每个位置都能快速知道“向左能延伸到哪、向右能延伸到哪”——单调栈干的就是这件事。

2. 核心前置知识：柱状图中最大矩形

2.1 暴力解法的问题

先看一维问题：给你一个数组 heights，每个元素代表柱子的高度，求这个柱状图中能够形成的最大矩形面积。

最暴力的写法是枚举每一根柱子作为矩形的高度，然后向左向右扩展，直到遇到比它矮的柱子为止。这样每个柱子都需要左右扫描，最坏情况下是O(n²)，比如柱子高度单调递增时，每根柱子都要向左扫完整个数组。

java复制// 暴力版本，只作为思路参考
public int largestRectangleAreaBruteForce(int[] heights) {
    int maxArea = 0;
    int n = heights.length;
    for (int i = 0; i < n; i++) {
        int left = i;
        int right = i;
        // 向左扩展
        while (left > 0 && heights[left - 1] >= heights[i]) {
            left--;
        }
        // 向右扩展
        while (right < n - 1 && heights[right + 1] >= heights[i]) {
            right++;
        }
        maxArea = Math.max(maxArea, heights[i] * (right - left + 1));
    }
    return maxArea;
}

这个版本的问题很明显：大量重复扫描。每根柱子都独立地左右找边界，前面柱子扫描过的信息完全没有被复用。

2.2 单调栈如何优化：维护递增信息

单调栈的做法是：维护一个栈内柱子高度单调递增的栈，实际上存的是索引。遍历每个柱子时：

• 如果当前柱子高度 >= 栈顶柱子高度，直接入栈（因为当前柱子还没法确定栈顶柱子的右边界，后面可能还有更高的柱子）。
• 如果当前柱子高度 < 栈顶柱子高度，说明栈顶柱子的右边界已经确定了，就是当前柱子的位置。此时弹出栈顶柱子，计算以它为高度的矩形面积。

这里的关键是：为什么弹出的时候能计算面积？因为栈里存的是递增序列，弹出的柱子左侧最近的比它矮的柱子，就是它弹出后的新栈顶（或者栈空则是-1，即数组左边界之外），右侧最近的比它矮的柱子就是当前遍历到的柱子。左右边界都确定了，宽度就是 right - left - 1，面积自然就算出来了。

这里有个细节特别重要：面积计算用的是弹出时确定的左右边界，而不是柱子本身在数组中的位置。我第一次写的时候就搞反了，直接用柱子索引算宽度，结果很多用例算出来都不对。

3. Java代码实现：从柱状图到最大子矩阵

3.1 柱状图最大矩形的Java实现

先把一维版本的完整代码写出来，后面二维版本直接复用它：

java复制public int largestRectangleArea(int[] heights) {
    if (heights == null || heights.length == 0) {
        return 0;
    }
    int maxArea = 0;
    Deque<Integer> stack = new ArrayDeque<>();
    // 关键技巧：在数组末尾追加一个高度为0的哨兵柱
    int[] newHeights = new int[heights.length + 1];
    System.arraycopy(heights, 0, newHeights, 0, heights.length);
    newHeights[heights.length] = 0;

    for (int i = 0; i < newHeights.length; i++) {
        // 当栈不为空且当前高度小于栈顶高度时，弹出并计算面积
        while (!stack.isEmpty() && newHeights[i] < newHeights[stack.peek()]) {
            int height = newHeights[stack.pop()];
            int left = stack.isEmpty() ? -1 : stack.peek();
            int width = i - left - 1;
            maxArea = Math.max(maxArea, height * width);
        }
        stack.push(i);
    }
    return maxArea;
}

哨兵柱那个技巧强烈推荐加上。不加哨兵的话，遍历结束后栈里可能还残留着柱子，需要额外处理一次。加了高度为0的末尾哨兵，因为0一定比栈里所有柱子矮，所以遍历到哨兵时会把栈里剩下的柱子全部弹出并完成面积计算，代码干净很多。

3.2 二维矩阵的完整实现

现在把一维解法扩展到二维。思路是：逐行扫描矩阵，用一个一维数组 heights 记录每一列在当前行位置向上连续1的个数。遇到当前行某个位置是1，heights[j] 就加1；遇到0，heights[j] 就重置为0（因为柱子断了）。

java复制public int maximalRectangle(int[][] matrix) {
    if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
        return 0;
    }
    int rows = matrix.length;
    int cols = matrix[0].length;
    int[] heights = new int[cols];
    int maxArea = 0;

    for (int i = 0; i < rows; i++) {
        // 更新当前行的柱状图高度
        for (int j = 0; j < cols; j++) {
            if (matrix[i][j] == 1) {
                heights[j] += 1;
            } else {
                heights[j] = 0;
            }
        }
        // 计算当前柱状图的最大矩形面积
        maxArea = Math.max(maxArea, largestRectangleArea(heights));
    }
    return maxArea;
}

public int largestRectangleArea(int[] heights) {
    int maxArea = 0;
    Deque<Integer> stack = new ArrayDeque<>();
    int[] newHeights = new int[heights.length + 1];
    System.arraycopy(heights, 0, newHeights, 0, heights.length);
    newHeights[heights.length] = 0;

    for (int i = 0; i < newHeights.length; i++) {
        while (!stack.isEmpty() && newHeights[i] < newHeights[stack.peek()]) {
            int height = newHeights[stack.pop()];
            int left = stack.isEmpty() ? -1 : stack.peek();
            int width = i - left - 1;
            maxArea = Math.max(maxArea, height * width);
        }
        stack.push(i);
    }
    return maxArea;
}

这就是完整的解法，总共不到40行代码。主函数逐行更新高度数组，然后复用一维函数计算结果，思路非常清晰。

3.3 复杂度分析与参数选择

• 时间复杂度：O(m·n)。外层循环遍历m行，内层对每个元素更新heights是O(1)，调用largestRectangleArea其实是O(n)，所以整体是O(m·n)。
• 空间复杂度：O(n)。heights数组长度是列数，单调栈的长度最多也是n+1，不随行数增长。

关于输入矩阵类型的说明：我这里用的是 int[][]，元素是0和1。有些题目的输入是 char[][]，元素是字符 '0' 和 '1'，这时候判断条件要写成 matrix[i][j] == '1'，千万别搞混。我之前面试时有一次就是没注意输入类型，直接用 == 1 判断char，结果字符和数字比较一直不相等，查了半天。如果是LeetCode 85题，输入就是 char[][]，注意区分。

4. 三种变体场景与扩展：不是所有“最大子矩阵”都长一样

4.1 变体一：求最大全1正方形

如果题目改成“最大正方形”而不是“最大矩形”，解法会简单很多。用DP，设 dp[i][j] 表示以 (i, j) 为右下角的最大正方形边长，则：

java复制public int maximalSquare(int[][] matrix) {
    if (matrix == null || matrix.length == 0) {
        return 0;
    }
    int rows = matrix.length;
    int cols = matrix[0].length;
    int[][] dp = new int[rows][cols];
    int maxSide = 0;
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            if (matrix[i][j] == 1) {
                if (i == 0 || j == 0) {
                    dp[i][j] = 1;
                } else {
                    dp[i][j] = Math.min(Math.min(dp[i-1][j], dp[i][j-1]), dp[i-1][j-1]) + 1;
                }
                maxSide = Math.max(maxSide, dp[i][j]);
            }
        }
    }
    return maxSide * maxSide;
}

这个公式的原理是：一个 (i, j) 位置能构成多大正方形，取决于它左上、上方、左方三个位置的正方形边长，取最小值再加1。你可以想象成正向扩展到极限——只有三个方向都够大，当前位置才能形成更大的正方形。

4.2 变体二：求矩阵中所有元素之和最大的子矩阵

这是另一个经典问题，不是求全1矩形，而是求一个二维矩阵中元素和最大的连续子矩阵，可以包含负数。这其实是一维“最大子数组和”的二维扩展。

解法是枚举上下边界，把列压缩成一维数组，然后用Kadane算法求最大子数组和。复杂度O(n²·m)，n是行数，m是列数。

java复制public int maxSumSubmatrix(int[][] matrix) {
    if (matrix == null || matrix.length == 0) {
        return 0;
    }
    int rows = matrix.length;
    int cols = matrix[0].length;
    int maxSum = Integer.MIN_VALUE;
    for (int top = 0; top < rows; top++) {
        int[] sums = new int[cols];
        for (int bottom = top; bottom < rows; bottom++) {
            for (int j = 0; j < cols; j++) {
                sums[j] += matrix[bottom][j];
            }
            int currentMax = sums[0];
            int globalMax = sums[0];
            for (int j = 1; j < cols; j++) {
                currentMax = Math.max(sums[j], currentMax + sums[j]);
                globalMax = Math.max(globalMax, currentMax);
            }
            maxSum = Math.max(maxSum, globalMax);
        }
    }
    return maxSum;
}

这也说明了学算法不要死记模板，关键在于：一维问题的解法往往能通过枚举或逐行扫描的方式扩展到二维。掌握了这个思维，很多看起来很难的题目都能找到突破口。

4.3 变体三：返回最大矩形的坐标而不是面积

有些场景下不只要面积，还要定位最大矩形的位置。这需要在计算过程中记录高度最大时的柱子索引以及左右边界。

修改方式是在 largestRectangleArea 中，每次计算面积时额外记录：

java复制// 计算面积时记录索引
if (height * width > maxArea) {
    maxArea = height * width;
    bestLeft = left + 1;
    bestRight = i - 1;
    bestHeight = height;
}

注意这里 bestLeft = left + 1，因为left是左边界外最近矮柱的索引，真正的左边界要从它后面一个开始；同理 bestRight = i - 1，因为右边界是当前柱子的前一个位置。这个细节很绕，建议画个图理解一下。实际开发中如果是做图像处理、表格识别这类需求，定位坐标比面积更有用。

5. 常见问题与排查技巧实录

5.1 栈里残留数据没有处理干净

这个问题我在初学单调栈时反复遇到。如果不用哨兵，遍历完成后，栈内还留着一些柱子的索引，这些柱子的右边界应该是数组末尾 n，但它们还没有被弹出计算面积。

解决方法有两个：一是像我上面代码那样加一个高为0的哨兵柱；二是在循环结束后额外处理栈内剩余元素。我强烈推荐哨兵法，因为代码更统一，不容易漏。如果不想复制数组，也可以直接判断索引越界，但代码逻辑会稍微复杂。

5.2 索引边界计算的经典错误：宽度到底怎么算

宽度公式 width = i - left - 1，很多人搞不清为什么不是 i - left 或者 i - left + 1。

原因在于：left 是左边第一个比弹出柱子矮的柱子索引，i 是右边第一个比它矮的柱子索引。以弹出柱子为高，能扩展的矩形范围是 (left, i) 这个开区间，即 left + 1 到 i - 1。所以个数是 (i - 1) - (left + 1) + 1 = i - left - 1。

举个例子：数组 [2, 1, 5, 6, 2, 3]，当遍历到索引4（高度2）时，栈里是 [1, 3]，栈顶是高度6（索引3），需要弹出。此时 i=4，弹出后栈顶是 left=1，宽度是 4 - 1 - 1 = 2，对应的是索引2和3两根柱子，高度是6的那根，面积为12。这个例子的关键是要明白：虽然弹出的是高度6，但它的左边界不是索引3自己，而是栈里的前一个索引1，因为中间被弹出的更高柱子都被它挡住了。

5.3 算法无法处理矩阵全为0的情况吗？

其实可以。如果矩阵全为0，那么每一行的 heights 数组都会在上一次遍历时被重置为0，largestRectangleArea 返回0，最终结果是0。这是符合预期的。需要担心的反而是边界条件：矩阵为空、矩阵行长度为0、矩阵列长度为0。代码里已经在入口处做了判空，建议自己也测试一下空矩阵和单行、单列的情况。

5.4 Java实现时用ArrayDeque还是Stack？

这里强烈建议用 ArrayDeque，不要用 Stack 类。原因有几个：

• Stack 继承自 Vector，所有方法都加了 synchronized 锁，性能有损耗。
• ArrayDeque 是双端队列实现，push和pop的效率更高。
• Stack 的API语义过于老旧，现代Java开发中已经不推荐使用。

实测单是替换容器类，在10万级别的数据量上，性能就能提升10%~20%。虽然面试时往往不会专门拷问这个点，但写出更地道的代码是加分项。

5.5 大矩阵性能陷阱：频繁扩容

如果矩阵特别大，比如几千行几千列，largestRectangleArea 每次都要新建数组并复制，会产生大量垃圾对象。如果是在批量处理场景中调用，建议在外部定义一个固定长度的数组，用一个额外参数代表有效高度长度，避免每次复制。

java复制public int largestRectangleArea(int[] heights, int len) {
    int maxArea = 0;
    Deque<Integer> stack = new ArrayDeque<>();
    for (int i = 0; i <= len; i++) {
        int curHeight = (i == len) ? 0 : heights[i];
        while (!stack.isEmpty() && curHeight < heights[stack.peek()]) {
            int height = heights[stack.pop()];
            int left = stack.isEmpty() ? -1 : stack.peek();
            int width = i - left - 1;
            maxArea = Math.max(maxArea, height * width);
        }
        stack.push(i);
    }
    return maxArea;
}

不过这种优化属于锦上添花，面试和普通刷题场景用不到，了解即可。

6. 现场手撕代码的加分写法

很多读者是在面试场景下用这个题，所以补充一点手撕代码时的实用技巧。面试官不只看最终结果，更看重你的思路演进过程，我建议按下面的顺序来说：

• 先回答暴力解法，明确说出时间复杂度的瓶颈在哪里。
• 再说降维思路：逐行扫描，把二维矩阵转成一行一行的柱状图。
• 然后引入单调栈，解释为什么它能帮我们快速找到每个柱子左右两侧第一个更矮的位置。
• 最后补上哨兵柱的优化，让代码更简洁。

如果面试官追问“这个解法还能不能优化”，可以从空间角度提：理论上可以用原地数组记录高度（但代码可读性会变差）。也可以提分治思路：每次选最低的柱子，分别递归处理左右两边，但实际意义不大，单调栈已经是最优解了。

另外还有一个细节：有些面试官会问如果矩阵是稀疏的（大量0少量1），怎么优化。这时候可以考虑按行遍历时跳过全0的行，或者用稀疏矩阵的存储方式（比如存储每个1的坐标），但因为题目本身时间限制少，鲜少要求做这种深度优化，能分析到这一层已经很加分了。

7. 测试用例设计：拿这些用例验证一遍

写完代码一定要测试，我习惯准备以下几类用例：

其中最简单也最容易出问题的是全1矩阵。全1矩阵中，每一行的heights都从1变成2、3、4，最终最大面积就是整个矩阵的面积。如果这个用例都没过，基本就是高度数组的更新逻辑写错了。

我在本地测试时通常写一个简单的测试方法循环跑，确保这些用例全部通过才提交。刷题时不要只盯着LeetCode的测试用例，自己设计边界用例往往能找到隐藏问题。

8. 从这道题延伸出去：算法思维如何迁移

说句实在话，这个题是“换皮不换骨”的典型代表。单调栈求柱状图最大矩形是一维基础题，最大子矩阵是二维扩展，而二维问题在面试中通常都是这么出：先问一维的情况，再拉成二维。掌握了这套递进方式，很多题目就不觉得陌生了。

同样的思路还能迁移到哪些场景？

• 图像处理中寻找最大连通白色区域的外接矩形。
• 数据分析中找表格里连续有效数据的最大区域。
• 11题“盛最多水的容器”虽然用的是双指针，但也是求最大面积，可以对比理解。
• LeetCode 1504题“统计全为1的子矩形数量”，和本题思路相近，只不过需要统计所有数量。

如果刷题时间有限，优先把这个题吃透，它同时涵盖了动态规划思想（逐行更新高度）、栈的高级应用（单调栈）、边界处理技巧，性价比非常高。

最后分享一个真实经历

我当年刷这题的时候，卡在宽度公式上整整两天，因为一直没有把“弹出时左边界是新的栈顶”这个逻辑想透，总以为弹出柱子后栈顶就代表它的左边界。后来自己画了一组柱状图，从状态1逐步推演到状态3，才突然想明白。所以如果你现在也被某个点卡住，不用着急，画图推演一遍远比反复看代码有效。

这道题我觉得很有价值的地方在于：它不会让你背一个复杂的动态规划状态转移方程，而是让你真正理解栈为什么能高效维护“最近更小元素”这个信息。理解了这个问题，很多看似无关的题型——比如接雨水、直方图中最大矩形——都能串起来了。

如果你用Java复现过程中还有哪里没跑通，欢迎在评论区把代码或者报错贴出来，我们一起看看。