栈、单调栈 题解合集

目录

栈的典型应用

（1）Leetcode第20题-有效的括号

（2）Leetcode第155题-最小栈

单调栈

（1）Leetcode_T496 下一个更大元素

（2）Leetcode_T456 132模式

（3）Leetcode_T503 下一个更大元素||

（4）Leetcode_T1118

（5）Leetcode_T739 每日温度

（6）Leetcode_T121 买卖股票的最佳时机

（7）Leetcode_T42 接雨水

（8）Leetcode_T84 柱状图中最大的矩形

栈的典型应用

（1）Leetcode第20题-有效的括号

20. 有效的括号 - 力扣（LeetCode） (leetcode-cn.com)

给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。

有效字符串需满足：

左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。

思路：

(1)如果字符串长度为奇数，直接返回false

(2)最开始左括号入栈，当遇到右括号时，判断：

(3)栈不为空并且栈顶左括号与这个右括号匹配，则栈顶左括号出栈

当栈为空或者栈顶元素与这个右括号不匹配，直接返回false

(4)可以遍历完，则返回true

【小细节】判断左右括号是否匹配，可以用哈希先预存对应关系，也可以根据相匹配的括号的ASCII的值相差为2

代码：

 public boolean isValid(String s) {
//        如果字符串长度为奇数,必然匹配不够,返回false
        int n = s.length();
        if(n % 2 == 1){
            return false;
        }
//        用哈希表存储括号,便于比较
        Map<Character,Character> map = new HashMap<Character,Character>(){{
            put(')','(');
            put('}','{');
            put(']','[');
        }};
        Deque<Character> stack = new LinkedList<Character>();
        for (int i = 0; i < n; i++) {
            char c = s.charAt(i);
            if(map.containsKey(c)){
                if(stack.isEmpty() || stack.peek() != map.get(c)){
                    return false;
                }
                stack.pop();
            }
            else{
                stack.push(c);
            }
        }
        return stack.isEmpty();
    }

（2）Leetcode第155题-最小栈

155. 最小栈 - 力扣（LeetCode） (leetcode-cn.com)

设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。

push(x) —— 将元素 x 推入栈中。
pop() —— 删除栈顶的元素。
top() —— 获取栈顶元素。
getMin() —— 检索栈中的最小元素。

思路：此题关键是检索栈中最小元素，这里我们用辅助栈，辅助栈与原栈同步进行

对于辅助栈s2，每push一个新元素x：

s2.push(Math.min(s2.peek(),x))

对于辅助栈s2，每pop一个新元素，s2也pop元素

代码：

public class MinStack {
    Deque<Integer> stack;
    Deque<Integer> minStack;

    //    无参构造初始化
    public MinStack() {
        stack = new LinkedList<>();
        minStack = new LinkedList<>();
        minStack.push(Integer.MAX_VALUE);
    }

    //    入栈
    public void push(int val) {
        stack.push(val);
        minStack.push(Math.min(minStack.peek(), val));
    }

    //    出栈
    public void pop() {
        stack.pop();
        minStack.pop();
    }

    //    返回栈顶元素
    public int top() {
        return stack.peek();

    }

    //    返回最小值
    public int getMin() {
        return minStack.peek();
    }

}

单调栈

单调栈——栈内元素要么按照单调递增顺序要么单调递减顺序

（1）Leetcode_T496 下一个更大元素

496. 下一个更大元素 I - 力扣（LeetCode） (leetcode-cn.com)

nums1 中数字 x 的 下一个更大元素 是指 x 在 nums2 中对应位置 右侧 的 第一个 比 x 大的元素。

给你两个 没有重复元素 的数组 nums1 和 nums2 ，下标从 0 开始计数，其中nums1 是 nums2 的子集。

对于每个 0 <= i < nums1.length ，找出满足 nums1[i] == nums2[j] 的下标 j ，并且在 nums2 确定 nums2[j] 的 下一个更大元素 。如果不存在下一个更大元素，那么本次查询的答案是 -1 。

返回一个长度为 nums1.length 的数组 ans 作为答案，满足 ans[i] 是如上所述的 下一个更大元素 

整体思路：

遍历nums2，将nums2中每个元素对应的下一个更大元素存储到哈希表中

再遍历nums1，从哈希表中找到nums1各个元素对应的下一个更大元素即可

局部——如何找nums2中每个元素对应的下一个更大元素

维护一个单调递减栈，对于nums2，从后向前遍历，对于元素x，如果单调栈为空，说明没有比x更大的，直接返回 - 1,如果栈不为空，则依次比较x与栈顶元素大小，栈顶不是更大的就换下一个栈顶，直到找到更大的或者栈为空了

【注意】每次的x都要入栈，作为下一个元素比较之一

代码：

    public int[] nextGreaterElement(int[] nums1, int[] nums2) {
//        哈希表，用于存储nums2中元素与下一个更大元素的对应关系
        Map<Integer, Integer> map = new HashMap<>();
        Deque<Integer> stack = new LinkedList<>();
        int n = nums2.length;
//        类似739题，但是是找nums2中元素的下一个更大元素
//        这里注意，从最后一个元素反着来，不然找不到类似3，1，4中3的下一个更大元素
        for (int i = n - 1; i >= 0; i--) {
            while (!stack.isEmpty() && nums2[i] >= stack.peek()) {
                stack.pop();
            }
            map.put(nums2[i], stack.isEmpty() ? -1 : stack.peek());
            stack.push(nums2[i]);
        }
        int res[] = new int[nums1.length];
//        从哈希表中找与nums1元素值相等的对应的元素
        for (int i = 0; i < res.length; i++) {
            res[i] = map.get(nums1[i]);
        }
        return res;
    }

（2）Leetcode_T456 132模式

456. 132 模式 - 力扣（LeetCode） (leetcode-cn.com)

给你一个整数数组 nums ，数组中共有 n 个整数。132 模式的子序列 由三个整数 nums[i]、nums[j] 和 nums[k] 组成，并同时满足：i < j < k 和 nums[i] < nums[k] < nums[j] 。

如果 nums 中存在 132 模式的子序列 ，返回 true ；否则，返回 false 。

整体思路：对于3,要保证3大于1又小于2，同时，3又是最后一个元素，所以我们从这里入手

从右向左遍历，维护一个单调递减栈，元素入栈，当遇到比栈顶元素大的，说明可以构成互逆的32模式，现在只差找1了，我们先将栈内比2小的元素出栈，引入变量k,令k等于最大的3，也即出栈元素中最大的（因为3>1，所以尽可能找最大的3），接着入栈，当可以找到一个新入栈元素 < k时，说明可以找到1，返回true

代码：

class Solution {
    public boolean find132pattern(int[] nums) {
        int n = nums.length;
        int m = Integer.MIN_VALUE;
        Deque<Integer> stack = new LinkedList<>();
//        从右向左遍历，维护一个单调递减栈，更小的直接入栈
        for (int i = n - 1; i >= 0; i--) {
//            只要能遇到小于m的，说明存在1，符合132模式
            if (nums[i] < m) return true;
//            当遇到大于栈顶的，说明遇到了一对2、3，将大于2的3全部出栈，并令m=最大的那个3
            while (!stack.isEmpty() && stack.peek() < nums[i]) {
                m = stack.pop();
            }
            stack.push(nums[i]);
        }
        return false;

    }
}

（3）Leetcode_T503 下一个更大元素||

503. 下一个更大元素 II - 力扣（LeetCode） (leetcode-cn.com)

给定一个循环数组（最后一个元素的下一个元素是数组的第一个元素），输出每个元素的下一个更大元素。数字 x 的下一个更大的元素是按数组遍历顺序，这个数字之后的第一个比它更大的数，这意味着你应该循环地搜索它的下一个更大的数。如果不存在，则输出 -1。

思路：两个for循环暴力求解也是可以通过的，但因为时间复杂度为O（n^2),效率低

故而我们借助单调栈求解

单调栈存储的是元素索引下标，因为是循环数组，所以for循环从 0--2*长度-1，通过模n运算，达到循环遍历的目的。

【注意】目标数组一开始赋初值为-1，再借助单调栈，遇到比栈顶元素大的，说明遇到了下一个更大元素，将栈内元素出栈并在目标数组中更新这些元素的下一个更大元素

//下一个更大元素||
public class Leetcode_T503 {
    //    单调栈存储下标
    public int[] nextGreaterElements(int[] nums) {
        int n = nums.length;
        int[] res = new int[n];
//        默认为 -1
        Arrays.fill(res, -1);
        Deque<Integer> stack = new LinkedList<>();
        int count = 2 * n - 1;
        for (int i = 0; i < count; i++) {
            while (!stack.isEmpty() && nums[stack.peek()] < nums[i % n]) {
                res[stack.pop()] = nums[i % n];
            }
            stack.push(i % n);
        }
        return res;
    }
}
//    自己的本能解法：两个for循环遍历，暴力求解
//    public int[] nextGreaterElements(int[] nums) {
//        int n = nums.length;
//        int[] res = new int[n];
//        if(n == 1){
//            res[0] = -1;
//            return res;
//        }
//        for (int i = 0; i < n; i++) {
//            for (int count = 0; count < n; count++) {
//                if(nums[(i + count) % n] > nums[i]){
//                    res[i] = nums[(i + count) % n];
//                    break;
//                }else{
//                    res[i] = -1;
//                }
//            }
//        }
//        return res;
//    }
//}

（4）Leetcode_T1118

OMG 这道题是会员题。。。。。QAQ 

（5）Leetcode_T739 每日温度

739. 每日温度 - 力扣（LeetCode） (leetcode-cn.com)

请根据每日 气温 列表 temperatures ，请计算在每一天需要等几天才会有更高的温度。如果气温在这之后都不会升高，请在该位置用 0 来代替。

整体思路：维护一个单调递减栈，当遇到温度比栈顶温度高的，说明已找到栈顶元素的下一个更高温度，并让栈顶出栈，这里，因为是单调递减栈，所以用while结构，不断出栈，直到保持递减

局部：因为问的不是下一个更高温度，而是几天后，所以我们可以让栈中存储元素索引下标，下标之差即为天数之差

    public int[] dailyTemperatures(int[] temperatures) {
        int[] ans = new int[temperatures.length];
//        单调栈记录温度的索引下标
        Deque<Integer> stack = new LinkedList<>();
        int n = temperatures.length;
        for (int i = 0; i < n; i++) {
//            栈不为空并且当前索引温度大于栈顶索引的温度时，记录栈顶索引的等待天数并将其出栈
            while (!stack.isEmpty() && temperatures[i] > temperatures[stack.peek()]) {
                int index = stack.pop();
                ans[index] = i - index;

            }
//            栈为空或者当前温度小于等于栈顶索引温度时，将当前索引入栈
            stack.push(i);
        }
        return ans;
    }

（6）Leetcode_T121 买卖股票的最佳时机

121. 买卖股票的最佳时机 - 力扣（LeetCode） (leetcode-cn.com)

给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。

你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。

返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。

思路：

方法一：两个for循环暴力求解

方法二：单调栈

维护一个单调栈，当遇到比栈顶小的，令栈顶出栈，最新的小元素入栈

当遇到比栈顶大的，更新利润值（栈顶保持是目前遍历到的最小，相当于在栈顶那天买入）

方法三：动态规划

类似于单调栈的思路，也是一步步更新最小值，以确定最大利益

dp[i]表示截止到第i天的最低价格，dp[i] = Math.min(dp[i - 1] , price[i])

res是利润，res = Math.max(res , price[i] - dp[i])

代码：

   public int maxProfit(int[] prices) {
        Deque<Integer> stack = new LinkedList<>();
        int n = prices.length;
        int max = 0;
        stack.push(prices[0]);
        for (int i = 1; i < n; i++) {
            if (prices[i] < stack.peek()) {
                int m = stack.pop();
                stack.push(prices[i]);
            } else {
                max = Math.max(max, prices[i] - stack.peek());
            }
        }
        return max;
    }
//动规解法
//public int maxProfit(int[] prices) {
//    int n = prices.length;
//    int res = 0;
//    int[]dp = new int[n];
//    dp[0] = prices[0];
//    for(int i = 1; i < n; i++){
//        dp[i] = Math.min(dp[i - 1],prices[i]);
//        res = Math.max(res, prices[i] - dp[i]);
//    }
//    return res;
//
//}

（7）Leetcode_T42 接雨水

42. 接雨水 - 力扣（LeetCode） (leetcode-cn.com)

给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。

示例 1：

思路：这道题解法也有多种，诸如动规、双指针，当然也可以使用单调栈，这里，我们主要讲单调栈的解法

 整体思路：

维护一个单调递减栈，当栈内元素个数大于等于2并且新入栈元素大于栈顶时，形成一个低洼，这里可以接到雨水

求低洼处雨水面积：

• 待处理的低洼处我们用变量cur表示，cur = stack.pop()
• 当cur出栈后，新的栈顶即是低洼的左边界，用left表示，left = stack.peek()
• 右边界即为新遇到的这个较大的元素
• 雨水面积 = 底长 * 高度，对于底长，是right - left - 1(我们单调栈中存储索引下标),之于高度，是左右边界较低的高度再减去底座高度（底座高度就是cur的高度）

【注意】因为在计算高度时会减去底座高度，所以即使遇到平地型低洼，如2 1 1 2，我们的算法也依然正确，在cur=右边的1时，左边界为1，高度会减为0，所以并没有重复计算面积，只有cur=左边的1时，才会计算这处低洼的面积

代码实现：

    public int trap(int[] height) {
        int n = height.length;
        int res = 0;
        Deque<Integer> stack = new LinkedList<>();
        for (int i = 0; i < n; i++) {
            while(!stack.isEmpty() && height[i] > height[stack.peek()]){
                int cur = stack.pop();
//                栈内元素至少为2个才能和大的元素构成雨水区域，否则是边界,跳出while
                if(stack.isEmpty()){
                    break;
                }
                int left = stack.peek();
                int right = i;
//                宽度由左右边界相减得来
                int width = right - left - 1;
//                这里注意，高度是左右俩边界较低的那个，再减去底座高度
//                所以不必担心平地的情况，譬如2 1 1 2，右边那个1的左边界为1，计算高度时会减为0，只要cur为左边的1时，左边界为2，高度为1
                int high = Math.min(height[left],height[right]) - height[cur];
                res += width * high;
            }
            stack.push(i);
        }
        return res;
    }

（8）Leetcode_T84 柱状图中最大的矩形

84. 柱状图中最大的矩形 - 力扣（LeetCode） (leetcode-cn.com)

给定 n 个非负整数，用来表示柱状图中各个柱子的高度。每个柱子彼此相邻，且宽度为 1 。

求在该柱状图中，能够勾勒出来的矩形的最大面积

示例 1:

输入：heights = [2,1,5,6,2,3]
输出：10
解释：最大的矩形为图中红色区域，面积为 10

思路：与接雨水差不多，都是求面积，但是这里，我们维护一个单调递增栈，当遇到小于栈顶的元素时，令cur = stack.pop() ，然后找以cur为高度的矩形的最大面积，同样是找左右边界以求宽，所以栈内存储的仍是索引下标

class Solution {
    public int largestRectangleArea(int[] heights) {
        int ret = 0;
        Deque<Integer> stack = new ArrayDeque<>();
        int length = heights.length;
        int[] h = new int[length + 2];
//        在高度数组左右加0作为边界
        for (int i = 0; i < length; i++) {
            h[i + 1] = heights[i];
        }
        for (int i = 0; i < length + 2; i++) {
//            当新入栈元素小于栈顶时，出栈并计算该栈顶元素能组成的最大矩形
            while (!stack.isEmpty() && h[stack.peek()] > h[i]) {
                int cur = stack.pop();
//                左边界
                int left = stack.peek();
//                右边界
                int right = i;
                ret = Math.max(ret, (right - left - 1) * h[cur]);
            }
//            栈中存储的实际是元素索引下标，为了计算左右边界（宽）
            stack.push(i);
        }
        return ret;
    }
}