[leetcode]496. Next Greater Element I下一个较大元素

You are given two arrays (without duplicates) nums1 and nums2 where nums1’s elements are subset of nums2. Find all the next greater numbers for nums1's elements in the corresponding places of nums2.

The Next Greater Number of a number x in nums1 is the first greater number to its right in nums2. If it does not exist, output -1 for this number.

Example 1:

Input: nums1 = [4,1,2], nums2 = [1,3,4,2].
Output: [-1,3,-1]
Explanation:
    For number 4 in the first array, you cannot find the next greater number for it in the second array, so output -1.
    For number 1 in the first array, the next greater number for it in the second array is 3.
    For number 2 in the first array, there is no next greater number for it in the second array, so output -1.

题意：

给定数组nums， 又给定它的子集subNums， 求subNums中每个元素在nums中右边第一个较大元素（即Next Greater Element）

subNums = [,1,2] 当扫到元素4， 该元素在 nums = [1,3,,2] 中右边第一个数为2， 并不greater than 4, 返回-1

subNums = [4,,2] 当扫到元素1， 该元素在 nums = [,3,4,2] 中右边第一个数为3， 确实greater than 1, 返回 3

subNums = [4,1,] 当扫到元素2， 该元素在 nums = [1,3,4,] 中右边没有元素， 不存在greater than 2, 返回-1

思路：

两个指针同时扫 subNums 和 nums

用一个boolean变量做标记，若当前 subNums 元素等于当前nums元素，则标记 found = true ，说明找到了corresponding元素。

nums指针继续往右，找greater element， 直到找到符合 found && nums[j] > subNums[i] 条件的元素。否则返回-1

代码一：

 class Solution {
      public int[] nextGreaterElement(int[] subNums, int[] nums) {
         int[] res = new int[subNums.length];
         for (int i = 0; i < subNums.length; i++) {
             boolean found = false;
             int j = 0;
             for (; j < nums.length; j++) {
                 if (found && nums[j] > subNums[i]) {
                     res[i] = nums[j];
                     break;
                 }
                 if (found && nums[j] < subNums[i]) {
                     res[i] = -1;
                 }
                 if (nums[j] == subNums[i]) {
                     found = true;
                 }
             }
             if (j == nums.length) {
                 res[i] = -1;
             }
         }
         return res;
     }
 }

另外一个思路就是用单调栈 + HashMap

为何用单调栈？  为任意一个元素找左边和右边第一个比自己大/小的位置，用单调栈。

先只take care of nums : 从右往左扫nums， 用Stack维护递减栈，留下波峰，剔除波谷。比较栈顶元素跟即将入栈元素大小，

用HashMap来记录其比较结果。再take care of nums: 扫一遍subNums，在HashMap中找到对应的value，返回即可。

subNums = [4,1,2],  nums = [1,0,3,4,2]
                                           Stack             HashMap
                                    ^      [2]                2 | -1
                                  ^        [4]                4 | -1
                                ^          [4, 3]             3 | 4
                              ^            [4, 3, 0]          0 | 3
                            ^              [4, 3, 1]          1 | 3

代码二：

  public int[] nextGreaterElement(int[] subNums, int[] nums) {
         int[] res = new int[subNums.length];
         Stack<Integer> stack = new Stack<>();
         HashMap<Integer, Integer> map = new HashMap<>();
         for (int i = nums.length - 1; i >= 0; i--) {
             while (!stack.empty() && nums[i] > stack.peek()) {
                 stack.pop();
             }
             if (stack.empty()) {
                 map.put(nums[i], -1);
             } else {
                 map.put(nums[i], stack.peek());
             }
             stack.push(nums[i]);
         }
 
         for (int i = 0; i < subNums.length; i++) {
             res[i] = map.get(subNums[i]);
         }
         return res;
     }