代码随想录算法训练营第十天| 232. 栈实现队列、225. 用队列实现栈、20. 有效的括号、1047. 删除所有相邻重复项

牢记栈是FILO,队列是FIFO就好，python中的list可以当栈，collections中deque双端队列；需要去看一下python中这些数据结构的实现。

有一个可能省时间的点：
stack = []
not stack 比 len(stack)要快? 因为len需要遍历，not只需要判断是不是空就行？

232. 用栈实现队列

leetcode 232. 用栈实现队列
代码随想录

class MyQueue:

    def __init__(self):
        self.stack_in = []
        self.stack_out = []

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

    def pop(self) -> int:
        if self.empty():
            return None
        if len(self.stack_out) == 0:
            while len(self.stack_in) != 0:
                self.stack_out.append(self.stack_in.pop())
        return self.stack_out.pop()

    def peek(self) -> int:
        temp = self.pop()
        self.stack_out.append(temp)
        return temp

    def empty(self) -> bool:
        if len(self.stack_in) == 0 and len(self.stack_out) == 0:
            return True
        return False



# Your MyQueue object will be instantiated and called as such:
# obj = MyQueue()
# obj.push(x)
# param_2 = obj.pop()
# param_3 = obj.peek()
# param_4 = obj.empty()

225. 用队列实现栈

leetcode 225. 用队列实现栈
代码随想录

一个队列做pop就是循环入同一个队列，最后一个元素返回回去。一个队列时候，出栈的时间复杂度为$o(n)$，两个队列好像也是的hhh，所以一个队列可以生空间。

from collections import deque
class MyStack:

    def __init__(self):
        self.qeue = deque()

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

    def pop(self) -> int:
        if self.empty():
            return None
        qeue_len = len(self.qeue)
        for i in range(qeue_len - 1):
            self.qeue.append(self.qeue.popleft())
        return self.qeue.popleft()

    def top(self) -> int:
        if self.empty():
            return None
        qeue_len = len(self.qeue)
        for i in range(qeue_len - 1):
            self.qeue.append(self.qeue.popleft())
        ans = self.qeue.popleft()
        self.qeue.append(ans)
        return ans

    def empty(self) -> bool:
        if len(self.qeue) == 0:
            return True
        return False


# Your MyStack object will be instantiated and called as such:
# obj = MyStack()
# obj.push(x)
# param_2 = obj.pop()
# param_3 = obj.top()
# param_4 = obj.empty()

20. 有效的括号

leetcode 20. 有效的括号
代码随想录

遇到左括号入栈一个右括号，这样遇到右括号就直接进行匹配

class Solution:
    def isValid(self, s: str) -> bool:
        stack = []
        for char in s:
            if char == "(":
                stack.append(")")
            elif char == "[":
                stack.append("]")
            elif char == "{":
                stack.append("}")
            else:
                if not stack or char != stack.pop():
                    return False
        if not stack:
            return True
        else:
            return False

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

leetcode 1047. 删除字符串中的所有相邻重复项
代码随想录

和括号匹配同样的消消乐

class Solution:
    def removeDuplicates(self, s: str) -> str:
        stack = []
        # stack.append(s[0:1])
        # print(stack)
        for char in s:
            if not stack or stack[-1] != char:
                stack.append(char)
            elif stack[-1] == char:
                stack.pop()
        s = ''.join(stack)
        return s