Day 58 | 739. Daily Temperatures | 496. Next Greater Element I-CSDN博客

本文链接：https://blog.csdn.net/kyle313606922/article/details/132192508

Monotonic Stack

In a one-dimensional array, find the first element on the right or left of an element that is larger or smaller than itself.
The time complexity is O(n).
The monotonic stack only needs to hold the index of the element.
There are three main criteria for using the monotonic stack.
- 1、The current element T[i] is smaller than the stack top element T[stack.top()].
- 2、The current element T[i] is the same as the stack top element T[stack.top()].
- 3、The current element T[i] is larger than the stack top element T[stack.top()].
When the monotonic stack is increasing (from the top to the bottom of the stack), this question is to find the one on the right that is bigger than the current element.
When the monotonic stack is decreasing (from the bottom to the top of the stack), this question is to find the one on the right that is smaller than the current element.

739. Daily Temperatures

Question Link

class Solution {
    public int[] dailyTemperatures(int[] temperatures) {
        int lens = temperatures.length;
        int[] res = new int[lens];
        Deque<Integer> stack = new LinkedList<>();
        stack.push(0);
        for(int i = 1; i < lens; 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;
    }
}

When the monotonic stack is increasing (from the top to the bottom of the stack), this question is to find the one on the right that is bigger than the current element.

496. Next Greater Element I

Question Link

class Solution {
    public int[] nextGreaterElement(int[] nums1, int[] nums2) {
        Stack<Integer> stack = new Stack<>();
        stack.push(0);

        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);

        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()])){
                        int index = hashMap.get(nums2[stack.peek()]);
                        res[index] = nums2[i];
                    }
                    stack.pop();
                }
                stack.add(i);
            }
        }
        return res;
    }
}

This question is similar like the 739. Daily Temperatures. Keep the elements of the stack in increasing order(from the top to the bottom of the stack), then we can get the first element on the right that is larger than itself.
In the nums2 traversal progress, when the current element is larger than the top element of the stack. We should determine if the top element of the stack has appeared in the nums1. If it appears, record the result.