刷题日记(9/10)

232 用栈来实现队列

请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（push、pop、peek、empty）：

实现 MyQueue 类：

void push(int x) 将元素 x 推到队列的末尾
int pop() 从队列的开头移除并返回元素
int peek() 返回队列开头的元素
boolean empty() 如果队列为空，返回 true ；否则，返回 false
说明：

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

class MyQueue(object):
    
    #.append()在list末尾添加
    #.pop()默认弹出list末尾的值
    def __init__(self):
        self.stack_in = []
        self.stack_out = []
    def push(self, x):
        """
        :type x: int
        :rtype: None
        """
        self.stack_in.append(x)


    def pop(self):
        """
        :rtype: int
        """
        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):
        """
        :rtype: int
        """
        first = self.pop()
        self.stack_out.append(first)
        return first

    def empty(self):
        """
        :rtype: bool
        """
        if self.stack_in or self.stack_out:
            return False
        else:
            return True

总结：主要是 pop函数有点麻烦，先将stack_in的元素逐个pop到stack_out中

225 用队列实现栈

class MyStack:

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

    def push(self, x):
        self.que.append(x)

    def pop(self):
        if self.empty():
            return None
        for i in range(len(self.que)-1):
            self.que.append(self.que.popleft())
        return self.que.popleft()

    def top(self):
        if self.empty():
            return None
        for i in range(len(self.que)-1):
            self.que.append(self.que.popleft())
        temp = self.que.popleft()
        self.que.append(temp)
        return temp

    def empty(self):
        return not self.que

总结：python中的双向队列deque(),方法pop()弹出队列末尾的，方法leftpop()弹出队列首位的

20 有效地序号

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

有效字符串需满足：

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

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()
        if not stack:
            return True
        else:
            return False 

总结：运用到栈的知识，挺有意思的还

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

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

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

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

class Solution(object):
    def removeDuplicates(self, s):
        """
        :type s: str
        :rtype: str
        """
        stack = []
        for item in s:

            if len(stack) == 0 or item != stack[-1]:
                stack.append(item)
            elif item == stack[-1]:
                stack.pop()
        
        return "".join(stack) #字符串拼接

总结：“”.join()字符串拼接知识点需要记住