单调栈算法详解：原理、应用与LeetCode实战

1. 单调栈算法深度解析：从原理到实战

在算法面试和日常编程中，单调栈是一种高效解决特定问题的数据结构。它能在O(n)时间复杂度内处理"寻找数组中每个元素前后第一个比它大/小的元素"这类问题。本文将从底层原理出发，通过大量代码示例和实际应用场景，带你彻底掌握这一重要算法技巧。

1.1 单调栈的核心思想

单调栈的本质是维护一个具有单调性的栈结构（递增或递减），通过巧妙的元素入栈和出栈操作，在遍历数组时快速找到满足特定条件的元素。其核心优势在于：

• 时间复杂度优化：将看似需要O(n²)的暴力解法优化到O(n)
• 空间效率：仅需额外O(n)空间存储栈结构
• 逻辑简洁：代码通常不超过20行，但能解决复杂问题

关键理解：栈的单调性不是预先设定的，而是由问题需求和比较逻辑自然形成的。这是很多初学者容易混淆的点。

1.2 四种基本模式详解

1.2.1 寻找后一个更大元素（Next Greater Element）

这是最经典的单调栈应用场景。我们需要为数组中每个元素找到它右边第一个比它大的元素。

cpp复制vector<int> nextGreater(vector<int>& nums) {
    int n = nums.size();
    vector<int> res(n, -1); // 默认-1表示没有更大的元素
    stack<int> st; // 存储元素索引
    
    for (int i = 0; i < n; i++) {
        // 当前元素比栈顶大时，说明找到了栈顶元素的"下一个更大元素"
        while (!st.empty() && nums[i] > nums[st.top()]) {
            res[st.top()] = nums[i]; // 存储实际值
            // 也可以存储索引差：i - st.top()
            st.pop();
        }
        st.push(i);
    }
    return res;
}

工作原理分析：

1. 栈中保持递减顺序（栈底到栈顶）
2. 遇到比栈顶大的元素时，说明找到了栈顶元素的解
3. 弹出已解决的栈顶元素，直到当前元素可以安全入栈
4. 最终栈中剩余元素表示没有找到更大元素的项

时间复杂度：每个元素最多入栈和出栈一次，因此是O(n)

1.2.2 寻找后一个更小元素（Next Smaller Element）

与寻找更大元素对称，只需改变比较方向：

cpp复制vector<int> nextSmaller(vector<int>& nums) {
    int n = nums.size();
    vector<int> res(n, -1);
    stack<int> st; // 单调递增栈
    
    for (int i = 0; i < n; i++) {
        while (!st.empty() && nums[i] < nums[st.top()]) {
            res[st.top()] = nums[i];
            st.pop();
        }
        st.push(i);
    }
    return res;
}

关键区别：

• 比较符号从>变为<
• 栈自然保持递增顺序（栈底到栈顶）

1.2.3 寻找前一个更大元素（Previous Greater Element）

通过改变遍历方向，可以寻找左侧的更大元素：

cpp复制vector<int> prevGreater(vector<int>& nums) {
    int n = nums.size();
    vector<int> res(n, -1);
    stack<int> st; // 仍然保持递减栈特性
    
    // 关键变化：从右向左遍历
    for (int i = n - 1; i >= 0; i--) {
        while (!st.empty() && nums[i] > nums[st.top()]) {
            res[st.top()] = nums[i];
            st.pop();
        }
        st.push(i);
    }
    return res;
}

逆向遍历的奥秘：

• 从右向左遍历时，"前一个"实际上是指原序列中左侧的元素
• 栈的逻辑保持不变，但遍历方向改变了问题的语义

1.2.4 寻找前一个更小元素（Previous Smaller Element）

同样通过改变遍历方向和比较符号实现：

cpp复制vector<int> prevSmaller(vector<int>& nums) {
    int n = nums.size();
    vector<int> res(n, -1);
    stack<int> st; // 单调递增栈
    
    for (int i = n - 1; i >= 0; i--) {
        while (!st.empty() && nums[i] < nums[st.top()]) {
            res[st.top()] = nums[i];
            st.pop();
        }
        st.push(i);
    }
    return res;
}

1.3 通用模板与思维模式

通过上述四种模式，我们可以提炼出一个通用思维框架：

1. 确定问题需求：找更大还是更小？找前面还是后面的？
2. 设定遍历方向：
   • 找后面的元素：正向遍历(0→n-1)
   • 找前面的元素：反向遍历(n-1→0)
3. 确定比较符号：
   • 找更大元素：nums[i] > nums[st.top()]
   • 找更小元素：nums[i] < nums[st.top()]
4. 栈的单调性：由比较逻辑自然形成，无需预先设定

通用代码模板：

cpp复制vector<int> monotonicStackTemplate(vector<int>& nums, bool findGreater, bool findPrevious) {
    int n = nums.size();
    vector<int> res(n, -1);
    stack<int> st;
    
    // 确定遍历方向
    int start = findPrevious ? n - 1 : 0;
    int end = findPrevious ? -1 : n;
    int step = findPrevious ? -1 : 1;
    
    for (int i = start; i != end; i += step) {
        // 确定比较条件
        bool condition = findGreater 
            ? (nums[i] > nums[st.top()]) 
            : (nums[i] < nums[st.top()]);
            
        while (!st.empty() && condition) {
            res[st.top()] = nums[i]; // 或索引i
            st.pop();
            // 需要更新condition以防栈变化
            if (!st.empty()) {
                condition = findGreater 
                    ? (nums[i] > nums[st.top()]) 
                    : (nums[i] < nums[st.top()]);
            }
        }
        st.push(i);
    }
    return res;
}

2. 经典问题实战解析

2.1 LeetCode 739. 每日温度

问题描述：给定每日温度列表，返回一个列表表示需要等待多少天才能遇到更暖和的温度。

cpp复制class Solution {
public:
    vector<int> dailyTemperatures(vector<int>& temperatures) {
        int n = temperatures.size();
        vector<int> ans(n, 0);
        stack<int> st;
        
        for (int i = 0; i < n; i++) {
            // 当前温度比栈顶高时，计算天数差
            while (!st.empty() && temperatures[i] > temperatures[st.top()]) {
                ans[st.top()] = i - st.top();
                st.pop();
            }
            st.push(i);
        }
        return ans;
    }
};

关键点：

1. 这是"找后一个更大元素"的变体
2. 结果存储的是索引差而非温度值本身
3. 初始化结果为0，表示没有更暖和的天气时保持0

时间复杂度分析：O(n)，每个索引最多入栈和出栈一次

2.2 LeetCode 84. 柱状图中最大矩形

问题描述：在柱状图中找出能勾勒出的最大矩形面积。

cpp复制class Solution {
public:
    int largestRectangleArea(vector<int>& heights) {
        int n = heights.size();
        stack<int> st;
        vector<int> left(n, -1);  // 左边第一个比当前小的索引
        vector<int> right(n, n);  // 右边第一个比当前小的索引
        
        // 找右边第一个更小的元素
        for (int i = 0; i < n; i++) {
            while (!st.empty() && heights[i] < heights[st.top()]) {
                right[st.top()] = i;
                st.pop();
            }
            st.push(i);
        }
        
        st = stack<int>(); // 清空栈
        
        // 找左边第一个更小的元素
        for (int i = n - 1; i >= 0; i--) {
            while (!st.empty() && heights[i] < heights[st.top()]) {
                left[st.top()] = i;
                st.pop();
            }
            st.push(i);
        }
        
        // 计算最大面积
        int maxArea = 0;
        for (int i = 0; i < n; i++) {
            maxArea = max(maxArea, heights[i] * (right[i] - left[i] - 1));
        }
        return maxArea;
    }
};

算法思路：

1. 对每个柱子，找到左右两边第一个比它矮的柱子
2. 矩形宽度 = 右边界 - 左边界 - 1
3. 矩形高度 = 当前柱子的高度
4. 取所有可能矩形中的最大值

优化技巧：

• 可以通过一次遍历同时计算左右边界，进一步优化代码
• 使用哨兵节点简化边界条件处理

2.3 LeetCode 42. 接雨水

问题描述：计算柱状图能接多少雨水。

方法一：动态规划（前缀/后缀最大值）

cpp复制class Solution {
public:
    int trap(vector<int>& height) {
        int n = height.size();
        if (n == 0) return 0;
        
        vector<int> leftMax(n), rightMax(n);
        
        leftMax[0] = height[0];
        for (int i = 1; i < n; i++) {
            leftMax[i] = max(leftMax[i-1], height[i]);
        }
        
        rightMax[n-1] = height[n-1];
        for (int i = n-2; i >= 0; i--) {
            rightMax[i] = max(rightMax[i+1], height[i]);
        }
        
        int ans = 0;
        for (int i = 0; i < n; i++) {
            ans += min(leftMax[i], rightMax[i]) - height[i];
        }
        return ans;
    }
};

方法二：单调栈解法

cpp复制class Solution {
public:
    int trap(vector<int>& height) {
        int n = height.size();
        int ans = 0;
        stack<int> st;
        
        for (int right = 0; right < n; right++) {
            while (!st.empty() && height[right] > height[st.top()]) {
                int bottom = st.top();
                st.pop();
                
                if (st.empty()) break;
                
                int left = st.top();
                int h = min(height[left], height[right]) - height[bottom];
                int w = right - left - 1;
                ans += h * w;
            }
            st.push(right);
        }
        return ans;
    }
};

单调栈解法解析：

1. 维护一个递减栈（栈底到栈顶）
2. 当遇到比栈顶高的柱子时，可能形成凹槽
3. 凹槽的宽度 = 当前索引 - 左边界索引 - 1
4. 凹槽的高度 = 左右边界较小值 - 底部高度
5. 每次计算一个水平层的雨水量

3. 高级技巧与常见错误

3.1 边界条件处理

单调栈问题中常见的边界问题包括：

• 空栈情况下的栈顶访问
• 数组为空或只有一个元素的情况
• 没有满足条件的元素时的默认值处理

防御性编程建议：

cpp复制while (!st.empty() && nums[i] > nums[st.top()]) {
    // 先检查栈是否为空再访问top()
}

3.2 索引存储与值存储

根据问题需求，栈中可以存储：

• 元素索引（更通用，可以获取值和位置信息）
• 元素值（更简单，但信息有限）

选择建议：

• 需要位置信息时（如计算天数差、宽度等）必须存储索引
• 仅需要值时，存储值可能更直观

3.3 单调栈的变体应用

单调栈不仅可以解决"下一个更大/小元素"问题，还可以应用于：

• 滑动窗口最大值问题
• 最大矩形问题
• 股票跨度问题
• 去除重复字母问题

3.4 常见错误与调试技巧

常见错误：

1. 混淆递增栈和递减栈的使用场景
2. 遍历方向设置错误
3. 结果数组初始化不当
4. 边界条件处理不完整

调试技巧：

1. 打印栈内容在每次迭代中的变化
2. 使用小测试案例手动验证
3. 检查最终栈中剩余元素的处理
4. 验证极端情况（空数组、全部相同元素等）

4. 扩展思考与性能优化

4.1 空间复杂度优化

某些情况下可以通过复用数组或更巧妙的设计减少空间使用：

• 将结果数组作为栈使用
• 原地修改输入数组（如果不需保留原始数据）
• 使用位运算压缩存储

4.2 并行化可能性

单调栈本质上是顺序处理的，难以并行化。但在某些特殊情况下：

• 可以分块处理然后合并结果
• 使用多线程处理独立的部分问题

4.3 替代方案比较

虽然单调栈是解决这类问题的最佳方案，但了解替代方法有助于深入理解：

4.4 实际工程应用

单调栈在以下场景中有实际应用：

• 编译器中的语法分析
• 数据库查询优化
• 图形渲染算法
• 时间序列分析

掌握单调栈不仅有助于算法面试，更能提升解决实际工程问题的能力。建议通过LeetCode和其他编程平台的类似题目进行大量练习，直到能够不假思索地写出正确的单调栈实现。