每日温度与单调栈：从暴力到O(n)的力扣经典题解析

力扣热题100里的“每日温度”，是我每次给人讲单调栈时几乎必提的一道题。它在原站上的题号其实是739，但因为在热题100的刷题清单里经常被排到第72位，很多朋友都直接叫它“72每日温度（栈）”。这道题看起来只是让你算“每天要等几天才能遇到更高温度”，但只要把它吃透，栈的先进后出特性、单调栈的维护方式、索引差值的计算思路，基本都能一次性理顺。

我自己刚刷这道题的时候，第一反应就是双重循环暴力扫，提交后才发现数据规模一大就开始吃力。后来把单调栈想明白，才意识到这一类“找右边第一个更大值”的问题，几乎都有固定的套路。这篇就把我从题面解读、暴力卡点、单调栈推导、代码实现到变体题串联的完整过程都写出来，希望能帮你少走一点弯路。

1. 力扣热题100这道“每日温度”究竟在考什么

1.1 题面到底说了什么

题目给了一个整数数组 temperatures，数组长度可以到 10^5 级别，每个温度在 30 到 100 之间。你要对每一天回答一个问题：从这一天开始，要等多少天才能等到一个“比今天更高”的温度？如果后面永远没有更高温度，就写 0。

举个最经典的例子：

text复制temperatures = [73, 74, 75, 71, 69, 72, 76, 73]
输出          = [1, 1, 4, 2, 1, 1, 0, 0]

第 0 天温度是 73，第 1 天就升温到 74，所以等 1 天；第 2 天温度是 75，要一直等到第 6 天的 76，中间隔了 4 天；最后一天后面没人了，自然是 0。

很多人第一眼可能只把它当作一道“模拟题”。但实际上，它考察的是你能不能认识到：当你在顺序扫描数组时，有些“还没等到答案”的状态是可以被临时保存下来的，而这个状态非常适合用栈来维护。

1.2 输出数组比想象中容易读错

这道题最容易踩的坑之一，是答案不是温度差，而是“天数差”。比如第 2 天温度 75，第 6 天温度 76，虽然温度只高了 1 度，但因为是第 6 天减去第 2 天，答案就是 4，而不是 76 - 75 = 1。

我见过有朋友一开始把输出理解成“右边第一个更高温度距离自己的索引差”，写代码的时候却下意识去算 temperatures[j] - temperatures[i]，结果数值完全不对。所以要养成习惯：只要题目里说“等几天”，你就应该条件反射地想到索引相减，比如 j - i。

这里还有个很容易被忽略的细节：题目要的是“更高”，不是“更高或相等”。也就是说，如果后面某一天的温度和当前一样，是不能算数的。这个细节会直接影响单调栈里比较符号用 < 还是 <=，后面我会专门展开讲。

1.3 这种“等待未来事件”的场景哪来的

如果把温度换成股价、请求时间、任务队列，你就能感觉到这道题的实用背景了。比如在交易系统里，你想知道“当前这个价格之后，再过多久会出现一个更高的价格”；在运维告警系统里，可能想知道“这次低负载之后，多久会恢复高负载”。这一类问题的共同点，都是要面向未来查找第一个满足条件的元素，并且这个“未来”是不断向右推进的。

也因此，“下一个更大元素”成了算法面试的一个高频家族，而每日温度就是家族里最友好的一道入门题。如果你能把它的原理讲清楚，后面遇到 LeetCode 496、503 这类变体题，思路是能直接平移过去的。

2. 先写出暴力解，再搞清楚它为什么慢

2.1 第一版双重循环到底怎么写

刷题第一步不要总想着最优解，尤其是对这种入门级题目，先写暴力至少能保证你把题目意思吃透。暴力思路很直白：对每个下标 i，从 i + 1 开始往后找，找到第一个大于 temperatures[i] 的位置 j，记录 j - i；找不到就保持 0。

python复制class Solution:
    def dailyTemperatures(self, temperatures: List[int]) -> List[int]:
        n = len(temperatures)
        ans = [0] * n
        for i in range(n):
            for j in range(i + 1, n):
                if temperatures[j] > temperatures[i]:
                    ans[i] = j - i
                    break
        return ans

这段代码逻辑一点毛病都没有，示例也能过。但当你交上去之后，遇到一个特别长的递减序列，比如 [100, 99, 98, ...]，问题就来了：第 0 天要一直扫到数组末尾才发现没有更高的温度，第 1 天又要从自己开始扫到末尾，每个位置都在做重复劳动，整体就是 O(n^2) 的时间复杂度。

2.2 暴力解法到底把时间浪费在哪

我们来看一个具体例子：temperatures = [75, 71, 69, 72, 76]。

如果按暴力做，当 i = 1 时，要找 71 的下一个更高温度，会先看到 69，不行，再看 72，可以，于是答案记 2。当 i = 2 时，要找 69 的下一个更高温度，又会看到 72，答案记 1。

发现没有，69 和 71 在分别查找时，都重复扫描了中间这一段区间。而且当 72 出现时，它其实可以一次性“解决”前面好几个比它低的温度，因为在它之前，只要温度比 72 低，那它们的下一个更高温度都有可能是 72。然而暴力循环里，前面的每个元素都是独立往后找，根本不记得“我之前已经看过哪些温度了”。

换句话说，暴力解法浪费在：每个元素都独自重新遍历一次右侧区间，而这次遍历得到的信息没有共享给左侧的元素。我们真正想要的，是一种能“回头批量处理”的结构：当新温度足够高时，把前面所有比它低、且还在等待答案的日子一次性结算掉。谁能做到这种“后面来的先把前面最近的先处理掉”的效果？栈。

2.3 从暴力到栈，思维的跳跃点在哪

很多教程直接抛出单调栈结论，读者很容易懵。其实跳跃点就一句话：当我们从左往右扫描时，有些天数的答案还没确定，可以把它们先“押”在一个容器里；等某一天温度升高了，就去容器里找出那些“比新温度低”的旧日子，把它们的答案结算掉。

问题只在于：用什么容器、按什么顺序取出来最合适。

可以这样想。新温度升高时，它能先满足谁？只能是离它最近的那个还没被满足的日子。比如 [75, 71, 69, 72] 里，72 出现时，先满足的是 69，然后才轮到 71；而 75 比 72 高，所以 75 继续等着。这种“最近来的先被处理”的次序，正是后进先出。所以容器的答案就出来了：栈。

3. 单调栈解法：栈里存什么、什么时候出栈，一步步拆给你看

3.1 为什么不是队列而是栈

有人可能会问：用队列从左边开始存“还没等到答案的日子”，先进先出不行吗？不行。因为“先来的”不一定“先被解决”。

还是看 [75, 71, 69, 72] 这个例子。从左往右扫描时，75 先到，接着 71 到，69 到。如果放在队列里，队头是 75，但 72 到来时，它只能解决 69 和 71，解决不了 75。如果你用队列，就得从队尾往回处理，这就违背了队列“先进先出”的语义。

而栈天然合适：每次新温度到来，我们从栈顶开始往外弹，弹出的都是“最近且还没等到答案”的日子。这个弹出顺序，和我们实际处理答案的顺序完全一致，都是后进先出。

我经常用一个生活化的比喻：这就像一列人在排队买限量商品，但规则不是按排队顺序补货，而是谁的需求刚好被满足谁就走。栈顶是站得离“当前时刻”最近的人，新来的高价买家（高温）只能先和队伍尾部的人成交，不可能越过近处的人去满足排在最前面的人。这个形象的画面感，能帮你记住为什么用栈。

3.2 栈里到底存什么：索引，不是温度

这是很多人写代码时第一个纠结的地方。栈里的每个元素，到底放温度值，还是放下标？

答案是放下标。

原因是两方面的。第一，判断是否需要弹出时，我们要拿 temperatures[当前下标] 和 temperatures[栈顶下标] 比较，这需要栈顶能够反查出温度，存下标完全可以做到。第二，结算答案时，我们需要计算“等待天数”，也就是 当前下标 - 栈顶下标，如果栈里只存温度值，这个差值根本算不出来。所以为了既能比较温度、又能算天数，栈里必须存下标。

这一步想清楚之后，代码的框架也就清楚了：

text复制遍历每个下标 i：
    如果栈不为空，并且 temperatures[i] > temperatures[栈顶下标]：
        说明栈顶这一天已经等到了下一个更高温度
        弹出栈顶下标 prev
        ans[prev] = i - prev
    把当前下标 i 压入栈

循环结束后，栈里剩下的下标，就是那些从它之后再也没有遇到更高温度的日子，它们的答案保持初始值 0 即可。

3.3 单调栈这个“单调”到底指什么

很多人都听过“单调栈”，但一到自己写就分不清该单调递增还是单调递减。这里有个实用的判断方法：你想让栈里的温度呈现什么趋势。

以正序遍历为例，我们只会在 temperatures[i] > temperatures[栈顶] 时弹出栈顶。也就是说，如果一个新温度比栈顶还低或相等，它不会被弹出，而是直接入栈。最终栈里从栈底到栈顶，温度是递减的，准确说是“非严格递减”，因为相等的温度不会被弹出。

举个例子，处理完 [75, 71, 69] 之后，栈从底到顶存放的下标对应温度是 75、71、69，一路向下递减。这就是为什么叫“单调递减栈”。

这个单调性的作用，是帮助栈内元素保持一种“等待状态”。栈底温度最高，它最挑剔，可能要等很久；栈顶温度最低，它最容易满足，所以每次新温度进来，最先检查的就是栈顶这个“最不挑”的。

3.4 手动推演一个完整例子

纸上谈兵再多，不如把一个用例从头推到尾。我们推 [73, 74, 75, 71, 69, 72, 76, 73]，初始时 ans = [0,0,0,0,0,0,0,0]，空栈。

推演结束后，栈里剩下下标 6 和 7，它们的答案仍然为 0，最终结果正好是：

text复制[1, 1, 4, 2, 1, 1, 0, 0]

你可以对照着这个过程多走几遍。每次弹出时，都是“栈顶温度的答案在这一刻确定了”；而每次没有弹出就入栈时，说明当前温度还不足以成为栈里那些日子的“下一个更高温度”。

3.5 复杂度为什么是 O(n)

单调栈看起来有个 while 循环，会不会是 O(n^2)？不会。关键在于每个下标只会入栈一次，也只会出栈一次。哪怕 while 循环里弹了多个元素，这些元素加起来也不会超过 n 次，因为每个下标最多被弹出一次。整体来看，每个下标最多经历一次 push 和一次 pop，所以总时间复杂度是 O(n)，空间复杂度最坏情况下是 O(n)，比如温度一直下降，所有元素都会留在栈里。

这也是为什么这种解法能稳稳应对 10^5 级别的数据量。暴力解法在数据小的时候也能过，但一旦长度拉满，单调栈的优势就非常明显。

4. 三种语言的写法细节：从模板到自己会写

4.1 C++、Java、Python 的参考实现

先给出最通用的正序遍历写法，语言之间只有栈语法上的差别。

C++ 版本：

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()]) {
                int prev = st.top();
                st.pop();
                ans[prev] = i - prev;
            }
            st.push(i);
        }
        return ans;
    }
};

Java 版本：

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

Python 版本：

python复制class Solution:
    def dailyTemperatures(self, temperatures: List[int]) -> List[int]:
        n = len(temperatures)
        ans = [0] * n
        stack = []
        for i in range(n):
            while stack and temperatures[i] > temperatures[stack[-1]]:
                prev = stack.pop()
                ans[prev] = i - prev
            stack.append(i)
        return ans

这三个版本的逻辑完全一样。新手经常纠结用 stack 还是 Deque，其实无所谓，关键是理解弹出和入栈的时机。

4.2 另一种写法：从右往左遍历，维护右侧候选

除了从左往右扫描，这道题还有第二种常规解法，就是从右往左扫。思路是：对于位置 i，我们需要在它右侧找一个比它高的温度，所以可以在栈里维护右侧还没被淘汰的候选下标。

python复制class Solution:
    def dailyTemperatures(self, temperatures: List[int]) -> List[int]:
        n = len(temperatures)
        ans = [0] * n
        stack = []
        for i in range(n - 1, -1, -1):
            while stack and temperatures[stack[-1]] <= temperatures[i]:
                stack.pop()
            if stack:
                ans[i] = stack[-1] - i
            stack.append(i)
        return ans

这个写法里，while 的条件变成了 temperatures[stack[-1]] <= temperatures[i]。原因是：当右侧栈顶的温度小于等于当前温度时，这个栈顶元素对于更左边任何一天来说，都不可能是“第一个更高的温度”，因为当前这个位置更靠左、温度又不比它低，留着它只会干扰判断，直接丢掉即可。

两种写法都能 AC，但我个人更推荐从左往右的版本。因为它的语义更贴近题目直觉：“当前温度到来，去结算那些等待它的日子”。在面试里从左往右讲，面试官一般也更容易跟上你的思路。

4.3 写模板时最容易漏掉的三件事

第一，ans 数组一定要初始化为 0。网上很多模板默认用了 vector<int> ans(n, 0)，但如果你随手写成 vector<int> ans(n)，C++ 里其实也默认是 0，问题不大；但有些语言或你自己封装的数组不一定，所以显式初始化最稳妥。这样一来，栈最后剩余的元素不用额外处理。

第二，比较符号别搞混。正序遍历时，只有当前温度“严格大于”栈顶温度才触发答案更新。如果你写成 >=，相等温度会被错误弹出。比如 [73, 73, 71, 75]，第 0 天和第 1 天都是 73，第 0 天需要等到第 3 天的 75，差 3 天；如果你在第 1 天就把第 0 天弹出去了，答案会被错误算成 1。更严重的是，被弹出的下标不会再入栈，最终结果完全错乱。

第三，取栈顶之前必须先判空。while 条件里要先写 !stack.isEmpty() 或 stack 非空，再利用短路特性判断温度大小。这个顺序反了，运行时就会报空栈异常。

5. 刷这题最常见的坑和排查思路

5.1 为什么我输出的数组全是 0

如果你写完代码，发现结果全是 0，先看是不是 while 循环压根没执行。常见原因有两个。

一个原因是栈里存了温度值而不是索引，导致 ans[prev] 的下标越界或者结果错乱。还有一个原因是你的比较写成了 temperatures[i] < temperatures[stack.top()]，方向反了，那永远不会触发弹出。

我调试这种问题的方法很简单：打印每一步的 i、当前温度、栈内所有元素、ans 数组。只要推两三个用例，马上就能看出是哪里没有按照预期更新。

5.2 答案错位，多半是索引差写反了

正确写法是 ans[prev] = i - prev，也就是用“当前下标”减去“被弹出的旧下标”。有些朋友一紧张写成 prev - i，得到负数，答案自然不对。

这也可以用语义来记：ans[prev] 表示第 prev 天要等多少天，而它等到的是第 i 天，所以相隔天数是 i - prev，永远不会是负的。

5.3 相等温度到底算不算“更高”

这道题要求严格更高，所以相等不算。但很多题型变体里，“下一个大于等于”或者“下一个不等于”都是可能的，所以在动手之前一定要确认题意。

如果改成“找下一个温度大于等于当前温度”，那正序遍历时弹出条件就要从 > 改成 >=，维护的单调性也会变化。这听起来只差一个等号，实际上对结果影响很大。我自己刷题时，遇到这种边界条件，会专门构造一个包含重复元素的用例来验证，比如 [73, 73, 71, 75]，把答案手算出来再和代码输出对比。

5.4 循环结束后栈里剩下的元素要处理吗

不需要。它们右边没有任何更高温度，答案保持初始化的 0 就行。

有人会担心：栈里剩了元素，会不会影响已经结算过的答案？不会。被弹出的元素答案已经确定，之后它们再也不会入栈；栈里剩下的元素只是暂时没等到答案，等遍历结束，它们的默认 0 正好是正确的。这也是为什么初始化 0 很重要。

5.5 一个小型速查表

6. 每日温度只是起点：单调栈题型地图与面试表达技巧

6.1 同类型题目怎么串起来刷

每日温度的核心套路，一句话总结就是“找每个元素右边第一个比它大的元素位置”。这个套路在 LeetCode 里有一整个系列，我建议你按顺序刷：

从 739 到 503，变化只是“要不要处理循环”；从 503 到 42 和 84，则是把“下一个更大”的思想延伸到“区间边界”。如果你能把每日温度的推导过程吃透，再看后面这些题就不会觉得它们是从零开始的新算法，而只是同一个思维模板的变形。

6.2 面试时怎么把单调栈讲得不卡壳

面试官让你做这道题，很多时候不只看你会不会写，更看你能不能把思路讲清楚。我的建议是不要上来就背“单调栈”三个字，而是按这个顺序讲：

先说我第一反应是暴力，每五天往后找，但是最坏情况 O(n^2)。然后说，我观察到当一个新温度出现时，它可以一次性解决前面若干个比它低的“还没等到答案”的日子。接着说明这个处理顺序是后进先出，所以用栈来保存还没等到答案的下标。最后强调栈里存下标，方便比较温度和计算天数，并用一个例子演示弹出过程。

这样讲的好处是，面试官能顺着你的思路看到你从暴力到优化的完整推理链路。你甚至可以边说边在纸上画栈的变化，效果比沉默写代码好很多。

6.3 我的一些练法体会

刷完每日温度之后，我最大的体会是：算法模板不是背出来的，是靠推演例子推出来的。你可以不看任何题解，只拿 [73, 74, 75, 71, 69, 72, 76, 73] 这组数据，自己画一张类似上面的表格，体会每个元素“什么时候入栈、什么时候出栈、为什么出栈”。只要能把这张表画明白，代码就只是表里规则的翻译。

我也建议你问自己一个问题：如果温度是相等的情况，单调栈里的“单调”还严格成立吗？等你能够解释清楚“因为相等时不会弹出，所以栈内温度是非严格递减”，你对栈的理解就又深了一层。接下来再去做 503、42、84 这些扩展题，你会发现很多卡壳的细节，其实在每日温度里都已经埋下伏笔了。