题目描述：
给定一个整数数组
temperatures，表示每天的温度，返回一个数组answer，其中answer[i]是指对于第i天，下一个更高温度出现在几天后。如果气温在这之后都不会升高，请在该位置用0来代替。示例 1:
输入: temperatures = [73,74,75,71,69,72,76,73] 输出: [1,1,4,2,1,1,0,0]示例 2:
输入: temperatures = [30,40,50,60] 输出: [1,1,1,0]示例 3:
输入: temperatures = [30,60,90] 输出: [1,1,0]
解题思路：
方法一：暴力解法
我的思路：对每一天，往后找第一个比它温度高的天，计算天数差。
具体步骤：
-
外层循环 ：枚举每一天
i -
内层循环 ：从
i+1开始往后找，找到第一个temperatures[j] > temperatures[i] -
找到 ：把
j - i存入ans，break -
没找到 ：
flag == 0，存入0
用例子走一遍：
temperatures = [73, 74, 75, 71, 69, 72, 76, 73]
| i | temperaturesi | 往后找第一个更高的 | j-i |
|---|---|---|---|
| 0 | 73 | 74（下标1） | 1 |
| 1 | 74 | 75（下标2） | 1 |
| 2 | 75 | 76（下标6） | 4 |
| 3 | 71 | 72（下标5） | 2 |
| 4 | 69 | 72（下标5） | 1 |
| 5 | 72 | 76（下标6） | 1 |
| 6 | 76 | 没有 | 0 |
| 7 | 73 | 没有 | 0 |
结果：[1, 1, 4, 2, 1, 1, 0, 0] ✅
代码实现：
cpp
class Solution {
public:
vector<int> dailyTemperatures(vector<int>& temperatures) {
vector<int> ans(temperatures.size());
for(int i=0;i<temperatures.size();i++){
for(int j=i+1;j<temperatures.size();j++){
if(temperatures[i]<temperatures[j]){
ans[i]=j-i;
break;
}
}
}
return ans;
}
};复杂度分析：
| 维度 | 复杂度 | 说明 |
|---|---|---|
| 时间复杂度 | O(n²) | 双重循环，最坏情况（递减数组）内层走完 |
| 空间复杂度 | O(1) | 不算输出数组，只用了几个变量 |
问题 ：当 n = 10⁵ 时，O(n²) 约 5×10⁹ 次操作，会超时（TLE）。
缺点：
1. 时间复杂度 O(n²)，会超时
最坏情况：temperatures = [100, 99, 98, ..., 1]（严格递减），每个 i 都要走到末尾，总操作次数约 n²/2。
2. flag 逻辑可以简化
cpp
int flag = 0;
// ...
if (temperatures[i] < temperatures[j]) {
ans.push_back(j - i);
flag++;
break;
}
flag = 0; // ❌ 这行是多余的
flag++ 后立即 break，flag = 0 永远不会执行
逻辑混乱，可以用 bool found 替代3. 代码结构可以优化
- 可以用
ans初始化为全0，找到时直接赋值，省去flag判断
方法二：单调栈(最优解法)
核心思路：
维护一个单调递减栈，存储还没找到"更高温度"的下标。
-
遍历每一天，如果当前温度 > 栈顶下标对应的温度，说明栈顶下标的那一天找到了答案
-
弹出栈顶，记录
i - 栈顶下标 -
把当前下标压入栈
具体过程示例：
temperatures = [73, 74, 75, 71, 69, 72, 76, 73]
i=0, 73: 栈空，压入 → 栈 [0]
i=1, 74: 74 > 73（栈顶0），弹出0，ans[0]=1-0=1
栈空，压入1 → 栈 [1]
i=2, 75: 75 > 74（栈顶1），弹出1，ans[1]=2-1=1
栈空，压入2 → 栈 [2]
i=3, 71: 71 < 75，直接压入 → 栈 [2, 3]
i=4, 69: 69 < 71，直接压入 → 栈 [2, 3, 4]
i=5, 72: 72 > 69（栈顶4），弹出4，ans[4]=5-4=1
72 > 71（栈顶3），弹出3，ans[3]=5-3=2
72 < 75（栈顶2），停止，压入5 → 栈 [2, 5]
i=6, 76: 76 > 72（栈顶5），弹出5，ans[5]=6-5=1
76 > 75（栈顶2），弹出2，ans[2]=6-2=4
栈空，压入6 → 栈 [6]
i=7, 73: 73 < 76，压入 → 栈 [6, 7]
最终: ans = [1, 1, 4, 2, 1, 1, 0, 0] ✅代码实现：
cpp
class Solution {
public:
vector<int> dailyTemperatures(vector<int>& temperatures) {
int n = temperatures.size();
vector<int> ans(n, 0); // 默认全0
stack<int> stk; // 存下标，对应温度单调递减
for (int i = 0; i < n; i++) {
// 当前温度 > 栈顶下标的温度，说明栈顶下标找到了答案
while (!stk.empty() && temperatures[i] > temperatures[stk.top()]) {
int idx = stk.top();
stk.pop();
ans[idx] = i - idx;
}
stk.push(i);
}
return ans;
}
};复杂度分析：
| 维度 | 复杂度 | 说明 |
|---|---|---|
| 时间复杂度 | O(n) | 每个下标最多入栈出栈各一次 |
| 空间复杂度 | O(n) | 栈最多存储 n 个下标 |
两种方法对比：
| 对比维度 | 你的方法（暴力） | 单调栈 |
|---|---|---|
| 时间复杂度 | O(n²) | O(n) |
| 空间复杂度 | O(1) | O(n) |
| 能否AC | ❌ 超时 | ✅ 通过 |
| 核心思想 | 逐个往后找 | 维护单调递减栈 |
| 代码复杂度 | 简单 | 中等 |
单调栈的优缺点：
优点：
-
✅ 时间复杂度 O(n)：每个元素最多入栈出栈一次
-
✅ 代码简洁：核心逻辑只有几行
-
✅ 适用面广：单调栈可以解决很多"找下一个更大/更小元素"的问题
缺点：
-
❌ 空间复杂度 O(n)：需要额外的栈
-
❌ 思路不够直观：需要理解"单调栈"的思想
-
❌ 不容易想到：相比暴力解法，需要一定的算法积累
单调栈的通用模板：
cpp
vector<int> nextGreaterElement(vector<int>& nums) {
int n = nums.size();
vector<int> ans(n, -1); // 默认-1（没找到）
stack<int> stk; // 存下标
for (int i = 0; i < n; i++) {
while (!stk.empty() && nums[i] > nums[stk.top()]) {
int idx = stk.top();
stk.pop();
ans[idx] = i - idx; // 或 nums[i]
}
stk.push(i);
}
return ans;
}变种：
-
找下一个更大元素：
nums[i] > nums[stk.top()] -
找下一个更小元素：
nums[i] < nums[stk.top()] -
找上一个更大元素：从右往左遍历