739. 每日温度

中等
提示
给定一个整数数组 temperatures ，表示每天的温度，返回一个数组 answer ，其中 answer[i] 是指对于第 i 天，下一个更高温度出现在几天后。如果气温在这之后都不会升高，请在该位置用 0 来代替。

思路：

有同学就问了，我怎么能想到用单调栈呢？ 什么时候用单调栈呢？
通常是一维数组，要寻找任一个元素的右边或者左边第一个比自己大或者小的元素的位置，此时我们就要想到可以用单调栈了。时间复杂度为O(n)。
例如本题其实就是找找到一个元素右边第一个比自己大的元素，此时就应该想到用单调栈了。

代码随想录有比较清晰的插图，由于比较长，我就不截图了。链接是：每日温度

// 思路就是，保持栈的的元素是最大的那个的索引，其次是次大的，保持栈是单调的
 /**
        如果当前遍历的元素 大于栈顶元素，表示 栈顶元素的 右边的最大的元素就是 当前遍历的元素，
        	所以弹出 栈顶元素，并记录
        	如果栈不空的话，还要考虑新的栈顶与当前元素的大小关系
        否则的话，可以直接入栈。
        注意，单调栈里 加入的元素是 下标。
        */
class Solution {
    public int[] dailyTemperatures(int[] temperatures) {
        int len = temperatures.length;
        int[] res = new int[len];

        Deque<Integer> stack = new LinkedList<>();
        stack.push(0); // 先把第一个元素的索引0压入栈

        for (int i = 1; i < len; i++) {
            if (temperatures[i] <= temperatures[stack.peek()]) { //如果当前元素小于等于栈顶元素
                stack.push(i);
            } else {
                while(!stack.isEmpty() && temperatures[i] > temperatures[stack.peek()]) { // 不停地弹出栈里的元素直到栈顶元素大于当前元素
                    res[stack.peek()] = i - stack.peek();
                    stack.pop();
                }
                stack.push(i); // 随后将当前元素压入栈
            }
        }

        return res;
    }
}

496. 下一个更大元素 I

简单

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 。

// 我的暴力解法，元素比较少，这也是能用暴力法的原因
class Solution {
    public int[] nextGreaterElement(int[] nums1, int[] nums2) {
        int len1 = nums1.length;
        int len2 = nums2.length;
        int[] ans = new int[len1];
        Arrays.fill(ans, -1);
        int nums2Index = len1; // 记录第一个数组中的元素在第二个数组中的索引,初始化先弄大一点

        for (int i = 0; i < len1; i++) {
            nums2Index = len1;
            for (int j = 0; j < len2; j++) {
                if (nums1[i] == nums2[j]) {
                    nums2Index = j;
                } else if( j > nums2Index && nums1[i] < nums2[j]){
                    ans[i] = nums2[j];
                    break;
                }
            }
        }

        return ans;
    }
}

// 单调栈解法
class Solution {
    public int[] nextGreaterElement(int[] nums1, int[] nums2) {
        Stack<Integer> stack = new Stack<>();
        int[] res = new int[nums1.length];
        Arrays.fill(res, -1);
        HashMap<Integer, Integer> hashmap = new HashMap<>();
        for (int i = 0; i < nums1.length; i++) {
            hashmap.put(nums1[i], i);
        }
        stack.add(0);
        // 因为是要在nums[2]中找大于的那个元素，所以要把nums2的元素入栈，和每日温度一样
        // 这个题和每日温度相比，就是要判断一下nums2的元素有没有在nums1里出现过，出现过才添加到res里
        // 别的操作都和每日温度一样的
        for (int i = 1; i < nums2.length; i++) {
            if (nums2[i] <= nums2[stack.peek()]) { // 当前元素小于等于栈顶元素，压入
                stack.add(i);
            } else { // 当前元素大于栈顶元素，弹出
                while (!stack.isEmpty() && nums2[i] > nums2[stack.peek()]) {
                    if (hashmap.containsKey(nums2[stack.peek()])) {
                        Integer index = hashmap.get(nums2[stack.peek()]); // 找到栈顶元素在nums1中的索引
                        res[index] = nums2[i];
                    }
                    stack.pop();
                }
                stack.add(i);
            }
        }
        return res;
    }
}