leetcode----单调栈解决下一个更大元素问题

参考 labuladong大佬题解

单调栈实际上就是栈，只是利用了一些巧妙的逻辑，使得每次新元素入栈后，栈内的元素都保持有序（单调递增或单调递减）。

单调栈用途不太广泛，只处理一种典型的问题: 下一个更大元素

单调栈模板：

场景：给你一个数组 nums，请你返回一个等长的结果数组，结果数组中对应索引存储着下一个更大元素，如果没有更大的元素，就存 -1。

示例：输入一个数组 nums = [2,1,2,4,3]，你返回数组 [4,2,4,-1,-1]。

public int[] nextGreaterNum(int[] nums){
    int len = nums.length;
    Deque<Integer> stack = new LinkedList();
    int[] res = new int[n];
    
    for(int i = n - 1; i >= 0; i--){
        //将当前元素右区间 小于等于自己的都去掉。去掉后，栈顶元素就是第一个大于当前元素的值。
        while(!stack.isEmpty() && stack.peek() <= nums[i]){
            stack.pop();
        }
        
        //栈为空说明当前元素的右区间没有大于当前元素的元素
        res[i] = stack.isEmpty() ? -1 : stack.peek();
        stack.push(nums[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] 是如上所述的 下一个更大元素 。

示例：

输入：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 = [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的下一个更大元素情况。

class Solution {
    public int[] nextGreaterElement(int[] nums1, int[] nums2) {
        int len1 = nums1.length, len2 = nums2.length;


        Deque<Integer> stack = new LinkedList();
        HashMap<Integer, Integer> map = new HashMap();

        for(int i = len2 - 1; i >= 0; i--){
            while(!stack.isEmpty() && stack.peek() <= nums2[i]){
                stack.pop();
            }
            map.put(nums2[i], stack.isEmpty() ? -1 : stack.peek());
            stack.push(nums2[i]);
        }

        int[] res = new int[len1];
        for(int i = 0; i < len1; i++){
            res[i] = map.get(nums1[i]);
        }
        return res;
    }
}

503.下一个更大元素II

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

示例：

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

思路：对于这道循环数组，重点在于寻找数组中最后一个元素的下一个更大元素，常用的套路是将数组长度翻倍。

最简单的方法就是构造一个两倍长度的数组，然后再用模板，但是，我们可以不用构造新数组，而是利用循环数组的技巧来模拟数组长度翻倍的效果。具体如下

class Solution {
    public int[] nextGreaterElements(int[] nums) {
        int len = nums.length;
        Deque<Integer> stack = new LinkedList();
        int[] res = new int[len];

        //长度翻倍
        for(int i = 2 * len - 1; i >= 0; i--){
            //索引取余模拟数组长度翻倍
            while(!stack.isEmpty() && stack.peek() <= nums[i % len]){
                stack.pop();
            }

            res[i % len] = stack.isEmpty() ? -1 : stack.peek();
            stack.push(nums[i % len]);
        }
        return res;
    }
}

739.每日温度

问题：请根据每日 气温 列表 temperatures ，请计算在每一天需要等几天才会有更高的温度。如果气温在这之后都不会升高，请在该位置用 0 来代替。

示例：

输入: temperatures = [73,74,75,71,69,72,76,73]
输出: [1,1,4,2,1,1,0,0]

输入: temperatures = [30,40,50,60]
输出: [1,1,1,0]

输入: temperatures = [30,60,90]
输出: [1,1,0]

思路：单调栈

这道题与上面所给的单调栈模板稍有不同，本题求当前元素与下一个大于它的元素的距离。所以栈中存索引，利用索引计算距离。

class Solution {
    public int[] dailyTemperatures(int[] temperatures) {
        int len = temperatures.length;

        if(len == 1){
            return new int[]{0};
        }
        Deque<Integer> stack = new LinkedList();
        int[] res = new int[len];

        for(int i = len - 1; i >= 0; i--){
            while(!stack.isEmpty() && temperatures[stack.peek()] <= temperatures[i]){
                stack.pop();
            }

            res[i] = stack.isEmpty() ? 0 : stack.peek() - i;
            stack.push(i);
        }
        return res;
    }
}

整理思路，记录博客，以便复习。若有误，望指正~