栈和队列

栈被限定必须在栈顶进行插入和删除操作，因此其特点是后进先出。

下图是栈的插入（入栈）、删除（出栈）示意图。

队列

队列被限定在队头进行删除操作，在队尾进行插入操作，因此其特点为先进后出。

下图是队列的插入（入队）、删除（出队）示意图。

 

基本操作

栈和队列的插入和删除操作上图已经解释。

【例题】

leetcode 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.
 

提示：

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

分析：

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

众多题目都会讲到“辅助栈”的概念，这是一种常见的思路，但是有没有更容易懂的方法呢？

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

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

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

1. 新元素入栈：当斩为空，保存元组（x, x）；当栈不空，保存元组（x, min(此前栈内最小值, x)）

2. 出栈：删除栈顶的元组。

class MinStack:

    def __init__(self):
        # init your data structure here.
        self.stack = []

    def push(self, val: int) -> None:
        if not self.stack:
            self.stack.append((val, val))
        else:
            self.stack.append((val, min(val, self.stack[-1][1]))) # self.stack[-1][1]解释：当前元素val入栈之前，栈顶元组为self.stack[-1], 那么该元组第一个元素为self.stack[-1][0]，该元组第二个元素为self.stack[-1][1],x就是要和这个元组中第二个元素进行比较。

    def pop(self) -> None:
        self.stack.pop() 

    def top(self) -> int:
        return self.stack[-1][0] # 返回栈顶元组第一个元素

    def getMin(self) -> int:
        return self.stack[-1][1] # 返回栈顶元组第二个元素


# Your MinStack object will be instantiated and called as such:
# obj = MinStack()
# obj.push(val)
# obj.pop()
# param_3 = obj.top()
# param_4 = obj.getMin()

【习题】

leetcode 20: 有效的括号【简单】

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

有效字符串需满足：

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

示例 1：

输入：s = "()"
输出：true

示例 2：

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

示例 3：

输入：s = "(]"
输出：false

示例 4：

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

示例 5：

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

提示：

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

分析：使用栈。

判断括号的有效性可以使用栈这一数据结构来解决。

我们遍历给定的字符串s，当我们遇到一个左括号时，我们会期望在后续遍历中，有一个相同类型的右括号将其闭合。可以将这个左括号放入栈顶。

当我们遇到一个右括号时，需要将一个相同类型的左括号闭合。此时，可以取出栈顶的左括号并判断它们是否是相同类型的括号。

如果不是相同类型的，或者栈中并没有左括号，那么字符串s无效，返回false。为了快速判断括号类型，可以使用哈希表存储每一种括号。哈希表的键为右括号，值为相同类型的左括号。

遍历结束后，如果栈中没有左括号，说明字符串s中的所有左括号闭合，返回true，否则返回false。

注意到有效字符串的长度一定为偶数，因此如果字符串的长度为奇数，可以直接返回false，省去后续的遍历判断过程。

class Solution:
    def isValid(self, s: str) -> bool:
        if len(s) % 2 == 1: # 若字符串元素数量为奇数，那么必然是不成对的。
            return False

        # 定义字典，键为右闭合符号，值为左闭合括号。
        pairs_map = {
            ")": "(",
            "]": "[",
            "}": "{",
        }

        stack = list() # 定义一个列表形式的栈，用于元素进栈和出栈
        for char in s: # 遍历输入字符串中的元素
            if char in pairs_map: # 如果字典中包含char类型元素
                if not stack or stack[-1] != pairs_map[char]: # 进一步判断，栈若为空或者栈顶元素（即预想中char的对应右闭合符号元素）不等于字典中对应的pairs_map[char]
                    return False
                stack.pop() # 将不对应的右侧元素出栈，开始对应下一个元素。
            else:
                stack.append(char) # 如果字典中不包含char元素类型元素，将char入栈。
        return not stack # 最后一步返回值，解释一下：注意到“if char in pairs_map: # 如果字典中包含char类型元素”中的执行语句，有一个出栈操作，也就是都能成功对应的话，最后stack会为空。那么，若最终stack为空，返回not stack(为空) is True；否则组队失败，not stack(非空) is False。