单调栈的学习

这道题就是给你输入两个数组nums1和nums2，让你求nums1中的元素在nums2中的下一个更大元素

其实很容易就可以解决这个问题，因为题目说nums1是nums2的子集，所以我们先把nums2中每个元素的下一个更大元素算出来存到一个映射里，然后让nums1中的元素去查表即可

完整代码如下：

int[] nextGreaterElement(int[] nums1, int[] nums2) {
    // 记录 nums2 中每个元素的下一个更大元素
    int[] greater = nextGreaterElement(nums2);
    // 转化成映射：元素 x -> x 的下一个最大元素
    HashMap<Integer, Integer> greaterMap = new HashMap<>();
    for (int i = 0; i < nums2.length; i++) {
        greaterMap.put(nums2[i], greater[i]);
    }
    // nums1 是 nums2 的子集，所以根据 greaterMap 可以得到结果
    int[] res = new int[nums1.length];
    for (int i = 0; i < nums1.length; i++) {
        res[i] = greaterMap.get(nums1[i]);
    }
    return res;
}

int[] nextGreaterElement(int[] nums) {
    // 见上文
}

或者是

class Solution {
    private static Map<Integer,Integer> greaterElements;
    public int[] nextGreaterElement(int[] nums1, int[] nums2) {
        greaterElements(nums2);
        int[] res=new int[nums1.length];
        for(int i=0;i<nums1.length;i++){
            res[i]=greaterElements.get(nums1[i]);
        }
        return res;
    }
    public static void greaterElements(int[] nums){
        greaterElements=new HashMap<>();
        Stack<Integer> stack=new Stack<>();
        for(int i=nums.length-1;i>=0;i--){
            while(!stack.isEmpty()&&nums[i]>=stack.peek()){
                stack.pop();
            }
            if(stack.isEmpty()){
                greaterElements.put(nums[i],-1);
            }else{
                greaterElements.put(nums[i],stack.peek());
            }
            stack.push(nums[i]);
        }
    }
}

给你一个温度数组temperatures，这个数组存放的是近几天的天气温度，题目要求返回一个等长的数组，计算对于每一天你还至少要等多少天才能等到一个更暖和的气温，如果等不到那一天填0

比如说给你输入 temperatures = [73,74,75,71,69,76]，你返回 [1,1,3,2,1,0]。因为第一天 73 华氏度，第二天 74 华氏度，比 73 大，所以对于第一天，只要等一天就能等到一个更暖和的气温，后面的同理。

这个问题本质上也是找下一个更大的元素，只不过现在不是问下一个更大的元素的值是多少，而是问你当前元素距离下一个更大元素的索引距离是多少

解决方法就是记录下一个更大元素的数就可以了

class Solution {
    public int[] dailyTemperatures(int[] temperatures) {
        int n=temperatures.length;
        Stack<Integer> elements=new Stack<>();
        //同时存储索引
        Stack<Integer> locations=new Stack<>();
        //存放最后下一个更大的数的索引
        int[] location=new int[n];
        for(int i=n-1;i>=0;i--){
            while(!elements.isEmpty()&&elements.peek()<=temperatures[i]){
                elements.pop();
                locations.pop();
            }
            location[i]=elements.isEmpty()?-1:locations.peek();
            elements.push(temperatures[i]);
            locations.push(i);
        }
        int[] res=new int[n];
        for(int j=0;j<n;j++){
            int num=location[j]-j;
            if(num<=0){
                res[j]=0;
            }else{
                res[j]=num;
            }
        }
        return res;
    }
}

或者是

int[] dailyTemperatures(int[] temperatures) {
    int n = temperatures.length;
    int[] res = new int[n];
    // 这里放元素索引，而不是元素
    Stack<Integer> s = new Stack<>(); 
    /* 单调栈模板 */
    for (int i = n - 1; i >= 0; i--) {
        while (!s.isEmpty() && temperatures[s.peek()] <= temperatures[i]) {
            s.pop();
        }
        // 得到索引间距
        res[i] = s.isEmpty() ? 0 : (s.peek() - i); 
        // 将索引入栈，而不是元素
        s.push(i); 
    }
    return res;
}

同样是求下一个更大元素，但是现在这个数组是环形的

比如输入 [2,1,2,4,3]，你应该返回 [4,2,4,-1,4]，因为拥有了环形属性，最后一个元素 3 绕了一圈后找到了比自己大的元素 4。

我们一般是通过 % 运算符求模（余数），来模拟环形特效：

int[] arr = {1,2,3,4,5};
int n = arr.length, index = 0;
while (true) {
    // 在环形数组中转圈
    print(arr[index % n]);
    index++;
}

我们要如何处理呢？

难点在于最后一个元素如何找到比自己大的数

对于这种需求，常用的套路就是将数组长度翻倍

这样最后一个元素就能找到下一个更大的数，其他的数也能被正确计算

当然我们可以不构造新的数组而是利用循环数组的技巧来模拟数组长度翻倍的效果

完整的代码如下：

class Solution {
    public int[] nextGreaterElements(int[] nums) {
        Stack<Integer> elements=new Stack<>();
        int n=nums.length;
        int[] res=new int[n];
        for(int i=2*n-1;i>=0;i--){
            while(!elements.isEmpty()&&elements.peek()<=nums[i%n]){
                elements.pop();
            }
            res[i%n]=elements.isEmpty()?-1:elements.peek();
            elements.push(nums[i%n]);
        }
        return res;
    }
}

这样就能很巧妙地解决环形数组的问题，时间复杂度是O(N)