Java单调栈解析：LeetCode每日温度问题实战

1. Java版LeetCode热题100之每日温度：单调栈经典应用深度解析

作为一名在算法领域摸爬滚打多年的开发者，我经常遇到需要高效解决"下一个更大元素"这类问题的场景。今天要详细拆解的LeetCode第739题《每日温度》，正是单调栈最经典的入门案例。这个题目看似简单，但其中蕴含的算法思想却非常精妙，值得每个Java开发者深入掌握。

1.1 问题本质与业务场景

题目要求我们根据每日温度列表，计算每一天需要等待多少天才能遇到更高的温度。这在实际开发中有着广泛的应用场景：

• 金融领域：预测股票价格首次超过当前价位所需的时间
• 电商系统：分析商品销量何时会突破当前水平
• 运维监控：判断服务器负载何时会超过当前阈值
• 游戏开发：计算技能冷却时间或伤害峰值间隔

这类问题的共同特点是：需要为序列中的每个元素，快速找到其后第一个满足某种条件的元素。在算法领域，这被称为NGE（Next Greater Element）问题。

1.2 暴力解法及其局限性

最直观的解法是双重循环：对每一天i，向后遍历直到找到第一个温度更高的天数j，然后计算j-i。这种方法虽然简单直接，但时间复杂度高达O(n²)，当n=10⁵时（LeetCode的测试用例规模），必然会导致超时。

java复制// 暴力解法示例（仅作对比，实际不可用）
public int[] dailyTemperaturesBruteForce(int[] temperatures) {
    int n = temperatures.length;
    int[] ans = new int[n];
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            if (temperatures[j] > temperatures[i]) {
                ans[i] = j - i;
                break;
            }
        }
    }
    return ans;
}

这个解法的主要问题在于：对于每个元素都进行了独立的向后扫描，没有利用已经处理过的信息，造成了大量重复计算。

2. 单调栈的核心思想与实现

2.1 单调栈的工作原理

单调栈是一种特殊的栈结构，它始终保持栈内元素的单调性（递增或递减）。对于本题，我们需要的是单调递减栈：

1. 栈中存储的是数组下标（而非温度值本身）
2. 从栈底到栈顶，对应的温度值是递减的
3. 当遇到一个比栈顶温度高的新元素时，就开始"结算"栈顶元素

这种结构的精妙之处在于：它能够将O(n²)的暴力解法优化到O(n)的时间复杂度，因为每个元素最多入栈和出栈各一次。

2.2 Java实现详解

下面是使用Deque实现的单调栈解法：

java复制import java.util.Deque;
import java.util.LinkedList;

class Solution {
    public int[] dailyTemperatures(int[] temperatures) {
        int n = temperatures.length;
        int[] ans = new int[n];
        Deque<Integer> stack = new LinkedList<>();
        
        for (int i = 0; i < n; i++) {
            // 当前温度比栈顶温度高时，进行结算
            while (!stack.isEmpty() && temperatures[i] > temperatures[stack.peek()]) {
                int prevIndex = stack.pop();
                ans[prevIndex] = i - prevIndex;
            }
            stack.push(i); // 当前索引入栈
        }
        return ans;
    }
}

2.3 执行过程示例分析

以输入temperatures = [73,74,75,71,69,72,76,73]为例，我们逐步分析栈的变化：

2.4 复杂度分析

• 时间复杂度：O(n)。虽然代码中有嵌套循环，但每个元素最多被压入和弹出栈各一次，因此总操作次数不超过2n。
• 空间复杂度：O(n)。最坏情况下（如完全递减序列），栈需要存储所有元素。

3. 优化与变种实现

3.1 数组模拟栈优化

对于性能敏感的场景，我们可以用数组代替Deque来模拟栈，减少对象创建开销：

java复制public int[] dailyTemperaturesOptimized(int[] temperatures) {
    int n = temperatures.length;
    int[] ans = 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--];
            ans[prevIndex] = i - prevIndex;
        }
        stack[++top] = i;
    }
    return ans;
}

这种实现方式在LeetCode上运行时可以减少约20%的时间消耗，适合对性能要求极高的场景。

3.2 反向遍历解法

除了单调栈，我们还可以利用温度范围有限（30-100）的特点，采用反向遍历的解法：

java复制public int[] dailyTemperaturesReverse(int[] temperatures) {
    int n = temperatures.length;
    int[] ans = new int[n];
    int[] next = new int[101]; // 记录每个温度最近出现的下标
    Arrays.fill(next, Integer.MAX_VALUE);
    
    for (int i = n - 1; i >= 0; i--) {
        int current = temperatures[i];
        int minIndex = Integer.MAX_VALUE;
        
        // 检查所有比current高的温度中最近的下标
        for (int t = current + 1; t <= 100; t++) {
            if (next[t] < minIndex) {
                minIndex = next[t];
            }
        }
        
        if (minIndex != Integer.MAX_VALUE) {
            ans[i] = minIndex - i;
        }
        
        next[current] = i; // 更新当前温度的最新下标
    }
    return ans;
}

这种解法的时间复杂度是O(n*71)（因为温度范围是71个可能值），虽然也是线性时间，但通用性不如单调栈，仅适用于温度范围有限的特殊场景。

4. 常见问题与调试技巧

4.1 调试技巧

在实现单调栈时，最容易出现的错误是：

1. 混淆存储的是下标还是温度值
2. 循环条件判断错误（温度比较方向）
3. 天数计算错误（应该是当前i减去栈顶元素的下标）

调试时可以打印栈的状态和ans数组的变化：

java复制System.out.println("i=" + i + ", temp=" + temperatures[i] + 
                   ", stack=" + stack + ", ans=" + Arrays.toString(ans));

4.2 边界情况测试

必须测试的边界情况包括：

1. 单元素数组：[100] → 预期输出[0]
2. 完全递减序列：[90,80,70,60] → [0,0,0,0]
3. 完全递增序列：[60,70,80,90] → [1,1,1,0]
4. 平缓变化序列：[70,70,70] → [0,0,0]
5. 大随机数组：验证性能和正确性

4.3 常见面试问题

面试中可能会被问到：

Q：为什么栈中要存储下标而不是温度值？
A：因为我们需要计算天数差（j-i），只存储温度值无法知道原始位置信息。

Q：如果温度范围很大（比如0到10^9），哪种方法更好？
A：单调栈方法不受温度范围限制，始终是最佳选择。

Q：如何修改代码来返回下一个更高温度的值而非天数？
A：只需将ans[prevIndex] = i - prevIndex改为ans[prevIndex] = temperatures[i]。

5. 实际工程应用案例

5.1 股票交易信号系统

在量化交易中，我们可以用类似的算法检测突破信号：

java复制public int[] nextBreakthrough(double[] prices, double threshold) {
    int n = prices.length;
    int[] signals = new int[n];
    Deque<Integer> stack = new LinkedList<>();
    
    for (int i = 0; i < n; i++) {
        while (!stack.isEmpty() && 
               prices[i] > prices[stack.peek()] * (1 + threshold)) {
            int idx = stack.pop();
            signals[idx] = i - idx;
        }
        stack.push(i);
    }
    return signals;
}

5.2 系统监控告警

监控服务器CPU使用率，预测何时会超过当前负载：

java复制public int[] nextOverloadAlert(int[] cpuUsage, int threshold) {
    int n = cpuUsage.length;
    int[] alerts = new int[n];
    Deque<Integer> stack = new LinkedList<>();
    
    for (int i = 0; i < n; i++) {
        while (!stack.isEmpty() && cpuUsage[i] > cpuUsage[stack.peek()] + threshold) {
            int idx = stack.pop();
            alerts[idx] = i - idx;
        }
        stack.push(i);
    }
    return alerts;
}

5.3 电商库存预警

预测商品销量何时会超过当前水平的20%：

java复制public int[] nextSalesPeak(int[] sales) {
    int n = sales.length;
    int[] peaks = new int[n];
    Deque<Integer> stack = new LinkedList<>();
    
    for (int i = 0; i < n; i++) {
        while (!stack.isEmpty() && sales[i] > sales[stack.peek()] * 1.2) {
            int idx = stack.pop();
            peaks[idx] = i - idx;
        }
        stack.push(i);
    }
    return peaks;
}

6. 相关题目拓展

掌握了每日温度问题后，可以尝试以下LeetCode变种题目：

1. 496. 下一个更大元素 I：更基础的版本，没有重复元素
2. 503. 下一个更大元素 II：循环数组的处理
3. 556. 下一个更大元素 III：数字重组问题
4. 84. 柱状图中最大的矩形：单调栈的经典应用
5. 42. 接雨水：单调栈与双指针的结合

特别推荐练习503题（循环数组版本），需要在原有基础上增加一些处理：

java复制public int[] nextGreaterElements(int[] nums) {
    int n = nums.length;
    int[] ans = new int[n];
    Arrays.fill(ans, -1);
    Deque<Integer> stack = new LinkedList<>();
    
    for (int i = 0; i < n * 2; i++) {
        int idx = i % n;
        while (!stack.isEmpty() && nums[idx] > nums[stack.peek()]) {
            ans[stack.pop()] = nums[idx];
        }
        if (i < n) stack.push(idx);
    }
    return ans;
}

7. 算法模板与记忆技巧

为了快速解决类似问题，可以记忆以下单调栈模板：

java复制// 单调递减栈模板（找下一个更大元素）
Deque<Integer> stack = new LinkedList<>();
for (int i = 0; i < n; i++) {
    while (!stack.isEmpty() && nums[i] > nums[stack.peek()]) {
        int prev = stack.pop();
        // 处理prev和i的关系
    }
    stack.push(i);
}

// 单调递增栈模板（找下一个更小元素）
Deque<Integer> stack = new LinkedList<>();
for (int i = 0; i < n; i++) {
    while (!stack.isEmpty() && nums[i] < nums[stack.peek()]) {
        int prev = stack.pop();
        // 处理prev和i的关系
    }
    stack.push(i);
}

记忆要点：

1. 栈中存储的是下标
2. 比较方向与要找的元素关系相反（找更大用递减栈）
3. 处理时机在while循环内部

8. 性能对比与选择建议

不同解法的性能特点：

选择建议：

1. 面试中优先使用单调栈，展示算法能力
2. 工程中如果值域确实很小（如温度30-100），可以考虑反向遍历
3. 绝对不要在生产环境使用暴力解法

9. 学习路径建议

要彻底掌握单调栈及相关问题，建议按照以下路径学习：

1. 基础阶段：

   • 739.每日温度（本文）
   • 496.下一个更大元素I
   • 503.下一个更大元素II

2. 进阶阶段：

   • 84.柱状图中最大的矩形
   • 42.接雨水
   • 85.最大矩形

3. 综合应用：

   • 316.去除重复字母
   • 402.移掉K位数字
   • 907.子数组的最小值之和

练习时要注意：

• 先自己思考暴力解法
• 分析暴力解法中的重复计算
• 思考如何用栈结构优化
• 画图理解栈的变化过程
• 总结模板和解题模式

10. 工程实践中的注意事项

在实际项目中使用单调栈算法时，需要注意：

1. 输入验证：

   • 检查输入数组是否为null
   • 处理空数组的特殊情况
   • 验证温度值是否在合理范围内

2. 资源管理：

   • 对于极大数组，考虑使用数组模拟栈减少对象创建
   • 在多线程环境下使用时需要同步控制

3. 日志记录：

   • 在关键步骤添加日志，方便问题排查
   • 记录算法执行时间，监控性能

4. 测试覆盖：

   • 单元测试要覆盖各种边界情况
   • 性能测试要模拟生产数据规模

5. 文档注释：

   • 在代码中添加详细注释说明算法原理
   • 在项目文档中记录算法选择和性能特征

java复制/**
 * 使用单调栈解决每日温度问题
 * @param temperatures 温度数组，范围[30,100]，长度[1,10^5]
 * @return 等待天数数组，0表示没有更高温度
 * @throws IllegalArgumentException 如果输入为null或包含非法值
 */
public int[] dailyTemperatures(int[] temperatures) {
    // 参数校验
    if (temperatures == null) {
        throw new IllegalArgumentException("输入不能为null");
    }
    
    // 主算法逻辑
    // ...
}

11. 算法可视化技巧

为了更好地理解单调栈的工作原理，可以采用可视化方法：

1. 横向图表法：

   • 绘制温度曲线图
   • 用不同颜色标记栈内元素
   • 动态展示元素的入栈和出栈过程

2. 纵向堆栈图：

   • 垂直绘制栈结构
   • 显示每次操作后栈的状态变化
   • 标注被弹出的元素及其计算结果

3. 双指针标记法：

   • 用两个指针分别表示当前处理位置和栈顶位置
   • 动态展示指针移动和比较过程

这些可视化技巧不仅有助于自己理解算法，在面试中向面试官展示时也能留下深刻印象。

12. 与其他算法的对比

单调栈与一些相似算法的关系：

1. 与滑动窗口的区别：

   • 滑动窗口处理的是固定大小的子区间
   • 单调栈关注的是下一个满足条件的元素

2. 与动态规划的关系：

   • 都是利用已计算信息优化后续计算
   • 单调栈更专注于序列关系问题

3. 与双指针的异同：

   • 双指针通常用于有序数组或链表
   • 单调栈适用于需要记住历史信息的场景

理解这些区别有助于在遇到新问题时快速选择合适的算法。

13. 高频错误与修正

在实现单调栈时，开发者常犯的错误包括：

1. 错误1：栈中存储温度值而非下标

   • 修正：始终存储数组下标，方便计算天数差

2. 错误2：比较方向弄反

   • 修正：找更大元素用递减栈，找更小元素用递增栈

3. 错误3：未处理栈中剩余元素

   • 修正：根据题意，剩余元素通常对应0值，Java数组默认初始化为0

4. 错误4：天数计算错误

   • 修正：应该是当前索引i减去栈顶元素索引，而非相反

5. 错误5：边界条件处理不当

   • 修正：添加对空输入、单元素数组等情况的处理

14. 语言特性优化

针对Java语言的特定优化技巧：

1. 使用ArrayDeque替代LinkedList：
   • ArrayDeque在大多数情况下性能更好
   • 但需要预估初始容量避免扩容

java复制Deque<Integer> stack = new ArrayDeque<>(temperatures.length);

2. 基本类型优化：

   • 对于性能敏感场景，可以考虑使用int[]模拟栈
   • 避免自动装箱/拆箱开销

3. 并行流尝试：

   • 虽然这个问题难以并行化，但可以尝试分块处理
   • 需要注意线程安全和合并结果的复杂度

4. JVM调优：

   • 对于极大数组，调整JVM堆大小
   • 考虑使用原生内存避免GC压力

15. 扩展思考与挑战

对于已经掌握基础解法的同学，可以思考以下进阶问题：

1. 如果不仅要找下一个更高温度，还要记录温度升高的幅度怎么办？

   • 可以扩展ans数组为二维，同时记录天数和温差

2. 如何实时处理温度数据流？

   • 考虑使用可持久化数据结构
   • 或者设计增量处理算法

3. 如果温度是浮点数怎么办？

   • 单调栈依然适用
   • 但反向遍历的优化方法不再可行

4. 如何找出所有更高温度而不仅仅是第一个？

   • 需要修改算法维护更多信息
   • 可能要用到更复杂的数据结构

这些思考可以帮助深化对算法本质的理解，培养解决变种问题的能力。