496. 下一个更大元素 I 的 单调栈解法

Posted 2021-11-23 寂静花开

496. 下一个更大元素 I

• 496. 下一个更大元素 I
• • 题目
  • 解题思路
  • Java代码
  • • • 法一
      • 法二

题目

给你两个 没有重复元素 的数组 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] <= 10⁴
nums1和nums2中所有整数 互不相同
nums1 中的所有整数同样出现在 nums2 中

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/next-greater-element-i

解题思路

首先分析题意，我开头都理解错了。感觉题干有点绕，看了示例才明白。
他要求输出的是数组2中等于数组1的元素的右边区间中，第一个大于这个元素的数。
就是，下标为i时，找到nums2中等于nums1[i]的右边那部分，第一个大于nums1[i]的数。

法一：暴力
就是按题意循环套循环的遍历俩数组，这不是重点。

法二：利用单调栈和哈希表

因为我们主要是遍历一个数的右边部分，所以对数组2进行倒序进栈会比较好写。
我们维护一个单调递减的栈，保持栈顶元素始终大于当前元素，那么栈顶元素就是右边第一个大于当前元素的值。
存入哈希表中，它的key就是当前元素。

时间复杂度：O(m + n)
mn分别为俩数组的长度，且俩数组分别遍历了一遍。
空间复杂度：O(n)
建的哈希表。

Java代码

法一

//法一
class Solution {
    public int[] nextGreaterElement(int[] nums1, int[] nums2) {
        int n = nums1.length;
        int m = nums2.length;
        int[] res = new int[n];
        for(int i = 0; i < n; i++){
            for(int j = 0; j < m;j++){
                if(nums1[i] == nums2[j]){
                    while(j < m){
                        if(nums2[j]<=nums1[i]){
                            j++;
                        }
                        else{
                            res[i]=nums2[j];
                            break;
                        }
                    }
                }
            }
        }
        for(int i =0; i < n; i++){
            if(res[i] == 0){
                res[i] = -1;
            }
        }
        return res;
    }
}

法二

//法二
class Solution {
    public int[] nextGreaterElement(int[] nums1, int[] nums2) {
        Deque<Integer> stack = new ArrayDeque<>();//定义一个单调栈
        Map<Integer,Integer> map = new HashMap<>();
        int len1 = nums1.length;
        int len2 = nums2.length;
        for(int i = len2-1; i>=0; i--){
            int num = nums2[i];
            while(!stack.isEmpty() && num > stack.peek()){
                stack.pop();
                
            }
            
            // if(!stack.isEmpty()){
            //     map.put(num,stack.peek());
            // }
            map.put(num, stack.isEmpty() ? -1 : stack.peek());
            stack.push(num);
            
        }

        int[] res = new int[len1];
        for(int i=0; i<len1; i++){
            //res[i] = map.getOrDefault(nums1[i],-1);
            //getOrDefault这个函数的作用是获得nums1[i]对应的值，如果没有这个值，就返回逗号后的给定值。
            res[i] = map.get(nums1[i]);
        }
        return res;
    }
}