LeetCode-Python 栈专题（学习笔记+代码）

故里_

已于 2022-04-22 15:18:01 修改

阅读量1.1k

点赞数

分类专栏： LeetCode 文章标签： leetcode

于 2022-04-22 14:45:39 首次发布

本文链接：https://blog.csdn.net/lht0909/article/details/124343248

版权

LeetCode 专栏收录该内容

6 篇文章 3 订阅

订阅专栏

文章目录

leetcode20. 有效的括号（简单）
leetcode155. 最小栈
leetcode84. 柱状图中最大的矩形

leetcode20. 有效的括号（简单）

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

有效字符串需满足：

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

示例 1：

输入：s = “()”
输出：true

示例 2：

输入：s = “()[]{}”
输出：true

示例 3：

输入：s = “(]”
输出：false

示例 4：

输入：s = “([)]”
输出：false

示例 5：

输入：s = “{[]}”
输出：true

提示：

1 <= s.length <= 104
s 仅由括号 '()[]{}' 组成

解题思路：

算法原理
    栈先入后出特点恰好与本题括号排序特点一致，即若遇到左括号入栈，遇到右括号时将对应栈顶左括号出栈，则遍历完所有括号后 stack 仍然为空；
    建立哈希表 dic 构建左右括号对应关系：keykeykey 左括号，valuevaluevalue 右括号；这样查询 222 个括号是否对应只需 O(1)O(1)O(1) 时间复杂度；建立栈 stack，遍历字符串 s 并按照算法流程一一判断。

在这里插入图片描述第一种情况：已经遍历完了字符串，但是栈不为空，说明有相应的左括号没有右括号来匹配，所以return false

第二种情况：遍历字符串匹配的过程中，发现栈里没有要匹配的字符。所以return false

第三种情况：遍历字符串匹配的过程中，栈已经为空了，没有匹配的字符了，说明右括号没有找到对应的左括号return false

那么什么时候说明左括号和右括号全都匹配了呢，就是字符串遍历完之后，栈是空的，就说明全都匹配了。

分析完之后，代码其实就比较好写了，

但还有一些技巧，在匹配左括号的时候，右括号先入栈，就只需要比较当前元素和栈顶相不相等就可以了，比左括号先入栈代码实现要简单的多了！

# 方法一，仅使用栈，更省空间
class Solution:
    def isValid(self, s: str) -> bool:
        stack = []
        
        for item in s:
            if item == '(':
                stack.append(')')
            elif item == '[':
                stack.append(']')
            elif item == '{':
                stack.append('}')
            elif not stack or stack[-1] != item:
                return False
            else:
                stack.pop()
        
        return True if not stack else False

# 方法二，使用字典
class Solution:
    def isValid(self, s: str) -> bool:
        stack = []
        mapping = {
            '(': ')',
            '[': ']',
            '{': '}'
        }
        for item in s:
            if item in mapping.keys():
                stack.append(mapping[item])
            elif not stack or stack[-1] != item: 
                return False
            else: 
                stack.pop()
        return True if not stack else False

leetcode155. 最小栈

设计一个支持 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.

提示：

-231 <= val <= 231 - 1
pop、top 和 getMin 操作总是在 非空栈 上调用
push, pop, top, and getMin最多被调用 3 * 104 次

解题思路

题目要求在常数时间内获得栈中的最小值，因此不能在 getMin() 的时候再去计算最小值，最好应该在 push 或者 pop 的时候就已经计算好了当前栈中的最小值。

前排的众多题解中，基本都讲了「辅助栈」的概念，这是一种常见的思路，但是有没有更容易懂的方法呢？

可以用一个栈，这个栈同时保存的是每个数字 x 进栈的时候的值与插入该值后的栈内最小值。即每次新元素 x 入栈的时候保存一个元组：（当前值 x，栈内最小值）。

这个元组是一个整体，同时进栈和出栈。即栈顶同时有值和栈内最小值，top()函数是获取栈顶的当前值，即栈顶元组的第一个值； getMin() 函数是获取栈内最小值，即栈顶元组的第二个值；pop() 函数时删除栈顶的元组。

每次新元素入栈时，要求新的栈内最小值：比较当前新插入元素 x 和当前栈内最小值（即栈顶元组的第二个值）的大小。

新元素入栈：当栈为空，保存元组 (x, x)；当栈不空，保存元组 (x, min(此前栈内最小值， x)))
出栈：删除栈顶的元组。

class MinStack(object):

    def __init__(self):
        """
        initialize your data structure here.
        """
        self.stack = []
        

    def push(self, x):
        """
        :type x: int
        :rtype: void
        """
        if not self.stack:
            self.stack.append((x, x))
        else:
            self.stack.append((x, min(x, self.stack[-1][1])))
        

    def pop(self):
        """
        :rtype: void
        """
        self.stack.pop()
        

    def top(self):
        """
        :rtype: int
        """
        return self.stack[-1][0]
        

    def getMin(self):
        """
        :rtype: int
        """
        return self.stack[-1][1]

思路分析：

在代码实现的时候有两种方式：

1、辅助栈和数据栈同步

特点：编码简单，不用考虑一些边界情况，就有一点不好：辅助栈可能会存一些“不必要”的元素。

2、辅助栈和数据栈不同步

特点：由“辅助栈和数据栈同步”的思想，我们知道，当数据栈进来的数越来越大的时候，我们要在辅助栈顶放置和当前辅助栈顶一样的元素，这样做有点“浪费”。基于这一点，我们做一些“优化”，但是在编码上就要注意一些边界条件。

（1）辅助栈为空的时候，必须放入新进来的数；

（2）新来的数小于或者等于辅助栈栈顶元素的时候，才放入，特别注意这里“等于”要考虑进去，因为出栈的时候，连续的、相等的并且是最小值的元素要同步出栈；

（3）出栈的时候，辅助栈的栈顶元素等于数据栈的栈顶元素，才出栈。

总结一下：出栈时，最小值出栈才同步；入栈时，最小值入栈才同步。

对比：个人觉得“同步栈”的方式更好一些，因为思路清楚，因为所有操作都同步进行，所以调试代码、定位问题也简单。“不同步栈”，虽然减少了一些空间，但是在“出栈”、“入栈”的时候还要做判断，也有性能上的消耗。
方法一：辅助栈和数据栈同步

class MinStack:

    # 辅助栈和数据栈同步
    # 思路简单不容易出错

    def __init__(self):
        # 数据栈
        self.data = []
        # 辅助栈
        self.helper = []

    def push(self, x):
        self.data.append(x)
        if len(self.helper) == 0 or x <= self.helper[-1]:
            self.helper.append(x)
        else:
            self.helper.append(self.helper[-1])

    def pop(self):
        if self.data:
            self.helper.pop()
            return self.data.pop()

    def top(self):
        if self.data:
            return self.data[-1]

    def getMin(self):
        if self.helper:
            return self.helper[-1]

复杂度分析：

时间复杂度：O(1)O(1)O(1)，“出栈”、“入栈”、“查看栈顶元素”的操作不论数据规模多大，都只是有限个步骤，因此时间复杂度是：O(1)O(1)O(1)。
空间复杂度：O(N)O(N)O(N)，这里 NNN 是读出的数据的个数。

方法二：辅助栈和数据栈不同步

 # 关键 1：辅助栈的元素空的时候，必须放入新进来的数
    # 关键 2：新来的数小于或者等于辅助栈栈顶元素的时候，才放入（特别注意这里等于要考虑进去）
    # 关键 3：出栈的时候，辅助栈的栈顶元素等于数据栈的栈顶元素，才出栈，即"出栈保持同步"就可以了

    def __init__(self):
        # 数据栈
        self.data = []
        # 辅助栈
        self.helper = []

    def push(self, x):
        self.data.append(x)
        # 关键 1 和关键 2
        if len(self.helper) == 0 or x <= self.helper[-1]:
            self.helper.append(x)

    def pop(self):
        # 关键 3：【注意】不论怎么样，数据栈都要 pop 出元素
        top = self.data.pop()

        if self.helper and top == self.helper[-1]:
            self.helper.pop()
        return top

    def top(self):
        if self.data:
            return self.data[-1]

    def getMin(self):
        if self.helper:
            return self.helper[-1]

复杂度分析：

时间复杂度：O(1)O(1)O(1)，“出栈”、“入栈”、“查看栈顶元素”的操作不论数据规模多大，都只有有限个步骤，因此时间复杂度是：O(1)O(1)O(1)。
空间复杂度：O(N)O(N)O(N)，这里 NNN 是读出的数据的个数。

leetcode84. 柱状图中最大的矩形

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

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

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

输入：heights = [2,1,5,6,2,3]
输出：10

解释：最大的矩形为图中红色区域，面积为 10

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

输入： heights = [2,4]
输出： 4

利用单调栈
单调栈，可以理解为有单调性的一个数组，在这里我们可以理解成为栈数组，栈数组可以是单调增，也可以是单调减，在本题中我们使用的是单调增
即栈数组从0到数组最后是单调递增的。单调栈的数组性质也是我们常用的性质，到这里为止，我们对单调栈有了基本印象，一个单调递的数组
从栈底到栈顶，单调递增，可以理解为从栈数组的0位置开始到栈数组的最后一位一直是单调递增。
**单调栈的性质：**接下来我们分析单调栈的性质，因为单调栈是即栈数组是单调递增的，因此他的单调性必须一直保持，因此在遇到下一个需要插入
栈数组的值的时候，我们首先判断该值与栈顶元素相比那个大？我们设栈顶元素为a，需要插入的值为b，当a<b的时候，我们可以直接将b插入栈数组
，我们可以设原来的栈数组为[0 , a],0到a单调递增，符合单调栈的要求
1：a<b的时候 b可以直接压入栈，栈数组变成[0 , a , b]
2：a>b的时候 b无法直接压入栈，因为那样会破坏栈的单调性我们需要将a弹出栈，然后再将b压入栈
栈数组就会变成[0 , b]
单调栈的结构：

for i  in  list:
    while i is not empty and stack[-1] > i: 先调整位置。
        stack.pop()
    stack.append(i)  #当前元素无论如何也要放进去，不同的只是需不需要pop来调整位置

class Solution:
    def largestRectangleArea(self, heights: List[int]) -> int:
        size = len(heights) + 2  #因为要前后分别要加一个哨兵，所以数组的总长度需要加1
        heights = [0] + heights + [0]  #前后分别加一个哨兵，方便使用单调栈
        stack = [0]#设置单调栈
        ans = 0  #初始数，用来存储最大值矩阵面积
        for i in range(1 , size):  #遍历数组
            while heights[i] < heights[stack[-1]]:#如果遇见了第一个小于当前栈顶在数组中的值，则需要将栈顶所存储的数组的值的序号弹出栈
                  hights = heights[stack.pop()] #将栈顶所存储的数组的值的序号弹出栈，作为高度，这说明这个高度能够跨越的宽度已经到头
                  widths = i - stack[-1] - 1  #求出栈弹出的的序号在数组中的值作为的高度所走过的宽度，
                  #因为不包括前后两个，只包括中间的 因此需要-1
                  ans = max(ans , hights*widths)   #每个求出的面积都需要跟原来的比较，方便求出最大的面积
            stack.append(i)   #根本上述的如果遇见的值大于栈顶的存储的序号在数组中的值，那么就将这个序号压入栈，
            #继续寻找小于栈顶存储序号在数组中的值
        return ans