DAY 10 栈和队列

栈与队列理论基础

队列是先进先出，栈是先进后出。

如图所示：

---

---

 

232. 用栈实现队列  

【简单】 

 算法思想：用两个栈一个输入栈，一个输出栈。在push数据的时候，只要数据放进输入栈就好，但在pop的时候，操作就复杂一些，输出栈如果为空，就把进栈数据全部导入进来（注意是全部导入）

class MyQueue:

    def __init__(self):
        """
        in主要负责push，out主要负责pop
        """
        self.stack_in = [] #实质是list
        self.stack_out = []


    def push(self, x: int) -> None:
        """
        有新元素进来，就往in里面push
        """
        self.stack_in.append(x)


    def pop(self) -> int:
        """
        Removes the element from in front of queue and returns that element.
        """
        if self.empty():
            return None
        
        if self.stack_out:
            return self.stack_out.pop()
        else:
            for i in range(len(self.stack_in)):
                self.stack_out.append(self.stack_in.pop())
            return self.stack_out.pop()


    def peek(self) -> int:
        """
        Get the front element.
        """
        ans = self.pop()
        self.stack_out.append(ans)
        return ans


    def empty(self) -> bool:
        """
        只要in或者out有元素，说明队列不为空
        """
        return not (self.stack_in or self.stack_out)

• 时间复杂度: push和empty为O(1), pop和peek为O(n)
• 空间复杂度: O(n)

---

---

 

225. 用队列实现栈 

【简单】请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。

实现 MyStack 类：

• void push(int x) 将元素 x 压入栈顶。
• int pop() 移除并返回栈顶元素。
• int top() 返回栈顶元素。
• boolean empty() 如果栈是空的，返回 true ；否则，返回 false 。

注意：

• 你只能使用队列的标准操作 —— 也就是 push to back、peek/pop from front、size 和 is empty 这些操作。
• 你所使用的语言也许不支持队列。 你可以使用 list （列表）或者 deque（双端队列）来模拟一个队列 , 只要是标准的队列操作即可。

用两个队列que和que_tmp实现队列的功能，que_tmp其实完全就是一个备份的作用，把que最后面的元素以外的元素都备份到que_tmp，然后弹出最后面的元素，再把其他元素从que_tmp导回que。

方法一：两个队列实现

class MyStack:

    def __init__(self):
        self.queue = deque() #使用双向队列，只执行popleft()和append()
        self.queue_tmp = deque() #暂存队列

    def push(self, x: int) -> None:
        self.queue.append(x)

    def pop(self) -> int:
        if self.empty():
            return None

        for i in range(len(self.queue)-1):
            self.queue_tmp.append(self.queue.popleft()) #这里不能使用pop()
            #将除最后一个元素以外的元素全部放入暂存队列
        pop_res =  self.queue.popleft() 
        
        for i in range(len(self.queue_tmp)):
            self.queue.append(self.queue_tmp.popleft()) # 元素放回
        return pop_res

    def top(self) -> int:
        ans = self.pop() #函数复用
        self.queue.append(ans) # 把栈顶元素再放回
        return ans

    def empty(self) -> bool:
        return not(self.queue or self.queue_tmp)

优化：只使用一个队列

一个队列在模拟栈弹出元素的时候只要将队列头部的元素（除了最后一个元素外） 重新添加到队列尾部，此时再去弹出元素就是栈的顺序了。

class MyStack:

    def __init__(self):
        self.queue = deque() #使用双向队列，只执行popleft()和append()

    def push(self, x: int) -> None:
        self.queue.append(x)

    def pop(self) -> int:
        if self.empty():
            return None

        for i in range(len(self.queue)-1):
            self.queue.append(self.queue.popleft()) #这里不能使用pop()
            #将除最后一个元素以外的元素弹出后放回 相当于原地换顺序 将最后一个元素提前
        return self.queue.popleft() 

    def top(self) -> int:
        ans = self.pop() #函数复用
        self.queue.append(ans) # 把栈顶元素再放回
        return ans

    def empty(self) -> bool:
        return not self.queue 

---

---

 

20. 有效的括号

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

有效字符串需满足：

1. 左括号必须用相同类型的右括号闭合。
2. 左括号必须以正确的顺序闭合。
3. 每个右括号都有一个对应的相同类型的左括号。

不匹配可总结为三种情况：

1. 左括号多          
2. 右括号多         
3. 括号不是一对   

算法思想：在遍历左括号的时候，右括号入栈，就只需要比较当前元素和栈顶相不相等。

第一种情况：已经遍历完了字符串，但是栈不为空，说明左括号多。

第二种情况：遍历字符串匹配的过程中，发现栈顶元素和字符不一致。

第三种情况：遍历字符串匹配的过程中，栈已经为空了，说明右括号多。

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

方法一：仅适用栈，更省空间

stack is none并不能判断栈是否为空，空列表不等于none。要使用not stack。

class Solution:
    def isValid(self, s: str) -> bool:
        if len(s) % 2:  # s 长度必须是偶数
            return False
        st = []
        for c in s:
            if c == '(':
                st.append(')')  # 入栈对应的右括号
            elif c == '[':
                st.append(']')
            elif c == '{':
                st.append('}')
            elif not st or st.pop() != c:  # c 是右括号
                return False  # 没有左括号，或者左括号类型不对
        return not st  # 所有左括号必须匹配完毕

方法二：用字典 省if-else判断

class Solution:
    def isValid(self, s: str) -> bool:
        if len(s) % 2:  # s 长度必须是偶数
            return False
        mp = {'(': ')', '[': ']', '{': '}'}
        st = []
        for c in s:
            if c in mp:  # c 是左括号
                st.append(mp[c])  # 入栈对应的右括号
            elif not st or st.pop() != c:  # c 是右括号
                return False  # 没有左括号，或者左括号类型不对
        return not st  # 所有左括号必须匹配完毕

---

---

 

1047. 删除字符串中的所有相邻重复项 

【简单】给出由小写字母组成的字符串 s，重复项删除操作会选择两个相邻且相同的字母，并删除它们。

在 s 上反复执行重复项删除操作，直到无法继续删除。

在完成所有重复项删除操作后返回最终的字符串。答案保证唯一。

方法一：栈

算法思想：匹配问题 类似有效括号来判断是否相邻重复

class Solution:
    def removeDuplicates(self, s: str) -> str:
        stack = [] 
        for char in s:
            if stack and char == stack[-1]: #stack不为空且当前字符和栈顶元素相等
                stack.pop() # 相邻重复 栈顶元素弹出
            else:
                stack.append(char) #不重复 加入栈中
        return ''.join(stack) #栈内元素由列表恢复成字符串