day10 栈与队列理论基础 232.用栈实现队列 225.用队列实现栈 20.有效的括号 1047.删除字符串中的所有相邻重复项

232.用栈实现队列

使用栈实现队列的下列操作：

push(x) -- 将一个元素放入队列的尾部。
pop() -- 从队列首部移除元素。
peek() -- 返回队列首部的元素。
empty() -- 返回队列是否为空。

示例:

MyQueue queue = new MyQueue();
queue.push(1);
queue.push(2);
queue.peek();  // 返回 1
queue.pop();   // 返回 1
queue.empty(); // 返回 false

说明:

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

 第一种方法：

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
        
        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) -> int:
        ans = self.pop()
        self.stack_out.append(ans)
        return ans

225.用队列实现栈

使用队列实现栈的下列操作：

• push(x) -- 元素 x 入栈
• pop() -- 移除栈顶元素
• top() -- 获取栈顶元素
• empty() -- 返回栈是否为空

注意:

• 你只能使用队列的基本操作-- 也就是 push to back, peek/pop from front, size, 和 is empty 这些操作是合法的。
• 你所使用的语言也许不支持队列。 你可以使用 list 或者 deque（双端队列）来模拟一个队列 , 只要是标准的队列操作即可。
• 你可以假设所有操作都是有效的（例如, 对一个空的栈不会调用 pop 或者 top 操作）。

第一种方法（用两个双向队列实现栈）： 

from collections import deque

class MyStack:

    def __init__(self):
        """
        python普通的Queue或Simple Queue没有类似peek的功能
        也无法用索引访问，在实现top的时候较为困难。

        用list可以，但是在使用pop(0)的时候时间复杂度为O(n)
        因此这里使用双向队列，保证只执行popleft()和append()
        因为deque可以用索引访问，可以实现和peek类似的功能
        """
        self.queue_in = deque()
        self.queue_out = deque()


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


    def pop(self) -> int:
        """
        1.首先确认不空
        2.因为队列的特殊性，FIFO，所以我们只有在pop()的时候才会使用queue_out
        3.先把queue_in的中的所有元素（除了最后一个），依次出列放进queue_out
        4.交换in和out
        5.把out的pop出来，即是原队列的最后一个
        """
        if self.empty():
            return
        
        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) -> int:
        #if self.empty():
        #    return

        #return self.queue_in[-1]   #实际用到了栈，因为直接获取了queue_in的末尾元素

        if self.empty():
            return
        
        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) -> 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()

 第二种方法（使用一个队列实现栈）：

class MyStack:

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


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


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


    def top(self) -> int:
        if self.empty():
            return

        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) -> bool:
        return not self.que


# 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.有效的括号

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

有效字符串需满足：

• 左括号必须用相同类型的右括号闭合。
• 左括号必须以正确的顺序闭合。
• 注意空字符串可被认为是有效字符串。

示例 1:

• 输入: "()"
• 输出: true

示例 2:

• 输入: "()[]{}"
• 输出: true

示例 3:

• 输入: "(]"
• 输出: false

示例 4:

• 输入: "([)]"
• 输出: false

示例 5: 

• 输入: "{[]}"
• 输出: true

第一种方法（仅使用栈）：

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

第二种方法（结合字典）：

class Solution:
    def isValid(self, s: str) -> bool:
        stack = []
        mapping = {
            '(': ')',
            '[': ']',
            '{': '}',
        }

        for item in s:
            if item in mapping:
                stack.append(mapping[item]) 
            elif not stack or stack[-1] != item:
                return False
            else:
                stack.pop()
        
        return True if not stack else False

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

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

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

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

示例：

• 输入："abbaca"
• 输出："ca"
• 解释：例如，在 "abbaca" 中，我们可以删除 "bb" 由于两字母相邻且相同，这是此时唯一可以执行删除操作的重复项。之后我们得到字符串 "aaca"，其中又只有 "aa" 可以执行重复项删除操作，所以最后的字符串为 "ca"。

提示：

• 1 <= S.length <= 20000
• S 仅由小写英文字母组成。

第一种方法（使用栈）：

class Solution:
    def removeDuplicates(self, s: str) -> str:
        res = list()
        for item in s:
            if res and res[-1] == item:
                res.pop()
            else:
                res.append(item)

        return "".join(res)

 第二种方法（双指针法）：

class Solution:
    def removeDuplicates(self, s: str) -> str:
        res = list(s)
        slow = fast = 0
        length = len(res)

        while fast < length:
            
            res[slow] = res[fast]

            if slow > 0 and res[slow] == res[slow - 1]:
                slow -= 1
            else:
                slow += 1
            fast += 1

        return "".join(res[0:slow])