算法（十二）栈

LightYoungLee

已于 2023-10-23 05:39:04 修改

阅读量273

点赞数

分类专栏：算法文章标签：数据结构栈算法

于 2021-03-07 10:00:13 首次发布

本文链接：https://blog.csdn.net/weixin_37688445/article/details/114477759

版权

算法专栏收录该内容

20 篇文章 3 订阅

订阅专栏

leetcode

[hot] 20. 有效的括号

题目

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

有效字符串需满足：

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

示例 1：

输入：s = "()"
输出：true
示例 2：

输入：s = "()[]{}"
输出：true
示例 3：

输入：s = "(]"
输出：false
示例 4：

输入：s = "([)]"
输出：false
示例 5：

输入：s = "{[]}"
输出：true

题解

栈解决问题，Switch case写法更直观，示例代码如下：

class Solution {
public:
    bool isValid(string s) {
        stack<char> stk;
        for (char c : s) {
            switch (c) {
                case '(':
                    stk.push(')');
                    break;
                case '[':
                    stk.push(']');
                    break;
                case '{':
                    stk.push('}');
                    break;
                default:
                    if (stk.empty() || stk.top() != c) {
                        return false;
                    }
                    stk.pop();
            }
        }
        return stk.empty();
    }
};

复杂度

时间复杂度： $O (n)$ ，n为字符串长度
空间复杂度： $O (n)$ ，栈的辅助空间大小

[hot] 84. 柱状图中最大的矩形

题目

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

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

在这里插入图片描述

示例:

输入: [2,1,5,6,2,3]
输出: 10

题解

单调栈解决问题，注意本题为"勾勒"出的面积，而不是能装入水的面积。对于某个柱子而言，勾勒出面积的最大高度不会超过这个柱子本身的高度。

class Solution {
public:
    int largestRectangleArea(vector<int>& heights) {
        int length = heights.size();
        if (length == 0) {
            return 0;
        }
        stack<int> stk;
        vector<int> left(length);
        vector<int> right(length);

        for (int i = 0; i < length; ++i) {
            while (!stk.empty() && heights[stk.top()] >= heights[i]) {
                stk.pop(); // pop为的是找到从左边起第一个小于heights[i]的元素
            }
            // 从stk.top()到heights[i]之间所有位置对应的元素都要比heights[i]大
            left[i] = stk.empty() ? -1 : stk.top(); // 左边初始化为-1
            stk.push(i);
        }

        stk = stack<int>();
        for (int i = length - 1; i >= 0; --i) {
            while (!stk.empty() && heights[stk.top()] >= heights[i]) {
                stk.pop(); // pop为的是找到从右边起第一个小于heights[i]的元素
            }
            // 从heights[i]到stk.top()之间所有位置对应的元素都要比heights[i]大
            right[i] = stk.empty() ? length : stk.top(); // 右边初始化为length
            stk.push(i);
        }

        int result = -1;
        for (int i = 0; i < length; ++i) {
            result = max((right[i] - left[i] - 1) * heights[i], result);
        }

        return result;
    }
};

复杂度

时间复杂度： $O (n)$
空间复杂度： $O (n)$

关键点

每个位置的最大矩形，一定要完全覆盖这个位置对应的元素！

[hot] 85. 最大矩形

题目

给定一个仅包含 0 和 1 、大小为 rows x cols 的二维二进制矩阵，找出只包含 1 的最大矩形，并返回其面积。

示例 1：
在这里插入图片描述

输入：matrix = [[“1”,“0”,“1”,“0”,“0”],[“1”,“0”,“1”,“1”,“1”],[“1”,“1”,“1”,“1”,“1”],[“1”,“0”,“0”,“1”,“0”]]
输出：6
解释：最大矩形如上图所示。

题解

套用<84. 柱状图中最大的矩形>思路，从列方向，将一维数组扩展成二维，示例代码如下所示：

class Solution {
public:
    int maximalRectangle(vector<vector<char>>& matrix) {
        int m = matrix.size();
        if (m == 0) {
            return 0;
        }
        int n = matrix[0].size();
        // 列维度计算每一维的取值
        vector<vector<int>> left(m, vector<int>(n, 0));
        for (int i = 0; i < m; ++i) {
            for (int j = 0; j < n; ++j) {
                if (matrix[i][j] == '1') {
                    left[i][j] = (j == 0 ? 0 : left[i][j - 1]) + 1;
                }
            }
        }
        int ret = 0;
        for (int j = 0; j < n; ++j) {
            vector<int> up(m, 0);
            vector<int> down(m, 0);
            stack<int> stk;
            for (int i = 0; i < m; ++i) {
                while (!stk.empty() && left[stk.top()][j] >= left[i][j]) {
                    stk.pop();
                }
                up[i] = stk.empty() ? -1 : stk.top();
                stk.push(i);
            }

            stk = stack<int>();
            for (int i = m - 1; i >= 0; --i) {
                while (!stk.empty() && left[stk.top()][j] >= left[i][j]) {
                    stk.pop();
                }
                down[i] = stk.empty() ? m : stk.top();
                stk.push(i);  
            }

            for (int i = 0; i < m; ++i) {
                int height = down[i] - up[i] - 1;
                int area = height * left[i][j];
                ret = max(ret, area);
            }
        }

        return ret;
    }
};

复杂度

时间复杂度： $O (mn)$
空间复杂度： $O (mn)$

[hot] 155. 最小栈

题目

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

实现 MinStack 类:

MinStack() 初始化堆栈对象。
void push(int val) 将元素val推入堆栈。
void pop() 删除堆栈顶部的元素。
int top() 获取堆栈顶部的元素。
int getMin() 获取堆栈中的最小元素。

示例 1:

输入：
["MinStack","push","push","push","getMin","pop","top","getMin"]
[[],[-2],[0],[-3],[],[],[],[]]

输出：
[null,null,null,null,-3,null,0,-2]

解释：
MinStack minStack = new MinStack();
minStack.push(-2);
minStack.push(0);
minStack.push(-3);
minStack.getMin();   --> 返回 -3.
minStack.pop();
minStack.top();      --> 返回 0.
minStack.getMin();   --> 返回 -2.

题解

辅助栈解决问题，示例代码如下：

class MinStack {
public:
    MinStack() {
        min_stk.push(INT_MAX);
    }
    
    void push(int val) {
        x_stk.push(val);
        min_stk.push(min(min_stk.top(), val));
    }
    
    void pop() {
        x_stk.pop();
        min_stk.pop();
    }
    
    int top() {
        return x_stk.top();
    }
    
    int getMin() {
        return min_stk.top();
    }
private: 
    stack<int> x_stk;
    stack<int> min_stk;
};

/**
 * Your MinStack object will be instantiated and called as such:
 * MinStack* obj = new MinStack();
 * obj->push(val);
 * obj->pop();
 * int param_3 = obj->top();
 * int param_4 = obj->getMin();
 */

[hot] 739. 每日温度

题目

请根据每日气温列表，重新生成一个列表。对应位置的输出为：要想观测到更高的气温，至少需要等待的天数。如果气温在这之后都不会升高，请在该位置用 0 来代替。例如，给定一个列表 temperatures = [73, 74, 75, 71, 69, 72, 76, 73]，你的输出应该是 [1, 1, 4, 2, 1, 1, 0, 0]。

提示：气温列表长度的范围是 [1, 30000]。每个气温的值的均为华氏度，都是在 [30, 100] 范围内的整数。

题解

用栈来模拟寻找遍历元素小的元素，示例代码如下：

class Solution {
public:
    vector<int> dailyTemperatures(vector<int>& temperatures) {
        int length = temperatures.size();
        vector<int> res(length, 0);
        stack<int> stk;
        for (int i = 0; i < length; ++i) {
            // while保证每个元素都能刷新到
            while (!stk.empty() && temperatures[i] > temperatures[stk.top()]) {
                int pre_idx = stk.top();
                res[pre_idx] = i - pre_idx;
                stk.pop();
            }
            stk.push(i);
        }
        return res;
    }
};

复杂度

时间复杂度： $O (n)$ ，数组中每个元素最多进入和弹出栈一次
空间复杂度： $O (n)$ ，栈辅助空间

关键点

代码中的while

剑指offer

9. 两个栈实现队列

题目

用两个栈实现一个队列。队列的声明如下，请实现它的两个函数 appendTail 和 deleteHead ，分别完成在队列尾部插入整数和在队列头部删除整数的功能。(若队列中没有元素，deleteHead 操作返回 -1 )

示例 1：

输入：
["CQueue","appendTail","deleteHead","deleteHead"]
[[],[3],[],[]]
输出：[null,null,3,-1]
示例 2：

输入：
["CQueue","deleteHead","appendTail","appendTail","deleteHead","deleteHead"]
[[],[],[5],[2],[],[]]
输出：[null,-1,null,null,5,2]

题解

定义两个栈，一个栈用来push，一个栈用来pop，push很简单不多说，pop的时候先从push_stk将元素依次导入pop_stk，然后再pop pop_stk的栈顶元素。示例代码如下所示：

class CQueue {
public:
    stack<int> stk1;
    stack<int> stk2;

    CQueue() {}
    
    void appendTail(int value) {
        stk1.push(value);
    }
    
    int deleteHead() {
        if (stk2.empty()) {
            while (!stk1.empty()) {
                stk2.push(stk1.top());
                stk1.pop();
            }
        }
	
		// 队列里没有元素可以弹出
        if (stk2.empty()) {
            return -1;
        }
        int top = stk2.top();
        stk2.pop();

        return top;
    }
};

/**
 * Your CQueue object will be instantiated and called as such:
 * CQueue* obj = new CQueue();
 * obj->appendTail(value);
 * int param_2 = obj->deleteHead();
 */

复杂度

时间复杂度： $O (n)$
空间复杂度： $O (n)$

31. 栈的压入、弹出序列

题目

输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如，序列 {1,2,3,4,5} 是某栈的压栈序列，序列 {4,5,3,2,1} 是该压栈序列对应的一个弹出序列，但 {4,3,5,1,2} 就不可能是该压栈序列的弹出序列。

示例 1：
输入：pushed = [1,2,3,4,5], popped = [4,5,3,2,1]
输出：true
解释：我们可以按以下顺序执行：
push(1), push(2), push(3), push(4), pop() -> 4,
push(5), pop() -> 5, pop() -> 3, pop() -> 2, pop() -> 1

示例 2：
输入：pushed = [1,2,3,4,5], popped = [4,3,5,1,2]
输出：false
解释：1 不能在 2 之前弹出。

题解

定义辅助栈来模拟栈的压入和弹出过程，从而判断压入和弹出队列是否符合要求，示例代码如下所示：

class Solution {
public:
    bool validateStackSequences(vector<int>& pushed, vector<int>& popped) {
        int length = pushed.size();
        stack<int> stk;
        int push_i = 0;

        for (int i = 0; i < length; ++i) {
            while (push_i < length && (stk.empty() || stk.top() != popped[i])) {
                stk.push(pushed[push_i++]);
            }

            if (stk.top() != popped[i]) {
                return false;
            }
            stk.pop();
        }

        return stk.empty() && (push_i == length);
    }
};