代码随想录算法训练营Day58|LC739 每日温度&LC496 下一个更大元素I

一句话总结：单调栈专题！

原题链接：739 每日温度

很简单的单调栈入门题。

在使用单调栈解决此题之前，先要想到：单调栈要什么时候用呢？怎么才能想到用单调栈呢？ 什么时候用单调栈呢？

答：通常是一维数组，要寻找任一个元素的右边或者左边第一个比自己大或者小的元素的位置，此时我们就要想到可以用单调栈了。

单调栈的时间复杂度为O(n)。

例如本题其实就是找找到一个元素右边第一个比自己大的元素，此时就应该想到用单调栈了。

再问：单调栈的原理是什么呢？为什么时间复杂度是O(n)就可以找到每一个元素的右边第一个比它大的元素位置呢？

答：单调栈的本质是空间换时间，在遍历的过程中利用一个栈来记录右边第一个比当前元素高的元素，优点是整个数组只需要遍历一次。更直白来说，就是用一个栈来记录我们遍历过的元素，因为我们遍历数组的时候，我们不知道之前都遍历了哪些元素，以至于遍历一个元素找不到是不是之前遍历过一个更小的，所以我们需要用一个容器（这里用单调栈）来记录我们遍历过的元素。

在使用单调栈的时候首先要明确如下几点：

• 单调栈里存放的元素是什么？

单调栈里只需要存放元素的下标i就可以了，如果需要使用对应的元素，直接T[i]就可以获取。

• 单调栈里元素是递增呢？ 还是递减呢？

以下解题过程中，顺序的描述为：从栈顶到栈底的顺序，因为单纯的说从左到右或者从前到后，不说栈顶朝哪个方向的话，就会比较懵。

这里我们要使用递增顺序（再强调一下是指从栈顶到栈底的顺序），因为只有递增的时候，栈里要加入一个元素i的时候，才知道栈顶元素在数组中右面第一个比栈顶元素大的元素是i。

即：如果求一个元素右边第一个更大元素，单调栈就是递增的，如果求一个元素右边第一个更小元素，单调栈就是递减的。

使用单调栈主要有三个判断条件：

• 当前遍历的元素T[i]小于栈顶元素T[st.peek()]的情况；
• 当前遍历的元素T[i]等于栈顶元素T[st.peek()]的情况；
• 当前遍历的元素T[i]大于栈顶元素T[st.peek()]的情况。

接下来是题解过程：

首先将0入栈，代表的是将下标为0的元素入栈；

然后分别依次遍历数组后序元素，如果当前遍历元素T[i]小于栈顶元素T[st.peek()]，那么将i入栈；

如果T[i] == T[st.peek()]，由于求解的是严格大于的是哪天，因此这里也将i入栈；

接下来最重要的是第三种情况，当T[i] > T[st.peek()]，这里就需要将其作为答案置入ans数组中，并且将栈顶元素出栈；同时还需要不停地比较出栈后的栈顶元素与当前元素，只要比当前元素小就可以计算ans[st.peek()]的值，直到栈顶元素比T[i]大，或者栈为空；计算完答案后，再将当前T[i]的下标i入栈，以完成后续的计算。

以下是完整代码：

class Solution {
    public int[] dailyTemperatures(int[] temperatures) {
        Stack<Integer> st = new Stack<>();
        int[] ans = new int[temperatures.length];
        st.push(0);
        for (int i = 1; i < temperatures.length; ++i) {
            if (temperatures[st.peek()] >= temperatures[i]) st.push(i);
            else {
                while (!st.isEmpty() && temperatures[st.peek()] < temperatures[i]) {
                    ans[st.peek()] = i - st.peek();
                    st.pop();
                }
                st.push(i);
            }
        }
        return ans;
    }
}

原题链接：496 下一个更大元素I

多了一道两个数组的转换过程，其实本质是一样的。代码如下：

class Solution {
    public int[] nextGreaterElement(int[] nums1, int[] nums2) {
        Stack<Integer> stack = new Stack<>();
        int[] ans = new int[nums1.length];
        Arrays.fill(ans, -1);
        Map<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < nums1.length; ++i) {
            map.put(nums1[i], i);
        }
        stack.add(0);
        for (int i = 1; i < nums2.length; ++i) {
            if (nums2[i] <= nums2[stack.peek()]) stack.add(i);
            else {
                while (!stack.isEmpty() && nums2[stack.peek()] < nums2[i]) {
                    if (map.containsKey(nums2[stack.peek()])) {
                        int j = map.get(nums2[stack.peek()]);
                        ans[j] = nums2[i];
                    }
                    stack.pop();
                }
                stack.add(i);
            }
        }
        return ans;
    }
}

 同时还有一种利用数组的解法，由于数据范围不大， 因此利用两个数组即可优化时空复杂度。代码如下：

class Solution {
    public int[] nextGreaterElement(int[] nums1, int[] nums2) {
        int[] hash = new int[10001];
        int[] stack = new int[nums2.length];
        int top = 0;

        for(int i = 0; i < nums2.length; i++) {
            while(top > 0 && nums2[i] > nums2[stack[top - 1]]){
                hash[nums2[stack[top - 1]]] = nums2[i];
                top--;
            }
            stack[top++] = i;
        }

        int[] ans = new int[nums1.length];
        for(int i = 0; i < nums1.length; i++) {
            ans[i] = hash[nums1[i]] == 0 ?- 1 : hash[nums1[i]];
        }
        return ans;
    }
}