链接：https://leetcode-cn.com/problems/next-greater-element-i/
https://leetcode-cn.com/problems/next-greater-element-ii/

题目

给你两个 没有重复元素 的数组 nums1 和 nums2 ，其中nums1 是 nums2 的子集。

请你找出 nums1 中每个元素在 nums2 中的下一个比其大的值。

nums1 中数字 x 的下一个更大元素是指 x 在 nums2 中对应位置的右边的第一个比 x 大的元素。如果不存在，对应位置输出 -1 。

用例

示例 1:

输入: nums1 = [4,1,2], nums2 = [1,3,4,2].
输出: [-1,3,-1]
解释:
对于 num1 中的数字 4 ，你无法在第二个数组中找到下一个更大的数字，因此输出 -1 。
对于 num1 中的数字 1 ，第二个数组中数字1右边的下一个较大数字是 3 。
对于 num1 中的数字 2 ，第二个数组中没有下一个更大的数字，因此输出 -1 。
示例 2:

输入: nums1 = [2,4], nums2 = [1,2,3,4].
输出: [3,-1]
解释:
  对于 num1 中的数字 2 ，第二个数组中的下一个较大数字是 3 。
对于 num1 中的数字 4 ，第二个数组中没有下一个更大的数字，因此输出 -1 。

提示：

1 <= nums1.length <= nums2.length <= 1000
0 <= nums1[i], nums2[i] <= 104
nums1和nums2中所有整数 互不相同

思路

方法一
暴力
用hash表记录nums2数组中每一个值对应的位置
遍历nums1数组 根据nums2中位置遍历后序值 找最大

class Solution {
public:
    vector<int> nextGreaterElement(vector<int>& nums1, vector<int>& nums2) {
        unordered_map<int,int>mp;
        int n1=nums1.size();
        int n2=nums2.size();
        for(int i=0;i<n2;++i){
            mp[nums2[i]]=i;
        }
        vector<int>ans(n1,-1);
        for(int i=0;i<n1;++i){
            for(int j=mp[nums1[i]]+1;j<n2;++j){
                if(nums2[j]>nums1[i]){
                    ans[i]=nums2[j];
                    break;
                }       
            }
        }
        return ans;
    }
};

方法二
一般求下一个最大值的题都使用单调栈
从后往前遍历nums2数组
设置单调栈（注意无重复值时栈中可以存值也可以存序号 有重复值必需存序号）
当nums[i]大于栈顶元素 出栈，直到栈顶元素大于nums[i]或栈空
当栈空时 说明数组后方无更大的值 返回-1 其余返回栈顶
然后将nums[i]入栈

class Solution {
public:
    vector<int> nextGreaterElement(vector<int>& nums1, vector<int>& nums2) {
        unordered_map<int,int>mp;
        stack<int>st;
        for(int i=nums2.size()-1;i>=0;--i){
            int num=nums2[i];
            while(!st.empty()&&num>=st.top()){
                st.pop();
            }
            mp[num]=st.empty()?-1:st.top();
            st.push(num);
        }     
        vector<int>ans(nums1.size());
        for(int i=0;i<nums1.size();++i){
            ans[i]=mp[nums1[i]];
        }
        return ans;
    }
};

相关题目

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

示例 1:

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

相关题目中为循环数组，实际上只需要用单调栈对数组循环两次即可

class Solution {
public:
    vector<int> nextGreaterElements(vector<int>& nums) {
        int n=nums.size();
        stack<int>st;//存在重复数 所以需要存下标
        vector<int>ans(n,-1);
        for(int i=n-1;i>=0;i--){          
            while(!st.empty()&&nums[st.top()]<=nums [i]){
                st.pop();
            }
            if(!st.empty())
                ans[i]=nums[st.top()];
            st.push(i);   
        }
        for(int i=n-1;i>=0;i--){          
            while(!st.empty()&&nums[st.top()]<=nums [i]){
                st.pop();
            }
            if(!st.empty())
                ans[i]=nums[st.top()];
            st.push(i);   
        }
        return ans;
    }
};

两次循环可写法简化 设置遍历2n-1然后对位置取模

class Solution {
public:
    vector<int> nextGreaterElements(vector<int>& nums) {
        int n = nums.size();
        vector<int> ret(n, -1);
        stack<int> stk;
        for (int i = 0; i < n * 2 - 1; i++) {
            while (!stk.empty() && nums[stk.top()] < nums[i % n]) {
                ret[stk.top()] = nums[i % n];
                stk.pop();
            }
            stk.push(i % n);
        }
        return ret;
    }
};