单调栈题目：每日温度

题目

标题和出处

标题：每日温度

出处：739. 每日温度

难度

6 级

题目描述

要求

给定整数数组 $\text{temperatures}$ 表示每日温度，返回数组 $\text{answer}$，其中 $\text{answer[i]}$ 是在第 $\text{i}$ 天之后出现更高温度需要等待的天数。如果在将来没有更高温度，则 $\text{answer[i] = 0}$。

示例

示例 1：

输入：$\text{temperatures = [73,74,75,71,69,72,76,73]}$
输出：$\text{[1,1,4,2,1,1,0,0]}$

示例 2：

输入：$\text{temperatures = [30,40,50,60]}$
输出：$\text{[1,1,1,0]}$

示例 3：

输入：$\text{temperatures = [30,60,90]}$
输出：$\text{[1,1,0]}$

数据范围

• $\text{1}\le \text{temperatures.length}\le {\text{10}}^{\text{5}}$
• $\text{30}\le \text{temperatures[i]}\le \text{100}$

解法

思路和算法

最简单的做法是对于数组 $\text{temperatures}$ 中的每个元素，向后遍历找到第一个比当前元素大的元素，计算下标差。假设数组 $\text{temperatures}$ 的长度是 $n$，上述做法的时间复杂度是 $O(n^2)$，会超出时间限制，因此需要优化。

上述做法中存在重复计算。对于同一个下标 $i$，可能存在 $m$ 个下标 $j_1$ 到 $j_m$，满足对于每个 $j_k$（$1\le k\le m$）都有 $\text{temperatures}[i]$ 是 $\text{temperatures}[j_k]$ 后面的第一个比 $\text{temperatures}[j_k]$ 大的元素，因此对于每个 $j_k$ 都有 $\text{answer}[j_k]=i-j_k$。如果按照上述做法，则下标 $i$ 被遍历了 $m$ 次。

为了避免重复计算，上述做法应改为：从左到右遍历数组 $\text{temperatures}$，对于每个下标 $i$，寻找在结果数组 $\text{answer}$ 中的所有尚未填入值的下标 $j$（显然 $j<i$），令 $\text{answer}[j]=i-j$。需要确保结果数组 $\text{answer}$ 中的每个元素都用 $O(1)$ 的时间填入一次，总时间复杂度是 $O(n)$。

可以使用单调栈实现，单调栈存储数组 $\text{temperatures}$ 的下标，满足从栈底到栈顶的下标对应的元素单调递减（非严格）。

创建长度为 $n$ 的结果数组 $\text{answer}$，初始时对于所有 $0\le i<n$ 都有 $\text{answer}[i]=0$。从左到右遍历数组 $\text{temperatures}$，对于每个下标 $i$，进行如下操作：

1. 如果栈不为空且栈顶下标对应的温度低于当前温度（即 $\text{temperatures}[i]$），则将栈顶下标出栈，用 $j$ 表示出栈下标，则令 $\text{answer}[j]=i-j$，重复该操作直到栈为空或者栈顶下标对应的温度高于或等于当前温度；

2. 将 $i$ 入栈。

遍历结束时，返回 $\text{answer}$。

上述解法的正确性说明如下。

1. 上述操作中，在将下标 $i$ 入栈之前会将对应温度低于 $\text{temperatures}[i]$ 的下标出栈，只有当栈为空或者栈顶下标对应的温度高于或等于 $\text{temperatures}[i]$ 时才会将下标 $i$ 入栈，因此新入栈的下标对应的温度一定不会高于栈内已有下标对应的温度，单调栈满足从栈底到栈顶的下标对应的元素单调递减。

2. 当遍历到下标 $i$ 时，如果单调栈不为空，则栈内下标一定小于 $i$。假设下标 $j$ 在栈内，满足 $j<i$ 且 $\text{temperatures}[j]<\text{temperatures}[i]$，考虑两种情况，分别为 $j$ 是栈顶下标和 $j$ 不是栈顶下标。

   • 如果 $j$ 是栈顶下标，假设存在下标 $k$ 满足 $j<k<i$ 且 $\text{temperatures}[j]<\text{temperatures}[k]$，则在遍历到下标 $k$ 时，下标 $j$ 就会出栈，下标 $j$ 在栈内说明尚未在下标 $j$ 右边遇到比 $\text{temperatures}[j]$ 大的元素，因此 $\text{temperatures}[i]$ 是 $\text{temperatures}[j]$ 右边第一个大于 $\text{temperatures}[j]$ 的元素。

   • 如果 $j$ 不是栈顶下标，假设下标 $j^{\prime }$ 更接近栈顶，则有 $j<j^{\prime }$（根据入栈顺序）和 $\text{temperatures}[j]\ge \text{temperatures}[j^{\prime }]$（根据单调栈的性质），当 $\text{temperatures}[j]<\text{temperatures}[i]$ 时必有 $\text{temperatures}[j^{\prime }]<\text{temperatures}[i]$，因此比下标 $j$ 更接近栈顶的下标都会出栈，当 $j$ 变成栈顶下标时，即为上一种情况。

以下是示例 1 的计算过程。

1. 下标 $0$ 处的元素是 $73$，将 $0$ 入栈，$\text{stack}=[0:73]$，其中左边为栈底，右边为栈顶，栈内存储下标，为了方便阅读加上了下标对应的元素值。

2. 下标 $1$ 处的元素是 $74$，由于 $73<74$，因此将 $0$ 出栈，$\text{answer}[0]=1-0=1$，将 $1$ 入栈，$\text{stack}=[1:74]$。

3. 下标 $2$ 处的元素是 $75$，由于 $74<75$，因此将 $1$ 出栈，$\text{answer}[1]=2-1=1$，将 $2$ 入栈，$\text{stack}=[2:75]$。

4. 下标 $3$ 处的元素是 $71$，将 $3$ 入栈，$\text{stack}=[2:75,3:71]$。

5. 下标 $4$ 处的元素是 $69$，将 $4$ 入栈，$\text{stack}=[2:75,3:71,4:69]$。

6. 下标 $5$ 处的元素是 $72$，由于 $69<72$，$71<72$，因此将 $4$ 和 $3$ 出栈，$\text{answer}[4]=5-4=1$，$\text{answer}[3]=5-3=2$，将 $5$ 入栈，$\text{stack}=[2:75,5:72]$。

7. 下标 $6$ 处的元素是 $76$，由于 $72<76$，$75<76$，因此将 $5$ 和 $2$ 出栈，$\text{answer}[5]=6-5=1$，$\text{answer}[2]=6-2=4$，将 $6$ 入栈，$\text{stack}=[6:76]$。

8. 下标 $7$ 处的元素是 $73$，将 $7$ 入栈，$\text{stack}=[6:76,7:73]$。

结果数组 $\text{answer}=[1,1,4,2,1,1,0,0]$。

代码

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

复杂度分析

• 时间复杂度：$O(n)$，其中 $n$ 是数组 $\text{temperatures}$ 的长度。需要从左到右遍历数组 $\text{temperatures}$ 计算结果数组 $\text{answer}$ 的值，由于每个下标最多入栈和出栈各一次，结果数组 $\text{answer}$ 中的每个元素的计算时间是 $O(1)$，因此时间复杂度是 $O(n)$。

• 空间复杂度：$O(n)$，其中 $n$ 是数组 $\text{temperatures}$ 的长度。空间复杂度主要取决于栈空间，栈内元素个数不会超过 $n$。