单调栈算法解析：解决每日温度问题的高效方法

1. 问题背景与需求分析

每日温度问题（Daily Temperatures）是LeetCode上的一道经典算法题（编号739），也是面试中高频出现的栈结构应用题。题目要求：给定一个温度列表temperatures，返回一个列表answer，其中answer[i]表示在第i天后需要等待多少天才能遇到更高的温度。如果未来没有更高温度，则在该位置用0代替。

这个问题的实际应用场景非常广泛：

• 农业领域预测作物生长周期
• 能源行业优化太阳能板发电效率
• 物流冷链运输的温度监控
• 气象数据分析中的温度变化趋势预测

2. 暴力解法与复杂度分析

2.1 双重循环实现

最直观的解法是使用双重循环：

java复制public int[] dailyTemperatures(int[] temperatures) {
    int n = temperatures.length;
    int[] answer = new int[n];
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            if (temperatures[j] > temperatures[i]) {
                answer[i] = j - i;
                break;
            }
        }
    }
    return answer;
}

时间复杂度：O(n²) —— 对于每个元素都要遍历后续所有元素
空间复杂度：O(1) —— 除了结果数组外不需要额外空间

2.2 暴力解法的优化空间

虽然这种解法简单直接，但当输入规模达到10^5量级时（LeetCode测试用例常见规模），n²的时间复杂度将导致超时。我们需要寻找更高效的算法。

3. 单调栈解法详解

3.1 单调栈的核心思想

单调栈（Monotonic Stack）是一种特殊的栈结构，其中的元素保持单调递增或递减的顺序。在本题中，我们使用单调递减栈：

• 栈中存储的是温度的索引（而非温度值本身）
• 从栈底到栈顶，对应的温度值依次递减
• 当遇到比栈顶温度高的新温度时，触发计算结果

3.2 Java实现代码

java复制public int[] dailyTemperatures(int[] temperatures) {
    int n = temperatures.length;
    int[] answer = new int[n];
    Deque<Integer> stack = new ArrayDeque<>();
    
    for (int i = 0; i < n; i++) {
        while (!stack.isEmpty() && temperatures[i] > temperatures[stack.peek()]) {
            int prevIndex = stack.pop();
            answer[prevIndex] = i - prevIndex;
        }
        stack.push(i);
    }
    
    return answer;
}

3.3 算法执行过程解析

以输入[73,74,75,71,69,72,76,73]为例：

1. i=0 (73): 栈空 → push(0)
2. i=1 (74): 74>73 → pop(0), answer[0]=1-0=1 → push(1)
3. i=2 (75): 75>74 → pop(1), answer[1]=2-1=1 → push(2)
4. i=3 (71): 71<75 → push(3)
5. i=4 (69): 69<71 → push(4)
6. i=5 (72):
   • 72>69 → pop(4), answer[4]=5-4=1
   • 72>71 → pop(3), answer[3]=5-3=2
   • 72<75 → push(5)
7. i=6 (76):
   • 76>72 → pop(5), answer[5]=6-5=1
   • 76>75 → pop(2), answer[2]=6-2=4
   • 栈空 → push(6)
8. i=7 (73): 73<76 → push(7)

最终answer数组：[1,1,4,2,1,1,0,0]

3.4 复杂度分析

时间复杂度：O(n) —— 每个元素最多入栈、出栈各一次
空间复杂度：O(n) —— 最坏情况下所有元素都在栈中

4. 算法优化与变种

4.1 从右向左遍历的解法

java复制public int[] dailyTemperatures(int[] T) {
    int n = T.length;
    int[] answer = new int[n];
    Deque<Integer> stack = new ArrayDeque<>();
    
    for (int i = n - 1; i >= 0; i--) {
        while (!stack.isEmpty() && T[i] >= T[stack.peek()]) {
            stack.pop();
        }
        answer[i] = stack.isEmpty() ? 0 : stack.peek() - i;
        stack.push(i);
    }
    
    return answer;
}

优势：在某些情况下可以减少比较次数

4.2 使用数组模拟栈

对于性能要求极高的场景，可以用数组替代Stack类：

java复制public int[] dailyTemperatures(int[] temperatures) {
    int n = temperatures.length;
    int[] answer = new int[n];
    int[] stack = new int[n];
    int top = -1;
    
    for (int i = 0; i < n; i++) {
        while (top >= 0 && temperatures[i] > temperatures[stack[top]]) {
            int prevIndex = stack[top--];
            answer[prevIndex] = i - prevIndex;
        }
        stack[++top] = i;
    }
    
    return answer;
}

性能提升：减少Deque的包装类开销

5. 单调栈的常见应用场景

5.1 类似LeetCode题目

• 496. 下一个更大元素 I
• 503. 下一个更大元素 II
• 84. 柱状图中最大的矩形
• 42. 接雨水

5.2 实际工程应用

1. 股票价格分析：寻找下一个更高/低的股价
2. 网络流量监控：检测流量突增的时间点
3. 资源调度系统：预测任务等待时间
4. 时序数据库：优化时间序列数据的查询

6. 常见错误与调试技巧

6.1 典型错误案例

1. 栈中存储温度值而非索引：

   • 导致无法计算天数差
   • 修正：始终存储数组索引

2. 忽略相等温度的情况：

   • 题目要求严格大于
   • 注意循环条件中的比较运算符

3. 边界条件处理不当：

   • 空输入数组
   • 所有温度相同的情况
   • 温度单调递减的情况

6.2 调试方法

1. 可视化跟踪法：

   • 打印每次循环后的栈状态
   • 对照手动计算的预期结果

2. 小规模测试用例：

   • [30,40,50] → [1,1,0]
   • [50,40,30] → [0,0,0]
   • [30,30,30] → [0,0,0]

3. 边界测试：

   • 空数组[]
   • 单元素数组[100]

7. 性能对比实测

使用JMH进行基准测试（单位：ms/op）：

关键发现：

1. 数据量越大，单调栈优势越明显
2. 数组模拟栈比Deque实现快约40%
3. 暴力解法在小规模数据时反而更快（常数项更小）

8. 扩展思考：分布式场景下的解决方案

对于超大规模温度数据集（如全球气象站数据），可以考虑：

1. 分治策略：

   • 按时间或地理位置分区
   • 每个分区单独计算
   • 合并边界结果

2. 流式处理：

   • 使用Kafka等消息队列
   • 滑动窗口计算
   • 状态保存与恢复

3. 近似算法：

   • 采样关键时间点
   • 牺牲精度换取速度
   • 适用于趋势分析场景

9. 面试技巧与答题要点

9.1 面试考察重点

1. 能否识别出单调栈的应用场景
2. 对时间/空间复杂度的分析能力
3. 边界条件的处理是否全面
4. 代码实现的简洁性与鲁棒性

9.2 回答建议

1. 先阐述暴力解法及其局限性
2. 引出单调栈的优化思路
3. 详细解释算法执行过程
4. 讨论时间/空间复杂度
5. 提及可能的优化方向

9.3 常见follow-up问题

1. 如何处理温度相同的情况？
2. 如果要找前一个更高温度如何修改？
3. 如果温度数据是实时流怎么处理？
4. 如何扩展到二维温度场的情况？

10. 个人实践心得

在实际编码中有几个值得注意的细节：

1. 栈的选择：

   • 推荐使用ArrayDeque而非Stack类
   • 性能更好且更符合现代Java规范

2. 索引处理：

   • 在循环内部定义prevIndex变量
   • 避免多次调用stack.pop()

3. 代码可读性：

   • 给单调栈变量起有意义的名字
   • 添加关键步骤的注释

4. 测试策略：

   • 优先测试单调递减/递增的极端情况
   • 添加随机生成的大规模测试用例

一个经过工程优化的最终版本：

java复制public int[] dailyTemperaturesOptimized(int[] temps) {
    final int n = temps.length;
    final int[] result = new int[n];
    final int[] stack = new int[n];
    int stackSize = 0;
    
    for (int currentDay = 0; currentDay < n; currentDay++) {
        while (stackSize > 0 && temps[currentDay] > temps[stack[stackSize - 1]]) {
            int prevDay = stack[--stackSize];
            result[prevDay] = currentDay - prevDay;
        }
        stack[stackSize++] = currentDay;
    }
    
    return result;
}

这个实现：

1. 使用基本类型数组替代Deque
2. 用stackSize变量显式跟踪栈顶
3. 所有变量使用final修饰确保不变性
4. 变量命名更加语义化