代码随想录算法训练营第48天|LeetCode 739. 每日温度、496.下一个更大元素 I、503.下一个更大元素II

1. LeetCode 739. 每日温度

题目链接：https://leetcode.cn/problems/daily-temperatures/description/
文章链接：https://programmercarl.com/0739.每日温度.html
视频链接：https://www.bilibili.com/video/BV1my4y1Z7jj/

思路：
本题计算右边第一个大于当前温度的天数，因此使用单调栈，且是递增。

解法：
class Solution {
    // public int[] dailyTemperatures(int[] temperatures) {
    //     //暴力
    //     int[] answer = new int[temperatures.length];

    //     for (int i=0;i<temperatures.length-1;i++) {
    //         int num=0;
    //         for (int j=i+1;j<temperatures.length;j++) {
    //             num++;
    //             if (temperatures[j]>temperatures[i]) {
    //                 answer[i] = num;
    //                 break;
    //             }
    //         }
    //     }

    //     return answer;
    // }

    // 单调栈
    public int[] dailyTemperatures(int[] temperatures) {
        if (temperatures.length == 1) {
            return new int[]{0};
        }
        //定义单调栈
        Deque<Integer> stack = new ArrayDeque<>(); 
        stack.push(0);
        int[] result = new int[temperatures.length];
        
        for (int i = 1; i < temperatures.length; i++) {
            int head = stack.peek();
            if (temperatures[head] >= temperatures[i]) {
                stack.push(i);
            } else {
                while (!stack.isEmpty() && temperatures[stack.peek()] < temperatures[i]) {
                    result[stack.peek()] = i - stack.peek();
                    stack.pop();
                }
                stack.push(i);
            }
        }
        return result;

    }

}

2. LeetCode 496.下一个更大元素 I

题目链接：https://leetcode.cn/problems/next-greater-element-i/submissions/556159259/
文章链接：https://programmercarl.com/0496.下一个更大元素I.html#算法公开课
视频链接：https://www.bilibili.com/video/BV1jA411m7dX/

思路：
本题求下一个更大的元素，因此使用单调栈，且是递增的。

class Solution {
    // public int[] nextGreaterElement(int[] nums1, int[] nums2) {
    //     // 单调栈
    //     if (nums2.length == 1) {
    //         return new int[]{-1};
    //     }
    //     Deque<Integer> stack = new ArrayDeque<>();
    //     stack.push(0);

    //     int[] big = new int[nums2.length];
    //     for (int i=0; i<big.length; i++) {
    //         big[i] = -1;
    //     }

    //     for (int i = 1; i < nums2.length; i++) {
    //         int head = stack.peek();
    //         if (nums2[head] >= nums2[i]) {
    //             stack.push(i);
    //         } else {
    //             while (!stack.isEmpty() && nums2[stack.peek()] < nums2[i]) {
    //                 big[stack.peek()] = nums2[i];
    //                 stack.pop();
    //             }
    //             stack.push(i);
    //         }
    //     }

    //     int[] ans = new int[nums1.length];
    //     for (int i=0;i<nums1.length;i++) {
    //         int index = getIndex(nums1[i],nums2);
    //         ans[i] = big[index];
    //     }

    //     return ans;
    // }

    // public int getIndex(int num,int[] nums2) {

    //     for (int i=0;i<nums2.length;i++) {
    //         if (nums2[i] == num) {
    //             return i;
    //         }
    //     }
    //     return -1;
    // }

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

}

3. LeetCode 503.下一个更大元素II

题目链接：https://leetcode.cn/problems/next-greater-element-ii/
文章链接：https://programmercarl.com/0503.下一个更大元素II.html#思路
视频链接：https://www.bilibili.com/video/BV15y4y1o7Dw/

思路：
本题要获取下一个更大的元素，则使用单调栈，且是递增。
注意：在遍历的过程中如何模拟走两边nums。

解法：
class Solution {
    public int[] nextGreaterElements(int[] nums) {
        //定义单调栈
        Deque<Integer> stack = new ArrayDeque<>();
        int[] res = new int[nums.length];
        Arrays.fill(res,-1);
        stack.push(0);
        for (int i=1;i<2*nums.length;i++) {
            if (nums[stack.peek()] >= nums[i%nums.length]) {
                stack.push(i%nums.length);
            } else {
                while (!stack.isEmpty() && nums[stack.peek()] < nums[i%nums.length]) {
                    res[stack.peek()] = nums[i%nums.length];//处理逻辑
                    stack.pop();
                }
                stack.push(i%nums.length);
            }
        }

        return res;
    }
}