Day10 栈和队列

232. 用栈实现队列

解法：注意peak()方法，复用了pop()方法，这样就避免了再写一次pop()方法里面的一大堆判空的逻辑。

class MyQueue(object):

    def __init__(self):
        # in负责push out负责pop
        self.stack_in = []
        self.stack_out = []


    def push(self, x):
        """
        :type x: int
        :rtype: None
        """
        # 向stack_in里面push
        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
        """
        # 获取队列开头元素 但通过pop()方法将其移除了
        ans = self.pop()
        # 所以得加进去
        self.stack_out.append(ans)
        return ans


    def empty(self):
        """
        :rtype: bool
        """
        return not (self.stack_out or self.stack_in)


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

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

解法：遍历字符串，若当前元素与栈内最后一个相同，则栈内最后一个元素出栈，否则当前元素入栈。

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

20. 有效的括号

解法：匹配失败的三种情况：1.左括号多余；2.右括号多余；3.左右都不多余，只是类型不匹配。那么对应到代码实现便是：1.遍历完字符串最终栈不为空，对应左括号多余；2.遍历的过程中栈空了，说明右括号多余了；3.遍历的过程中，栈里没有要匹配的元素，说明类型不匹配。

class Solution(object):
    def isValid(self, s):
        """
        :type s: str
        :rtype: bool
        """
        if len(s) % 2 != 0:
            return False
        stack = []
        for i in s:
            if i == '[':
                stack.append(']')
            elif i == '(':
                stack.append(')')
            elif i == '{':
                stack.append('}')
            elif not stack or stack[-1] != i:
                return False
            else:
                stack.pop()
        return not stack 

225. 用队列实现栈

解法： Python普通的Queue或SimpleQueue没有类似于peak的功能也无法用索引访问，在实现top的时候较为困难。 用list可以，但是在使用pop(0)的时候时间复杂度为O(n) 因此这里使用双向队列，我们保证只执行popleft()和append()，因为deque可以用索引访问，可以实现和peak相似的功能。

from collections import deque
class MyStack(object):

    def __init__(self):
    # in存放数据 out仅仅在pop时用到
        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):
        	# 将in内最后一个元素之前的元素添加到out中
            self.queue_out.append(self.queue_in.popleft())
        # 此时in只有一个元素，交换in和out
        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
        return self.queue_in[-1]


    def empty(self):
        """
        :rtype: bool
        """
        return len(self.queue_in) == 0



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