单调栈01（leetcode739/496/503）

参考资料：

https://programmercarl.com/0739.%E6%AF%8F%E6%97%A5%E6%B8%A9%E5%BA%A6.html

单调栈：

常用于解决在一维数组中找到任一元素的左边或右边第一个比它大或小的元素位置。

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]

思路分析：

要找到右边第一个比当前元素大的，用单调递增栈

遇到大于当前栈顶元素的，记录结果并弹出已记录结果的元素。

代码实现：

class Solution {
    // 递增栈，存数组下标
    public int[] dailyTemperatures(int[] temperatures) {
       int n=temperatures.length;
       int[] res=new int[n];
       Deque<Integer> stk=new LinkedList<>();
       stk.push(0);
        for(int i=1;i<n;i++){
            if(temperatures[i]<=temperatures[stk.peek()]){
                stk.push(i);
            }else{
                while(!stk.isEmpty() && temperatures[i]>temperatures[stk.peek()]){
                    res[stk.peek()]=i-stk.peek();
                    stk.pop();
                }
                stk.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 。

思路分析：

主要思路与上题同。

将nums1的数值和下标通过HashMap对应，方便后面弹出栈顶元素时判断元素是否存在于nums1中。

代码实现：

class Solution {
    public int[] nextGreaterElement(int[] nums1, int[] nums2) {
        int len1 = nums1.length;
        int[] res=new int[len1];
        Arrays.fill(res,-1);
        Stack<Integer> temp =new Stack<>();
        HashMap<Integer,Integer> hashMap=new HashMap<>();
        for(int i=0;i<len1;i++){
            hashMap.put(nums1[i],i);//将数值与下标对应，方便后面搜索
        }

        //nums2 单调栈
        temp.push(0);
        for(int i=1;i<nums2.length;i++){
            if(nums2[i] <= nums2[temp.peek()]){
                temp.push(i);
            }else{
                while(!temp.isEmpty() && nums2[i]>nums2[temp.peek()]){
                    if(hashMap.containsKey(nums2[temp.peek()])){
                        int index1 = hashMap.get(nums2[temp.peek()]);
                        res[index1] = nums2[i];
                    }
                    temp.pop();
                }
                temp.push(i);
            }
        }
        return res;
    }
}

 503. 下一个更大元素 II

题目描述：

给定一个循环数组 nums （ nums[nums.length - 1] 的下一个元素是 nums[0] ），返回 nums 中每个元素的 下一个更大元素 。

数字 x 的 下一个更大的元素 是按数组遍历顺序，这个数字之后的第一个比它更大的数，这意味着你应该循环地搜索它的下一个更大的数。如果不存在，则输出 -1 。

示例 1:

输入: nums = [1,2,1]
输出: [2,-1,2]
解释: 第一个 1 的下一个更大的数是 2；
数字 2 找不到下一个更大的数； 
第二个 1 的下一个最大的数需要循环搜索，结果也是 2。

思路分析：

总体思路仍与上题一致。

循环： for(int i=0;i<2*n;i++){

        i%n

}

代码实现：

class Solution {
    public int[] nextGreaterElements(int[] nums) {
       int n=nums.length;
       int[] res=new int[n];
       Arrays.fill(res,-1);
       Stack<Integer> stk=new Stack<>();
       stk.push(0);
       for(int i=1;i<2*n;i++){
        while(!stk.isEmpty() && nums[i%n]>nums[stk.peek()]){
            res[stk.peek()] = nums[i%n];
            stk.pop();
        }
        stk.push(i%n);
       }
       return res;
    }
}