代码随想录跟练第九天——LeetCode 232.用栈实现队列、225. 用队列实现栈、20. 有效的括号、1047. 删除字符串中的所有相邻重复项

拔了智齿后，好久没有总结了，先补一点 

---

232.用栈实现队列

力扣题目链接(opens new window)

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

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

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 None
        if self.stack_out:
            return self.stack_out.pop()
        else:
            for i in range(len(self.stack_in)):
                x = self.stack_in.pop()
                self.stack_out.append(x)
            return self.stack_out.pop()

    def peek(self) -> int:
        x = self.pop()
        self.stack_out.append(x)
        return x

    def empty(self) -> bool:
        if  len(self.stack_in) == 0 and len(self.stack_out) == 0:
            return false

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

思路：

用栈实现队列，需要两个栈，因为队列先入可以先出，但是栈只能先入后出。

push的时候，直接push到stack_in，定义两个栈都是列表的形式，直接用append

pop的时候，从stack_out来pop，这样可以直接pop出队列的值。

peek的 返回队列首部的元素，从pop中取出元素后，需要把这个元素重新append到out栈

225. 用队列实现栈

力扣题目链接(opens new window)

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

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

class MyStack:

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

    def push(self, x: int) -> None:
        self.que.append(x)  # 需要将实际x传入

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

    def empty(self) -> bool:
        return not self.que  # 如果que为空则返回not que 为True，符合题目要求

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

思路： 

• self.que = deque() 创建了一个双端队列 deque，并将其赋值给 self.que。这个 deque 将用来存储栈中的元素。 
• pop：
• 首先检查 self.que 是否为空。如果是 None，则返回 None。
• 如果队列不为空，则进行一个循环，将队列的前 n-1 个元素从队列头部取出并重新加入队列的尾部。这一步操作是为了将最后加入队列的元素（即栈顶元素）移到队列的头部。
• 循环结束后，self.que.popleft() 取出并返回队列头部的元素，这个元素就是栈顶元素。
• empty：
• return not self.que 返回 True 如果队列为空，否则返回 False。这个操作检查 deque 是否为空，符合题目要求的栈为空返回 True。

20. 有效的括号

力扣题目链接(opens new window)

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

有效字符串需满足：

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

示例 1:

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

示例 2:

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

示例 3:

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

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

思路：

当s[i]为左括号的时候，把右括号加入st[]数组，如果st为空或者 st[-1] != s[i]时，返回False。

三种不匹配的情况：

1. 第一种情况，字符串里左方向的括号多余了 ，所以不匹配。 

   

2. 第二种情况，括号没有多余，但是 括号的类型没有匹配上。 

   

3. 第三种情况，字符串里右方向的括号多余了，所以不匹配。 

   

第一种情况：已经遍历完了字符串，但是栈不为空，说明有相应的左括号没有右括号来匹配，所以return false

第二种情况：遍历字符串匹配的过程中，发现栈里没有要匹配的字符。所以return false

第三种情况：遍历字符串匹配的过程中，栈已经为空了，没有匹配的字符了，说明右括号没有找到对应的左括号return false 

扩展： 

栈的应用，比如linux系统下的路径cd这个进入目录的命令；写代码的过程中，要求括号的顺序是一样的，有左括号，相应的位置必须要有右括号；编译器在词法分析的过程中处理括号、花括号等这个符号的逻辑，也是使用了栈这种数据结构。

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

力扣题目链接(opens new window)

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

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

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

示例：

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

提示：

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

双指针：

class Solution:
    def removeDuplicates(self, s: str) -> str:
        st = list(s)
        slow = fast = 0
        for i in range(len(st)):
            st[slow] = st[fast]
            if slow > 0 and st[slow] == st[slow-1] :
                slow -= 1
            else:
                slow += 1
            fast += 1
        return "".join(st[0:slow])

栈： 

class Solution:
    def removeDuplicates(self, s: str) -> str:
        st = []
        for i in s:
            if st and st[-1] == i:
                st.pop()
            else:
                st.append(i)
        return "".join(st)

如果st存在，并且st[-1]等于要加入的这个元素就把这个元素pop出来