代码随想录算法训练营day58|739. 每日温度，496.下一个更大元素 I

739. 每日温度

739. 每日温度 - 力扣（LeetCode）

思路：单调栈

1. 一维数组，要寻找任一元素右边或左边第一个比自己大或者小的元素的位置的题目，要想到借助单调栈。单调栈内存放的元素：元素的下标i；从栈头到栈尾，使用递增顺序；

2. 三种情况：

（1）当前遍历的元素 T[i] 小于栈顶元素 T[st.peek()]：将当前遍历元素加入单调栈；

（2）当前遍历的元素 T[i] 等于栈顶元素 T[st.peek()] ：将当前遍历元素加入单调栈；

（3）当前遍历的元素 T[i] 大于栈顶元素 T[st.peek()] ：意味着栈顶元素右边的最大的元素就是当前元素，所以弹出栈顶元素，并记录；若栈不为空，继续考虑新的栈顶与当前元素的大小关系，否则直接入栈；

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

精简代码如下：

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

496. 下一个更大元素 I - 力扣（LeetCode）

思路：

1. 定义一个跟 nums1 一样大的数组，初始化为-1；

2.由于 nums1 和 nums2 没有重复元素，可以用map来作映射，根据数值快速找到下标，且能判断nums2[i]是否在nums1中出现过。

3.单调递增栈，三种情况如下:

(1) 当前遍历的元素T[i]小于栈顶元素T[st.peek()]：此时满足递增栈，直接入栈；

(2) 当前遍历的元素T[I]等于栈顶元素T[st.peek()]：直接入栈；

(3) 当前遍历的元素T[i]大于栈顶元素T[st.peek()]：判断栈顶元素是否在nums1中出现过，如果出现过，根据map找到nums2[st.peek()]在nums1中的下标，记录结果。

class Solution {
    public int[] nextGreaterElement(int[] nums1, int[] nums2) {
        Stack<Integer> temp = 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);
        }
        temp.add(0);
        for(int i = 1;i<nums2.length;i++){
            if(nums2[i]<=nums2[temp.peek()]){
                temp.add(i);
            }else{
                while(!temp.isEmpty()&&nums2[temp.peek()]<nums2[i]){
                    if(hashMap.containsKey(nums2[temp.peek()])){
                        Integer index = hashMap.get(nums2[temp.peek()]);
                        res[index] = nums2[i];
                    }
                    temp.pop();
                }
                temp.add(i);
            }
        }
        return res;
    }
}

精简代码如下：

class Solution {
    public int[] nextGreaterElement(int[] nums1, int[] nums2) {
        Stack<Integer> temp = 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);
        }
        temp.add(0);
        for(int i = 1;i<nums2.length;i++){
            while(!temp.isEmpty()&&nums2[temp.peek()]<nums2[i]){
                if(hashMap.containsKey(nums2[temp.peek()])){
                    Integer index = hashMap.get(nums2[temp.peek()]);
                    res[index] = nums2[i];
                }
                temp.pop();
            }
            temp.add(i);
        }
        return res;
    }
}