Leetcode 496：下一个更大元素Ⅰ

题目描述：

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) 的解决方案吗？

解法一：双重循环

思路：

        通过双重循环找到nums1中元素在nums2中的位置，然后从找到的位置向后遍历，找到比nums1[i]大的第一个元素，返回即可；如果找不到则返回-1。

代码：

class Solution {
    public int[] nextGreaterElement(int[] nums1, int[] nums2) {
        int[] result = new int[nums1.length];
        for(int i=0; i < nums1.length; i++){
            result[i] = nextMaxNum(nums2, nums1[i]);
        }                           
        return result;
    }
    public int nextMaxNum(int[] array, int data){
        int index = 0;
        //找到data在array中的位置
        for(int i=0; i < array.length; i++){
            if(array[i] == data){
                index = i;
                break;
            }
        }
        //从该位置向后遍历，找到第一个比data大的元素返回
        for(int i=index; i < array.length; i++){
            if(array[i] > data){
                return array[i];
            }
        }
        //找不到则返回-1
        return -1;
    }
}

解法二：stack+map

思路：

1、遍历大数组nums2，将第一个元素入栈。

2、继续遍历，如果当前元素小于栈顶元素时，继续将它入栈；如果当前元素大于栈顶元素时，栈顶元素出栈，此时应将该出栈的元素与当前元素形成key-value键值对，存入HashMap中。

3、当遍历完nums2后，得到nums2中元素所对应的下一个更大元素的hash表。

4、遍历nums1的元素在hashMap中去查找‘下一个更大元素’，当找不到时则为-1。

代码：

class Solution {
    public int[] nextGreaterElement(int[] nums1, int[] nums2) {
        //存储结果
        int[] result = new int[nums1.length];
        //辅助栈
        Stack<Integer> stack = new Stack<>();
        Map<Integer, Integer> map = new HashMap<>();
        for(int val : nums2){
            while(!stack.isEmpty() && val > stack.peek()){
                map.put(stack.pop(), val);
            }
            stack.push(val);
        }
        //找到nums1中各元素的下一个最大元素
        for(int i=0; i < nums1.length; i++){
            Integer data = map.get(nums1[i]);
            result[i] = data == null ? -1 : data;
        }
        return result;
    }
    
}

扩展题目：

Leetcode 503：下一个更大元素Ⅱ

题目描述：

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

示例 1:

输入: [1,2,1]

输出: [2,-1,2]

解释: 第一个 1 的下一个更大的数是 2；数字 2 找不到下一个更大的数； 第二个 1 的下一个最大的数需要循环搜索，结果也是 2。

注意: 输入数组的长度不会超过 10000。

解法一：

思路：

将数组复制两倍，然后从当前下标向后遍历，找到第一个比当前元素值大的值返回即可。

代码：

class Solution {
    public int[] nextGreaterElements(int[] nums) {
        //创建一个2倍的数组，并拷贝元素
        int[] array = new int[nums.length*2];
        System.arraycopy(nums, 0, array, 0, nums.length);
        System.arraycopy(nums, 0, array, nums.length, nums.length);
        int[] result = new int[nums.length];
        for(int i=0; i < nums.length; i++){
            result[i] = nextMaxNum(array, nums[i], i);
        }                           
        return result;
    }
    public int nextMaxNum(int[] array, int data, int cur){
        int index = 0;
        //找到data在array中的位置
        for(int i=cur; i < array.length; i++){
            if(array[i] == data){
                index = i;
                break;
            }
        }
        //从该位置向后遍历，找到第一个比data大的元素返回
        for(int i=index; i < array.length; i++){
            if(array[i] > data){
                return array[i];
            }
        }
        //找不到则返回-1
        return -1;
    }
}

解法二：单调栈

思路：

思路与上一题差不多，不同在于需要对原数组遍历两次，对遍历下标进行取余转换。

代码：

class Solution {
     public int[] nextGreaterElements(int[] nums) {
        int n = nums.length;
        int [] res = new int[n];
        Arrays.fill(res, -1);
        Stack <Integer> stack = new Stack<>();
        for (int i = 0; i < n*2; i++){
            int num = nums[i % n];
            while(!stack.isEmpty() && num > nums[stack.peek()]){
                res[stack.pop()] = num;
            }
            if(i < n) stack.add(i);
        }
        return res;
    }
}