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 。
  提示：
  1 <= nums1.length <= nums2.length <= 1000
  0 <= nums1[i], nums2[i] <= 104
  nums1和nums2中所有整数 互不相同
  nums1 中的所有整数同样出现在 nums2 中
  进阶：你可以设计一个时间复杂度为 O(nums1.length + nums2.length) 的解决方案吗？

算法思想

这个到题目就是使用到了单调栈的算法，并且对于单调栈，我们只需要知道单调栈的解题模版，遇到算法问题，识别是否是单调栈模版能解决的，直接就套用单调栈解决算法问题的模版就可以了。
那么什么是单调栈？

单调栈就就是栈，只不过单调栈中元素，要么是单调递增的，单调递减的

解决思路

这个题目整体的思路就是：

1、nums1是nums2的子集，而且数组是没有元素重复的，那么我们可以想把nums2中所有元素的下一个更大元素求出来，放哈希MAP银映射表里面，让后让nums1从哈希MAP映射里面去找，因为元素是不重复的，所以get到的值一定是一一对应的。
2、那怎么求解nums2数组中每个数组的下一个元素呢，那就是需要用到单调栈的算法模版思想了
3、单调栈的算法模版思想的目的就位为了解决这种下一个最大元素的题目，这个算法模版有点不好理解，直接看代码，通过代码来理解这个单调栈的模版思想

代码

在这里插入代码片
class Solution {
    public int[] nextGreaterElement(int[] nums1, int[] nums2) {
        //因为nums1是nums2的子集，数组又没有重复元素
        //所以把nums2的所以元素的下一个更大元素都计算出来并对一放到MAP映射，让nuss根据key去找value
        int[] greater = nextGreaterElement(nums2);

        HashMap<Integer,Integer> greaterMap = new HashMap<>();

        for(int i = 0; i < nums2.length;i++){
            greaterMap.put(nums2[i],greater[i]);
        }

        int[] res = new int[nums1.length];
        for(int i = 0;i < nums1.length;i++){
            res[i] = greaterMap.get(nums1[i]);
        }     

        return res;   
    }

    //计算nums中每个元素的下一个最大值
    int[] nextGreaterElement(int[] nums){
        //存放答案的数组，这个数组的长度和nums的长度是一样的
        int n = nums.length;
        int[] res = new int[n];

        //定义栈结构
        Stack<Integer> s = new Stack<>();

        //单调栈的解题思想:
        //把数组的元素从后往前的放入栈中
        //没循环一次就要做一次和栈中值的判断，如果栈的元素比当前的值还小，那就干掉，因为没什么用了
        //每次循环的结果要么是没有要么是栈顶元素
        for(int i = n - 1; i >= 0;i--){
            while(!s.isEmpty() && nums[i] >= s.peek()){
                s.pop();
            }
            res[i] = s.isEmpty() ? -1:s.peek();

            s.push(nums[i]);
        }
        return res;
    }
}