代码随想录day61 | 单调栈P1 | ● 739. ● 496.

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)。

单调栈的本质是空间换时间，因为在遍历的过程中需要用一个栈来记录右边第一个比当前元素高的元素，优点是整个数组只需要遍历一次。

更直白来说，就是用一个栈来记录我们遍历过的元素，因为我们遍历数组的时候，我们不知道之前都遍历了哪些元素，以至于遍历一个元素找不到是不是之前遍历过一个更小的，所以我们需要用一个容器（这里用单调栈）来记录我们遍历过的元素。

在使用单调栈的时候首先要明确如下几点：

1. 单调栈里存放的元素是什么？

单调栈里只需要存放元素的下标i就可以了，如果需要使用对应的元素，直接T[i]就可以获取。

1. 单调栈里元素是递增呢？ 还是递减呢？

代码

class Solution {
    public int[] dailyTemperatures(int[] temperatures) {
        //Stack<Integer> st = new Stack<Integer>(); 使用stack 更慢
        Deque<Integer> st = new LinkedList<Integer>();
        int len = temperatures.length;
        int [] res = new int [len];
        if(len == 1) return res;
        st.push(0);
        for(int i = 1; i < len; i++) {
            //当前元素小于等于栈顶元素 入栈(保持栈从顶到底 递增) 同时不更新res
            if (temperatures[i] <= temperatures[st.peek()]) {
                st.push(i);
            }else{
                //当前元素大于栈顶元素
                while(!st.isEmpty() && temperatures[i] > temperatures[st.peek()]){
                    //更新结果值, 在右侧发现了第一个大于栈顶元素的索引i 减去当前元素的索引值即可
                    res[st.peek()]=i-st.peek();
                    //出栈
                    st.pop();
                }
                //当前元素不再大于栈顶元素 入栈
                st.push(i);
            }
        }
        return res;
    }
}

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 。

思路

单调栈 找更大的 从小到大;

对nums2利用单调栈遍历 然后找到更大时候 先判断当前元素是否是nums1中元素 若是 则更新res 否则继续

在遍历nums2的过程中，我们要判断nums2[i]是否在nums1中出现过，因为最后是要根据nums1元素的下标来更新result数组。

注意题目中说是两个没有重复元素 的数组 nums1 和 nums2。

没有重复元素，我们就可以用map来做映射了。根据数值快速找到下标，还可以判断nums2[i]是否在nums1中出现过。

代码

class Solution {
    public int[] nextGreaterElement(int[] nums1, int[] nums2) {
        //暴力 忍不住了 三层for 算了
        int [] res = new int [nums1.length];
        Arrays.fill(res,-1);
        Deque<Integer> st = new LinkedList<Integer>();
        HashMap<Integer, Integer> hs = new HashMap<>();
        for(int i = 0; i < nums1.length; i++){
            //哈希表记录nums1 值到下标的映射
            hs.put(nums1[i] , i);
        }
        st.push(0);
        //遍历nums2 当找到一个在nums1中存在的元素的 右侧 首个大于它的值时候 更新res
        for(int i = 1; i<nums2.length; i++){
            if(nums2[i] <= nums2[st.peek()]){
                st.push(i);
            }else{
                while(!st.isEmpty() && nums2[i] > nums2[st.peek()]){
                    if(hs.containsKey(nums2[st.peek()])){
                        //更新res 为 下一个更大元素 也就是当前元素 nums2[i]
                        res[hs.get(nums2[st.peek()])] = nums2[i];
                    }
                    st.pop();
                }
                st.push(i);
            }
        }
        return res;
    }
}