目录
为什么单调栈的时间复杂度是O(n)
尽管for 循环里面还有while 循环，但是里面的while最多执行n次，所以最大执行2n次，即时间复杂度为O(n)。
不能只看有几层循环，因为很多情况下内循环是不执行的，可以这样理解，n个元素每个元素最多进栈一次出栈一次，所以是n
496. 下一个更大元素 I
leetcode-cn.com/problems/ne…
给定两个 没有重复元素 的数组 nums1 和 nums2 ，其中nums1 是 nums2 的子集。找到 nums1 中每个元素在 nums2 中的下一个比其大的值。
nums1 中数字 x 的下一个更大元素是指 x 在 nums2 中对应位置的右边的第一个比 x 大的元素。如果不存在，对应位置输出 -1 。
示例 1:
输入: nums1 = [4,1,2], nums2 = [1,3,4,2].
输出: [-1,3,-1]
解释:
对于num1中的数字4，你无法在第二个数组中找到下一个更大的数字，因此输出 -1。
对于num1中的数字1，第二个数组中数字1右边的下一个较大数字是 3。
对于num1中的数字2，第二个数组中没有下一个更大的数字，因此输出 -1。
示例 2:
输入: nums1 = [2,4], nums2 = [1,2,3,4].
输出: [3,-1]
解释:
对于 num1 中的数字 2 ，第二个数组中的下一个较大数字是 3 。
对于 num1 中的数字 4 ，第二个数组中没有下一个更大的数字，因此输出 -1 。
方法一：暴力
先找到nums1的数在nums2对应的下标，然后从那个下标开始向右遍历，寻找是否存在。
class Solution {
public:
int get_index(vector<int>& nums, int num)
{
for(int i = 0; i < nums.size(); i++)
{
if(num == nums[i]) return i;
}
return -1;
}
vector<int> nextGreaterElement(vector<int>& nums1, vector<int>& nums2) {
vector<int> ans(nums1.size()); //答案数组
stack<int> st;
for(int i = 0; i < nums1.size(); i++)
{
//首先获取nums1[i](当前元素)在nums2数组中的下标
int start = get_index(nums2,nums1[i]);
int flag = 0;
for(; start < nums2.size(); start++)
{
if(nums2[start] > nums1[i])
{
ans[i] = nums2[start];
flag = 1;
break;
}
}
if(flag == 0)
{
ans[i] = -1;
}
flag = 0;
}
return ans;
}
};
方法二:单调栈+哈希表
先忽略nums1，因为nums1中元素在nums2中一定有。
对nums2进行单调栈处理，需要记录的是一个键值对(该元素，该元素右边第一个比该元素大的元素)。
这个是个典型的单调栈模型：
需要注意：在比较的过程，如果满足st.back() <= nums2[i]，就说明nums2[i]是大于栈顶元素的第一个元素(因为我们遍历是向右遍历的)。
经过这个过程后，留在栈中的元素都符合没有找到右边元素大于该元素的条件，所以应该返回-1。
class Solution {
public:
vector<int> nextGreaterElement(vector<int>& nums1, vector<int>& nums2) {
vector<int> ans(nums1.size()); //答案数组
vector<int> st;
map<int,int> hash_map;
for(int i = 0; i < nums2.size(); i++)
{
while(!st.empty() && st.back() < nums2[i])
{
//说明第一个大于栈顶元素的元素为nums2[i]
hash_map[st.back()] = nums2[i];
st.pop_back();
}
st.push_back(nums2[i]);
}
//如果此时栈中还有元素，说明说明呢？
//说明栈中的元素在nums2数组中没有在右边找到比它还大的数，所以需要赋值为-1
while(!st.empty())
{
hash_map[st.back()] = -1;
st.pop_back();
}
//将哈希集合中的键值对转换为结果
for(int i = 0; i < nums1.size(); i++)
{
ans[i] = hash_map[nums1[i]];
}
return ans;
}
};
739. 每日温度
leetcode-cn.com/problems/da…
请根据每日 气温 列表，重新生成一个列表。对应位置的输出为：要想观测到更高的气温，至少需要等待的天数。如果气温在这之后都不会升高，请在该位置用 0 来代替。
例如，给定一个列表 temperatures = [73, 74, 75, 71, 69, 72, 76, 73]，你的输出应该是 [1, 1, 4, 2, 1, 1, 0, 0]。
提示：气温 列表长度的范围是 [1, 30000]。每个气温的值的均为华氏度，都是在 [30, 100] 范围内的整数。
单调栈模版解
一开始我使用了两个栈，一个用来存该元素，还有一个用来存该元素的下标，用来计算相差天数，时间复杂度会比较高，也浪费了一些空间。后来发现了只使用一个栈，存下标就行了。
class Solution {
public:
vector<int> dailyTemperatures(vector<int>& T) {
vector<int> ans(T.size()); //答案数组
vector<int> st_index;
for(int i = 0; i < T.size(); i++)
{
while(!st_index.empty() && T[st_index.back()] < T[i])
{
//说明第一个大于栈顶元素的元素为nums2[i]
ans[st_index.back()] = (i - st_index.back());
st_index.pop_back();
}
st_index.push_back(i);
}
//说明栈中的元素在nums2数组中没有在右边找到比它还大的数，所以需要赋值为-1
while(!st_index.empty())
{
ans[st_index.back()] = 0;
st_index.pop_back();
}
return ans;
}
};
优化
这一题还有KMP的解法，等看到KMP的知识点再做！贴个链接
leetcode-cn.com/problems/da…
503. 下一个更大元素 II
leetcode-cn.com/problems/ne…
给定一个循环数组（最后一个元素的下一个元素是数组的第一个元素），输出每个元素的下一个更大元素。数字 x 的下一个更大的元素是按数组遍历顺序，这个数字之后的第一个比它更大的数，这意味着你应该循环地搜索它的下一个更大的数。如果不存在，则输出 -1。
示例 1:
输入: [1,2,1]
输出: [2,-1,2]
解释: 第一个 1 的下一个更大的数是 2；
数字 2 找不到下一个更大的数；
第二个 1 的下一个最大的数需要循环搜索，结果也是 2。
单调栈+循环遍历
原本next只能在当前元素的右边，现在有可能出现在左边了。
我们可以在原数组后面再接一个原数组，这样就可以完成这样的效果。
另外需要注意的是：对于压栈的元素来说，仍然只是需要压入前n个数，不需要重复将后面链接的数组元素压入。
还需要注意的是：
1、当前元素大于栈顶元素的时候才能进行出栈操作，也就是说，栈中的元素是严格单调递增的，不允许出现等于的情况(这里可能出现重复的元素，所以不能等于)
class Solution {
public:
vector<int> nextGreaterElements(vector<int>& nums) {
int n = nums.size();
vector<int> ans(n,-1); //答案数组
vector<int> st;
for(int i = 0; i < 2 * n; i++)
{
while(!st.empty() && nums[st.back()] < nums[i%n])
{
ans[st.back()] = nums[i%n];
st.pop_back();
}
if(i < n) st.push_back(i);
}
return ans;
}
};
