跟随carl代码随想录刷题
语言：python

---

栈与队列

• 队列：先进先出（first in first out, FIFO）
• 栈：先进后出（fist in last out, FILO）
  • 匹配问题都是栈的强项：括号匹配、去重、消消乐

不允许存在遍历

🙋栈里面的元素在内存中是连续分布的吗？
💁栈是容器适配器。底层所使用的容器决定栈内数据是否会连续分布。缺省情况下，默认底层容器是deque。deque在内存中的数据分布是不连续的。

232. 简单用栈实现队列

题目：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（双端队列）来模拟一个栈，只要是标准的栈操作即可。

题目分析

考察对栈和队列的掌握程度
需要使用两个栈：一个输入栈，一个输出栈
在push数据的时候，将数据放进输入栈即可
在pop数据的时候：
如果输入栈为空，就把输入栈的数据全部导入进来，再从输出栈弹出数据
如果输入栈不为空，就直接从输出栈弹出数据

如果输入栈和输出栈都为空，则队列为空。

代码一定要懂得复用，不要大量复制粘贴。

完整代码如下

class MyQueue:

    def __init__(self):
        """
        in主要负责push，将数据推入输入栈
        out主要负责pop，将数据从输出栈移出
        """
        self.stack_in = []
        self.stack_out = []

    def push(self, x: int) -> None:
        """
        有新元素进来，就往“输入栈”push
        """
        self.stack_in.append(x)

    def pop(self) -> int:
        """
        从输出栈移出（pop）元素
        如果队列是空，直接返回None
        如果输出栈不为空，则从输出栈移除（pop）元素

        如果输出栈是空，则将输入栈数据全部压进输出栈，同时将元素从输入栈移除
        
        """
        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) -> int:
        """
        拿到队列的第一个元素
        """
        ans = self.pop()
        self.stack_out.append(ans)
        return ans

    def empty(self) -> bool:
        """
        只要输入栈和输出栈有元素，说明队列不为空

		只要`self.stack_in`或`self.stack_out`不为空，
		那么`return not (self.stack_in or self.stack_out)`为0

		如果`self.stack_in`和`self.stack_out`都为空，则return 1
		
		从上方`pop`函数的调用逻辑可以看出，当empty函数的return值为1时，队列为空。
        """
        return not (self.stack_in or self.stack_out)


# 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()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

225. 简单用队列实现栈

题目：请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。

👉实现 MyStack 类：
void push(int x) 将元素 x 压入栈顶。
int pop() 移除并返回栈顶元素。
int top() 返回栈顶元素。
boolean empty() 如果栈是空的，返回 true ；否则，返回 false 。
👉注意：
你只能使用队列的基本操作 —— 也就是 push to back、peek/pop from front、size 和 is empty 这些操作。
你所使用的语言也许不支持队列。 你可以使用 list （列表）或者 deque（双端队列）来模拟一个队列 , 只要是标准的队列操作即可。

题目分析

用两个队列实现栈的功能的思路：

• 队列2完全是用来备份的。把除队尾元素以外的元素备份到队列2，然后弹出队列1的队尾元素，然后再把其他元素从队列2移回队列1

用一个队列实现栈的思路：

• 在模拟栈弹出元素时，只要把队列中除尾部元素以外的元素重新添加到队尾，此时原来的尾部元素变成了头部元素，即可实现弹出原尾部元素的操作。

完整代码如下

两个队列实现

class MyStack:

    def __init__(self):
        """
        `queue_in`用于存所有数据
        `queue_out`仅在pop的时候会遇到
        这里使用双向队列，在移除元素时使用`popleft`即可，添加元素时使用`append`
        """
        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. 交换`queue_in`和`queue_out`，此时`queue_out`只有一个元素
        5. 把`queue_out`的元素pop()取出来

        """
        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) -> int:
        """
        1. 首先确认不空
        2. 返回队列最后一个元素
        """
        if self.empty():
            return None
        
        return self.queue_in[-1]

    def empty(self) -> bool:
        """
        因为只有`queue_in`存有数据，因此只用判断`queue_in`
        """
        return not(self.queue_in)
        # 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()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

一个队列实现

逻辑和两个队列实现是一样的，只是把第二个队列实现的备份功能直接在队列1上实现了

class MyStack:

    def __init__(self):
        """
        这里使用双向队列，在移除元素时使用`popleft`即可，添加元素时使用`append`
        """
        self.queue = deque()
        
    def push(self, x: int) -> None:
        """
        将元素压入栈内
        """
        self.queue.append(x)

    def pop(self) -> int:
        """
        1. 首先确认不为空
        2. 先把`queue`中除最后一个元素外，其余元素依次放入`queue`的末尾 
        3. 把`queue`的元素pop()取出来

        """
        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) -> int:
        """
        1. 首先确认不空
        2. 返回队列最后一个元素
        """
        if self.empty():
            return None
        
        return self.queue[-1]

    def empty(self) -> bool:
        """
        因为只有`queue`存有数据，因此只用判断`queue`
        """
        return not(self.queue)
        # return len(self.queue)==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()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

栈在系统中的应用

71. 中等简化路径

题目：给你一个字符串 path ，表示指向某一文件或目录的 Unix 风格 绝对路径 （以 ‘/’ 开头），请你将其转化为更加简洁的规范路径。
.
在 Unix 风格的文件系统中，一个点（.）表示当前目录本身；此外，两个点 （…） 表示将目录切换到上一级（指向父目录）；两者都可以是复杂相对路径的组成部分。任意多个连续的斜杠（即，‘//’）都被视为单个斜杠 ‘/’ 。 对于此问题，任何其他格式的点（例如，‘…’）均被视为文件/目录名称。
.
请注意，返回的 规范路径 必须遵循下述格式：
始终以斜杠 '/' 开头。
两个目录名之间必须只有一个斜杠 '/' 。
最后一个目录名（如果存在）不能 以 '/' 结尾。
此外，路径仅包含从根目录到目标文件或目录的路径上的目录（即，不含 '.' 或 '..'）。
返回简化后得到的 规范路径 。

👉示例 1：
输入：path = “/home/”
输出：“/home”
解释：注意，最后一个目录名后面没有斜杠。
👉示例 2：
输入：path = “/…/”
输出：“/”
解释：从根目录向上一级是不可行的，因为根目录是你可以到达的最高级。
👉示例 3：
输入：path = “/home//foo/”
输出：“/home/foo”
解释：在规范路径中，多个连续斜杠需要用一个斜杠替换。
👉示例 4：
输入：path = “/a/./b/…/…/c/”
输出：“/c”

完整代码如下

class Solution:
    def simplifyPath(self, path: str) -> str:
        """
        1. 用`/`分割字符串
        `//`分割后会变为''空字符串
        `/home//foo/`分割后会变为"home"、 ""、 "fool"
        2. 如果name==`..`，并且栈stack中存有内容，则弹出栈顶元素（弹出上级目录）
        3. 如果分割后的内容不是""空字符串、不是"."，则将其压入栈中
        4. 在开头加入`/`，栈中元素用`/`分隔，返回。
        
        """

        names = path.split("/")
        stack = list()

        for name in names:
            if name == "..":
                if stack:
                    stack.pop()
            elif name and name != ".":
                stack.append(name)
        return "/" + "/".join(stack)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22