算法题
Leetcode 739. 每日温度
题目链接:739. 每日温度
大佬视频讲解：739. 每日温度视频讲解
个人思路
因为题目所求的是找到一个元素右边第一个比自己大的元素，这是单调栈的经典题目，用栈来记录遍历过的元素
解法
单调栈
单调栈的本质是空间换时间，因为在遍历的过程中需要用一个栈来记录右边第一个比当前元素高的元素，优点是整个数组只需要遍历一次。
更直白来说，就是用一个栈来记录遍历过的元素，因为遍历数组的时候，不知道之前都遍历了哪些元素，以至于遍历一个元素找不到是不是之前遍历过一个更小的，所以需要用一个容器（这里用单调栈）来记录遍历过的元素。
在使用单调栈的时候首先要明确如下三点：
1.单调栈里存放的元素是什么？
单调栈里只需要存放元素的下标i就可以了，如果需要使用对应的元素，直接T[i]就可以获取。
2.单调栈里元素是递增呢？ 还是递减呢？
从栈头到栈底的顺序，使用递增循序，因为只有递增的时候，栈里要加入一个元素i的时候，才知道栈顶元素在数组中右面第一个比栈顶元素大的元素是i。
即：如果求一个元素右边第一个更大元素，单调栈就是递增的，如果求一个元素右边第一个更小元素，单调栈就是递减的。
3.使用单调栈的三个判断条件，把这三种情况分析清楚了，也就理解透彻了。
- 当前遍历的元素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]没更新值，说明这个元素右面没有更大的了，也就是为0。所以定义result数组的时候，就应该直接初始化为0.
class Solution {
public int[] dailyTemperatures(int[] temperatures) {
int lens=temperatures.length;
int []res=new int[lens];//结果数组
Deque<Integer> stack=new LinkedList<>();//单调栈
stack.push(0);
for(int i=1;i<lens;i++){
if(temperatures[i]<=temperatures[stack.peek()]){
stack.push(i);
}else{//大于时
while(!stack.isEmpty()&&temperatures[i]>temperatures[stack.peek()]){
res[stack.peek()]=i-stack.peek();
stack.pop();
}
stack.push(i);
}
}
return res;
}
}时间复杂度:O(n)；（ 每个元素最多被入栈和出栈各一次）
空间复杂度:O( n);（暂存数据的栈和res结果数组）
Leetcode 496.下一个更大元素 I
题目链接:496.下一个更大元素 I
大佬视频讲解：496.下一个更大元素 I视频讲解
个人思路
和前面这道很是相像，所以还是用单调栈，
解法
单调栈
从题目示例中可以看出最后是要求nums1的每个元素在nums2中下一个比当前元素大的元素，那么就要定义一个和nums1一样大小的数组result来存放结果。因为题目说如果不存在对应位置就输出 -1 ，所以result数组如果某位置没有被赋值，那么就应该是是-1，所以就初始化为-1。
在遍历nums2的过程中，需要判断nums2[i]是否在nums1中出现过，因为最后是要根据nums1元素的下标来更新result数组。
再加上题目中说是两个没有重复元素 的数组 nums1 和 nums2，所以可以用map来做映射了。根据数值快速找到下标，还可以判断nums2[i]是否在nums1中出现过。
因为要找到右边第一个比自己大的元素，所以这里使用单调栈还是递增顺序，即栈头到栈底的顺序(从小到大)。而递减栈就是求右边第一个比自己小的元素了。
接下来分析如下三种情况：
情况一：当前遍历的元素T[i]小于栈顶元素T[st.top()]的情况
此时满足递增栈（栈头到栈底的顺序），所以直接入栈。
情况二：当前遍历的元素T[i]等于栈顶元素T[st.top()]的情况
如果相等的话，依然直接入栈，因为我们要求的是右边第一个比自己大的元素，而不是大于等于！
情况三：当前遍历的元素T[i]大于栈顶元素T[st.top()]的情况
此时如果入栈就不满足递增栈了，这也是找到右边第一个比自己大的元素的时候。
判断栈顶元素是否在nums1里出现过，（注意栈里的元素是nums2的元素），如果出现过，开始记录结果。记录结果这块逻辑有一点小绕，要清楚，此时栈顶元素在nums2数组中右面第一个大的元素是nums2[i]（即当前遍历元素）。
class Solution {
public int[] nextGreaterElement(int[] nums1, int[] nums2) {
Stack<Integer> temp = new Stack<>();
int[] res = new int[nums1.length];
Arrays.fill(res,-1);//初始化
HashMap<Integer, Integer> hashMap = new HashMap<>();
for (int i = 0 ; i< nums1.length ; i++){
hashMap.put(nums1[i],i);
}
temp.add(0);//暂存栈
for (int i = 1; i < nums2.length; i++) {
if (nums2[i] <= nums2[temp.peek()]) {
temp.add(i);
} else {
while (!temp.isEmpty() && nums2[temp.peek()] < nums2[i]) {
if (hashMap.containsKey(nums2[temp.peek()])){
Integer index = hashMap.get(nums2[temp.peek()]);
res[index] = nums2[i];
}
temp.pop();
}
temp.add(i);
}
}
return res;
}
}时间复杂度:O(n)；（ 每个元素最多被入栈和出栈各一次）
空间复杂度:O( n);（暂存数据的栈，res结果数组，map）
以上是个人的思考反思与总结，若只想根据系列题刷，参考卡哥的网址代码随想录算法官网