代码随想录python---队列和栈

目录

目录

用栈实现对队列

用队列实现栈

20. 有效的括号

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

150. 逆波兰表达式求值

---

 

---

python中队列用三种实现方式
双端队列deque()
队列queue()
列表

 1.用栈实现队列

class MyQueue:

    def __init__(self):
        self.stack1 = []
        self.stack2 = []

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

    def pop(self) -> int:
        if not self.stack2:
            while self.stack1:
                self.stack2.append(self.stack1.pop())
        return self.stack2.pop()

    def peek(self) -> int:
        if not self.stack2:
            while self.stack1:
                self.stack2.append(self.stack1.pop())
        return self.stack2[-1]

    def empty(self) -> bool:
        return not self.stack1 and not self.stack2



# 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()

2.用队列实现栈

class MyStack:
# 这里使用一个双端队列进行操作的
    # def __init__(self):
    #     self.queue = deque()

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

    # def pop(self) -> int:
    #     # 这里的pop()不能使用
    #     n = len(self.queue)
    #     if n <= 1:
    #         return self.queue.popleft()
    #     else:
    #         for i in range(n - 1):
    #             self.queue.append(self.queue.popleft())
    #         return self.queue.popleft()

    # def top(self) -> int:
    #     return self.queue[-1]
    # def empty(self) -> bool:
    #     return not self.queue

# 这里使用两个队列进行操作,一个队列做队列内容的存储，一个队列做队列内容的转换
    def __init__(self):
        self.queue1 = deque()
        self.queue2 = deque()
    def push(self, x:int) -> None:
        self.queue2.append(x)
        while self.queue1:
            self.queue2.append(self.queue1.popleft())
        self.queue1, self.queue2 = self.queue2, self.queue1
    def pop(self) -> int:
        return self.queue1.popleft()
    def top(self) -> int:
        return self.queue1[0]
    def empty(self) -> bool:
        return not self.queue1




# 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()

50.有效的括号：

class Solution:
    def isValid(self, s: str) -> bool:
        # stack = []
        # lists = list(s)
        # for i in range(len(lists)):
        #     if lists[i] == '(':
        #         stack.append(')')
        #     elif lists[i] == '[':
        #         stack.append(']')
        #     elif lists[i] == '{':
        #         stack.append('}')
        #     # elif lists[i] == ')':
        #     #     if stack[-1] == ')':
        #     #         stack.pop()
        #     #     else:
        #     #         return False
        #     # elif lists[i] == ']':
        #     #     if stack[-1] == ']':
        #     #         stack.pop()
        #     #     else:
        #     #         return False
        #     # elif lists[i] == '}':
        #     #     if stack[-1] == '}':
        #     #         stack.pop()
        #     #     else:
        #     #         return False
        #     # 上面注释这些可以写成下面这种
        #     elif not stack or stack[-1] != lists[i]:
        #         return False
        #     # elif stack[-1] == lists[i]:
        #     else:
        #         stack.pop()
        # if not stack:
        #     return True
        # else:
        #     return False

        # 方法二：使用字典 占用空间，但是代码写得简单些
        maps = {'(':')','[':']','{':'}'}
        stack = []
        lists = list(s)
        for i in lists:
            if i in maps.keys():
                stack.append(maps[i])
            elif not stack or stack[-1] != i:
                return False
            else:
                stack.pop()
        return False if stack else True

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

class Solution:
    def removeDuplicates(self, s: str) -> str:
        stack = []
        lists = list(s)
        result = ''
        for i in lists:
            # if i == stack[-1]:
            #     stack.pop()
            # else:
            #     stack.append(i)
            if not stack or i != stack[-1]:
                stack.append(i)
            else:
                stack.pop()

        # for j in range(len(stack)):
        #     result += stack[j]
        # return result

        # return stack[j] += stack[j] for j in range(len(stack))
        # return [str(stack[j]) for j in range(len(stack))][0]
        # 字符串拼接
        return ''.join(stack)

150. 逆波兰表达式求值

class Solution:
    def evalRPN(self, tokens: List[str]) -> int:
        stack = []
        for i in tokens:
            # IndexError: list index out of range:报错原因if i == '+' or '-' or '*' or '/':中
            # “i == '+' or '-' or '*' or '/'”为True；；所以这是if后面的判断条件错了
            if i == '+' or i == '-' or i == '*' or i == '/':
                q, w = stack.pop(), stack.pop() 
                # q = stack[-1]
                # stack.pop()
                # w = stack[-1]
                # stack.pop()
                if i == '+':
                    stack.append(w+q)
                elif i == '-':
                    stack.append(w-q)
                elif i == '*':
                    stack.append(w*q)
                elif i == '/':
                    # 注意除数和被除数的前后顺序
                    # 13/5=2.6,就是整数与整数之间的除法运算，运算结果是浮点型
                    stack.append(int(w/q))
            else:
                stack.append(int(i))
        result = stack[0]
        stack.pop()
        return result