739. 每日温度
给定一个整数数组
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]
思路（详细版）
我怎么能想到用单调栈呢？ 什么时候用单调栈呢？
通常是一维数组，要寻找任一个元素的右边或者左边第一个比自己大或者小的元素的位置，此时我们就要想到可以用单调栈了。时间复杂度为O(n)。
单调栈的本质是空间换时间，更直白来说，就是用一个栈来记录我们遍历过的元素。
- 单调栈里存放的元素是什么？
单调栈里只需要存放元素的下标i就可以了，如果需要使用对应的元素，直接T[i]就可以获取
2.单调栈里元素是递增呢？ 还是递减呢？
这里我们要使用递增循序（再强调一下是指从栈头到栈底的顺序），因为只有递增的时候，栈里要加入一个元素i的时候，才知道栈顶元素在数组中右面第一个比栈顶元素大的元素是i。
使用单调栈主要有三个判断条件。
- 当前遍历的元素T[i]小于栈顶元素T[st.top()]的情况
- 当前遍历的元素T[i]等于栈顶元素T[st.top()]的情况
- 当前遍历的元素T[i]大于栈顶元素T[st.top()]的情况
把这三种情况分析清楚了，也就理解透彻了。
接下来我们用temperatures = [73, 74, 75, 71, 71, 72, 76, 73]为例来逐步分析，输出应该是 [1, 1, 4, 2, 1, 1, 0, 0]。
首先先将第一个遍历元素加入单调栈
加入T[1] = 74，因为T[1] > T[0]（当前遍历的元素T[i]大于栈顶元素T[st.top()]的情况）。
我们要保持一个递增单调栈（从栈头到栈底），所以将T[0]弹出，T[1]加入，此时result数组可以记录了，result[0] = 1，即T[0]右面第一个比T[0]大的元素是T[1]。
加入T[2]，同理，T[1]弹出
加入T[3]，T[3] < T[2] （当前遍历的元素T[i]小于栈顶元素T[st.top()]的情况），加T[3]加入单调栈。
加入T[4]，T[4] == T[3] （当前遍历的元素T[i]等于栈顶元素T[st.top()]的情况），此时依然要加入栈，不用计算距离，因为我们要求的是右面第一个大于本元素的位置，而不是大于等于！
加入T[5]，T[5] > T[4] （当前遍历的元素T[i]大于栈顶元素T[st.top()]的情况），将T[4]弹出，同时计算距离，更新result
T[4]弹出之后， T[5] > T[3] （当前遍历的元素T[i]大于栈顶元素T[st.top()]的情况），将T[3]继续弹出，同时计算距离，更新result
直到发现T[5]小于T[st.top()]，终止弹出，将T[5]加入单调栈
加入T[6]，同理，需要将栈里的T[5]，T[2]弹出
同理，继续弹出
此时栈里只剩下了T[6]
加入T[7]， T[7] < T[6] 直接入栈，这就是最后的情况，result数组也更新完了。
此时有同学可能就疑惑了，那result[6] , result[7]怎么没更新啊，元素也一直在栈里。
其实定义result数组的时候，就应该直接初始化为0，如果result没有更新，说明这个元素右面没有更大的了，也就是为0。
代码
class Solution {
public:
vector<int> dailyTemperatures(vector<int>& temperatures) {
stack<int>st;
vector<int>result(temperatures.size(),0);
st.push(0);
for(int i=1;i<temperatures.size();i++)
{
if(temperatures[i]<=temperatures[st.top()])
st.push(i);//情况一+情况二
else//情况三
{
while(!st.empty()&&temperatures[i]>temperatures[st.top()])
{
result[st.top()]=i-st.top();//如果当前数大于栈顶，则表示找到了大于栈顶的第一个元素，下标相减求得值
st.pop();
}
st.push(i);//大于的情况，踢完后也要加进去
}
}
return result;
}
};496.下一个更大元素 I
nums1中数字x的 下一个更大元素 是指x在nums2中对应位置 右侧 的 第一个 比x大的元素。给你两个 没有重复元素 的数组
nums1和nums2，下标从 0 开始计数，其中nums1是nums2的子集。对于每个
0 <= i < nums1.length，找出满足nums1[i] == nums2[j]的下标j，并且在nums2确定nums2[j]的 下一个更大元素 。如果不存在下一个更大元素，那么本次查询的答案是-1。返回一个长度为
nums1.length的数组ans作为答案，满足ans[i]是如上所述的 下一个更大元素 。示例 1：
输入：nums1 = [4,1,2], nums2 = [1,3,4,2]. 输出：[-1,3,-1] 解释：nums1 中每个值的下一个更大元素如下所述： - 4 ，用加粗斜体标识，nums2 = [1,3,4,2]。不存在下一个更大元素，所以答案是 -1 。 - 1 ，用加粗斜体标识，nums2 = [1,3,4,2]。下一个更大元素是 3 。 - 2 ，用加粗斜体标识，nums2 = [1,3,4,2]。不存在下一个更大元素，所以答案是 -1 。示例 2：
输入：nums1 = [2,4], nums2 = [1,2,3,4]. 输出：[3,-1] 解释：nums1 中每个值的下一个更大元素如下所述： - 2 ，用加粗斜体标识，nums2 = [1,2,3,4]。下一个更大元素是 3 。 - 4 ，用加粗斜体标识，nums2 = [1,2,3,4]。不存在下一个更大元素，所以答案是 -1 。
思路
这么定义这个result数组初始化应该为多少呢？
题目说如果不存在对应位置就输出 -1 ，所以result数组如果某位置没有被赋值，那么就应该是是-1，所以就初始化为-1。
注意题目中说是两个没有重复元素 的数组 nums1 和 nums2。
没有重复元素，我们就可以用map来做映射了。根据数值快速找到下标，还可以判断nums2[i]是否在nums1中出现过。
然后单调栈，因为求右边第一个比此大的元素，所以，栈头到栈底的顺序，要从小到大，也就是保持栈里的元素为递增顺序。只要保持递增，才能找到右边第一个比自己大的元素。
和上题也是差不多的。
代码
先用map哈希表保持数组1的元素及下标，然后遍历数组2入栈。
class Solution {
public:
vector<int> nextGreaterElement(vector<int>& nums1, vector<int>& nums2) {
stack<int>st;
vector<int>result(nums1.size(),-1);
if(nums1.size()==0)return result;
unordered_map<int,int>umap;//记录数组1内容
for(int i=0;i<nums1.size();i++)
umap[nums1[i]]=i;//记录元素和下标
st.push(0);
for(int i=1;i<nums2.size();i++)
{
if(nums2[i]<=nums2[st.top()])//当前元素小于栈顶元素，push，因为要保证栈顶到栈底是递增的
st.push(i);
else
{
while(!st.empty()&&nums2[i]>nums2[st.top()])
{
if(umap.count(nums2[st.top()])>0)// 检查栈顶元素是否在 nums1 中
{
int index=umap[nums2[st.top()]];//获取栈顶元素在 nums1 中的下标
result[index]=nums2[i];//记录比数组1大的第一个数（在数组2中）的当前值
}
st.pop();//弹出栈顶元素
}
st.push(i);//入栈当前元素
}
}
return result;
}
};举例过程
假设
nums1 = [4, 1, 2]和nums2 = [1, 3, 4, 2]，以下是代码的执行过程：
初始化结果数组：
result = [-1, -1, -1]记录
nums1中每个元素的下标：umap = {4: 0, 1: 1, 2: 2}遍历
nums2：
i = 1，nums2[1] = 3：
3 > 1，处理栈顶元素1：
1在umap中，index = 1，result[1] = 3。- 当前元素
3入栈。i = 2，nums2[2] = 4：
4 > 3，处理栈顶元素3：
3不在umap中。- 当前元素
4入栈。i = 3，nums2[3] = 2：
2 < 4，当前元素2入栈。最终结果：
result = [-1, 3, -1]
503.下一个更大元素II
503. 下一个更大元素 II - 力扣（LeetCode）
给定一个循环数组
nums（nums[nums.length - 1]的下一个元素是nums[0]），返回nums中每个元素的 下一个更大元素 。数字
x的 下一个更大的元素 是按数组遍历顺序，这个数字之后的第一个比它更大的数，这意味着你应该循环地搜索它的下一个更大的数。如果不存在，则输出-1。示例 1:
输入: nums = [1,2,1] 输出: [2,-1,2] 解释: 第一个 1 的下一个更大的数是 2； 数字 2 找不到下一个更大的数； 第二个 1 的下一个最大的数需要循环搜索，结果也是 2。示例 2:
输入: nums = [1,2,3,4,3] 输出: [2,3,4,-1,4]
思路
和第一题差不多。
一种写法就是拼接两段数组。可以不扩充nums，而是在遍历的过程中模拟走了两边nums。
代码
class Solution {
public:
vector<int> nextGreaterElements(vector<int>& nums) {
vector<int>result(nums.size(),-1);
if(nums.size()==0)return result;
stack<int>st;
st.push(0);
for(int i=1;i<nums.size()*2;i++)
{
// 模拟遍历两边nums，注意一下都是用i % nums.size()来操作
if(nums[i%nums.size()]<=nums[st.top()])//一二情况
st.push(i%nums.size());
else
{
while(!st.empty()&&nums[i%nums.size()]>nums[st.top()])
{
result[st.top()]=nums[i%nums.size()];
st.pop();
}
}
st.push(i%nums.size());
}
return result;
}
};
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
