代码随想录Day10 Day11

232.用栈实现队列

用两个栈实现队列，一个输入栈一个输出栈

class MyQueue(object):
    def __init__(self):
        self.stuck_in=[]
        self.stuck_out=[]
    def push(self, x):
        """
        :type x: int
        :rtype: None
        """
        self.stuck_in.append(x)

    def pop(self):
        """
        :rtype: int
        """
        if self.empty():
            return None
        if self.stuck_out:
            return self.stuck_out.pop()
        else:
            for i in range(len(self.stuck_in)):
                self.stuck_out.append(self.stuck_in.pop())
            return self.stuck_out.pop()
    def peek(self):
        """
        :rtype: int
        """
        ans=self.pop()
        self.stuck_out.append(ans)
        return ans
    def empty(self):
        """
        :rtype: bool
        """
        return not (self.stuck_in or self.stuck_out)

225. 用队列实现栈

方法一

使用两个双向队列实现栈，双向队列deque()

class MyStack(object):

    def __init__(self):
        self.queue_in=deque()
        self.queue_out=deque()
    def push(self, x):
        """
        :type x: int
        :rtype: None
        """
        self.queue_in.append(x)
    def pop(self):
        """
        :rtype: int
        """
        if self.empty():
            return None
        for i in range(len(self.queue_in)-1):
            self.queue_out.append(self.queue_in.popleft())
        self.queue_in,self.queue_out=self.queue_out,self.queue_in
        return self.queue_out.popleft()
    def top(self):
        """
        :rtype: int
        """
        if self.empty():
            return None
        for i in range(len(self.queue_in)-1):
            self.queue_out.append(self.queue_in.popleft())
        self.queue_in,self.queue_out=self.queue_out,self.queue_in
        temp=self.queue_out.popleft()
        self.queue_in.append(temp)
        return temp
    def empty(self):
        """
        :rtype: bool
        """
        return len(self.queue_in)==0

方法二

使用一个双向队列完成

class MyStack(object):

    def __init__(self):
        self.queue=deque()
      
    def push(self, x):
        """
        :type x: int
        :rtype: None
        """
        self.queue.append(x)
    def pop(self):
        """
        :rtype: int
        """
        if self.empty():
            return None
        for i in range(len(self.queue)-1):
            self.queue.append(self.queue.popleft())
      
        return self.queue.popleft()
    def top(self):
        """
        :rtype: int
        """
        if self.empty():
            return None
        for i in range(len(self.queue)-1):
            self.queue.append(self.queue.popleft())
        temp=self.queue.popleft()
        self.queue.append(temp)
        return temp
    def empty(self):
        """
        :rtype: bool
        """
        return len(self.queue)==0

#20. 有效的括号

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

方法一

使用栈完成

class Solution(object):
    def isValid(self, s):
        """
        :type s: str
        :rtype: 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

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

给出由小写字母组成的字符串 S，重复项删除操作会选择两个相邻且相同的字母，并删除它们。
在 S 上反复执行重复项删除操作，直到无法继续删除。
在完成所有重复项删除操作后返回最终的字符串。答案保证唯一

方法一

使用栈完成

class Solution(object):
    def removeDuplicates(self, s):
        """
        :type s: str
        :rtype: str
        """
        stack=[]
        for item in s:
            if stack and stack[-1]==item:
                stack.pop()
            else:
                stack.append(item)
        return "".join(stack)

方法二

使用双指针法完成

class Solution(object):
    def removeDuplicates(self, s):
        """
        :type s: str
        :rtype: str
        """
        res=list(s)
        n=len(s)
        slow=fast=0
        while fast<n:
            res[slow]=res[fast]
            if res[slow]==res[slow-1] and slow>0:
                slow-=1
            else:
                slow+=1
            fast+=1
        return "".join(res[0:slow])

150. 逆波兰表达式求值

方法一

class Solution:
    def evalRPN(self, tokens):       
        stack = []
        for item in tokens:
            if item not in {"+", "-", "*", "/"}:
                stack.append(item)
            else:
                first_num, second_num = stack.pop(), stack.pop()
                stack.append(
                    int(eval(f'{second_num} {item} {first_num}'))   # 第一个出来的在运算符后面
                )
        return int(stack.pop()) # 如果一开始只有一个数，那么会是字符串形式的