力扣刷题笔记 → 496. 下一个更大元素 I

小知识，大挑战！本文正在参与“程序员必备小知识”创作活动。

题目

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

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

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

示例

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

输入: 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 $^4$
nums1和nums2中所有整数互不相同
nums1 中的所有整数同样出现在 nums2 中

解题思路

遍历

通过两层for循环，每一位元素都通过遍历，到nums2中查找它后面第一个比它大的值。由于题目中说明数组中元素没有重复，我们可以采用哈希表来保存每位元素的起始位置，便于nums1往后遍历。

class Solution {
    public int[] nextGreaterElement(int[] nums1, int[] nums2) {
        Map<Integer, Integer> map = new HashMap<>();
        for(int i = 0; i < nums2.length; ++i){
            // 这里 +1 为往后遍历的起始位置
            map.put(nums2[i], i + 1);
        }

        for(int i = 0; i < nums1.length; ++i){
            // 得到起始位置后，遍历比较
            int idx = map.get(nums1[i]);
            while(idx < nums2.length && nums2[idx] < nums1[i]){
                idx++;
            }
            nums1[i] = idx == nums2.length ? -1 : nums2[idx];
        }

        return nums1;
    }
}

针对小数据量的场景，可以自定义数组来模拟哈希的映射，这样会比采用哈希表效率更高一些。

class Solution {
    public int[] nextGreaterElement(int[] nums1, int[] nums2) {
        int[] index = new int[10001];
        for(int i = 0; i < nums2.length; i++){
            index[nums2[i]] = i + 1;
        }

        for(int i = 0; i < nums1.length; ++i){
            int temp = nums1[i];
            for(int j = index[nums1[i]]; j < nums2.length; ++j){
                if(nums2[j] > nums1[i]){
                    nums1[i] = nums2[j];
                    break;
                }
            }
            if(temp == nums1[i]){
                nums1[i] = -1;
            }
        }

        return nums1;
    }
}

复杂度分析

时间复杂度： $O(NM)$
空间复杂度： $O(1)$

单调栈

由于暴力法每次都需要去搜索右边的元素，重复的操作太多了，这里我们可以利用单调栈的后进先出特性来给它做一个优化，从右到左遍历nums2数组，将元素压入栈中，判断栈内是否有大于当前数值的元素，将其结果保存至哈希表中。同时由于后面的元素已经得到结果，所以可以顺便将小于当前数值的元素则弹出栈。

栈.gif

class Solution {
    public int[] nextGreaterElement(int[] nums1, int[] nums2) {
        Map<Integer, Integer> map = new HashMap<>();
        Stack<Integer> stack = new Stack<>();
        for(int i = nums2.length - 1; i >= 0; --i){
            // 将小于当前元素的都弹出栈
            while(!stack.isEmpty() && stack.peek() < nums2[i]){
                stack.pop();
            }
            // 保存结果
            map.put(nums2[i], stack.isEmpty() ? -1 : stack.peek());
            // 压入栈
            stack.add(nums2[i]);
        }

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

        return nums1;
    }
}

复杂度分析

时间复杂度： $O(N + M)$
空间复杂度： $O(N)$

最后

文章有写的不好的地方，请大佬们不吝赐教，错误是最能让人成长的，愿我与大佬间的距离逐渐缩短！

如果觉得文章对你有帮助，请 点赞、收藏、关注、评论 一键四连支持，你的支持就是我创作最大的动力！！！

题目出处: leetcode-cn.com/problems/ne…