【LeetCode学习计划】《数据结构入门-C++》第9天 栈 / 队列

LeetCode【学习计划】：【数据结构】

---

---

20. 有效的括号

LeetCode: 20. 有效的括号

$简单$

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

1. 左括号必须用相同类型的右括号闭合。
2. 左括号必须以正确的顺序闭合。

示例 1：

输入：s = "()"
输出：true

示例 2：

输入：s = "()[]{}"
输出：true

示例 3：

输入：s = "(]"
输出：false

示例 4：

输入：s = "([)]"
输出：false

示例 5：

输入：s = "{[]}"
输出：true

提示：

• 1 <= s.length <= 10⁴
• s 仅由括号 '()[]{}' 组成

---

方法1：栈

我们可以先跳过对于左括号的思考。假设我们能够记录所有的左括号，那么我们每次遇到右括号时的操作就是取出最后一个记录的左括号，然后判断是否能匹配。所以这是一个先入后出的情景，也正是栈的特点。

• 当遇到右括号时，取出栈顶，如果匹配则继续，不匹配则直接返回假值。
• 当然，取栈顶的时候有可能栈为空，此时代表不匹配，返回假值。
• 如果遍历结束后栈不为空，说明左括号冗余，也返回假值。

同时，有效的括号必然成对出现，这也意味着正确的字符串起码也得是偶数长度，因此奇数长度的字符串就不用操作了，直接返回假值。

#include <string>
#include <stack>
using namespace std;
class Solution
{
public:
    bool isValid(string s)
    {
        if (s.length() % 2 == 1)
            return false;

        stack<char> stk;
        for (const auto &c : s)
        {
            switch (c)
            {
            case '(':
            case '[':
            case '{':
                stk.push(c);
                break;

            case ')':
            {
                if (stk.empty() || stk.top() != '(')
                    return false;
                stk.pop();
                break;
            }
            case ']':
            {
                if (stk.empty() || stk.top() != '[')
                    return false;
                stk.pop();
                break;
            }
            case '}':
            {
                if (stk.empty() || stk.top() != '{')
                    return false;
                stk.pop();
                break;
            }
            }
        }
        return stk.empty();
    }
};

复杂度分析

• 时间复杂度：$O(n)$

• 空间复杂度：$O(n)$。主要为栈的开销。

参考结果

Accepted
91/91 cases passed (0 ms)
Your runtime beats 100 % of cpp submissions
Your memory usage beats 27.03 % of cpp submissions (6.3 MB)

---

---

232. 用栈实现队列

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

进阶：
你能否实现每个操作均摊时间复杂度为 O(1) 的队列？换句话说，执行 n 个操作的总时间复杂度为 O(n) ，即使其中一个操作可能花费较长时间。

示例：

输入：
["MyQueue", "push", "push", "peek", "pop", "empty"]
[[], [1], [2], [], [], []]
输出：
[null, null, null, 1, 1, false]

解释：
MyQueue myQueue = new MyQueue();
myQueue.push(1); // queue is: [1]
myQueue.push(2); // queue is: [1, 2] (leftmost is front of the queue)
myQueue.peek(); // return 1
myQueue.pop(); // return 1, queue is [2]
myQueue.empty(); // return false

提示：

• 1 <= x <= 9
• 最多调用 100 次 push、pop、peek 和 empty
• 假设所有操作都是有效的 （例如，一个空的队列不会调用 pop 或者 peek 操作）

---

前言

队列是一种先进先出（First In First Out, FIFO）的数据结构，元素从队尾入队，从队首出队。大家最熟悉的可能就是各种输入输出流，比如标准输入输出流std:cin和std::cout就是典型的FIFO。

栈是一种后进先出（Last In First Out, LIFO）的数据结构，元素从栈顶压入，也从栈顶弹出。

为了满足队列FIFO的特性，我们需要用到2个栈。

---

方法1：（使用两个栈 入队 - O(n)， 出队 - O(1)）

入队（push）

对于栈来说，为了满足队列先进先出的操作，我们要把新元素压入栈底，然后弹出时从栈顶弹出。

1. 也就是说压入元素时，我们需要把当前栈内所有的元素依次弹出压入另一个栈中；
2. 然后才能压入新元素，这样新元素就会变成最后出队；
3. 最后再将所有元素压回来。

void push(int x)
{ // O(n),O(n)
    stack<int> dummy;
    while (!stk.empty())
    {
        dummy.push(stk.top());
        stk.pop();
    }
    stk.push(x);
    while (!dummy.empty())
    {
        stk.push(dummy.top());
        dummy.pop();
    }
}

复杂度分析

• 时间复杂度：$O(n)$。每一次push操作时队列的长度为n，每次原来的元素一共会被压入2次，弹出2次；新元素只会被压入一次。整个push过程中一共产生了4n+1次操作，而每次操作（压入和弹出）的时间复杂度为O(1)，因此总时间复杂度为$O(n)$。

• 空间复杂度：$O(n)$。需要额外的一个栈来暂存元素。

弹出（pop）

直接将栈顶元素弹出即可。

int pop()
{
    int x = stk.top();
    stk.pop();
    return x;
}

复杂度分析

• 时间复杂度：$O(1)$

• 空间复杂度：$O(1)$

取队首元素（peek）

返回栈顶元素即可。

int peek()
{
    return stk.top();
}

复杂度分析

• 时间复杂度：$O(1)$

• 空间复杂度：$O(1)$

判断空（empty）

栈空即代表队列空，判断栈是否为空即可。

bool empty()
{
    return stk.empty();
}

复杂度分析

• 时间复杂度：$O(1)$

• 空间复杂度：$O(1)$

---

参考结果

Accepted
21/21 cases passed (0 ms)
Your runtime beats 100 % of cpp submissions
Your memory usage beats 7.65 % of cpp submissions (6.9 MB)

---

方法2：（使用两个栈 入队 - O(1)，出队 - 摊还复杂度 O(1)）

入队（push）

正常地压入栈stk1中。

void push(int x)
{
    stk1.push(x);
}

复杂度分析

• 时间复杂度：$O(1)$

• 空间复杂度：$O(1)$

弹出（pop）

我们可以用stk1和stk2来分段存储队列中所有的元素。

1. stk2从最初开始一直为空。
2. 一旦出现了pop操作，将此时stk1中的所有元素依次弹出并压入自身。由于stk1是正常的压入流程，因此stk1的栈底，即此时stk2的栈顶，就是队首。正常弹出即可。
3. 以上的操作可以支撑多次pop操作，一旦某一次pop时stk2为空，就重复第2步将stk1的所有元素压入自身。

int pop()
{
    if (stk2.empty())
    {
        while (!stk1.empty())
        {
            stk2.push(stk1.top());
            stk1.pop();
        }
    }
    int x = stk2.top();
    stk2.pop();
    return x;
}

复杂度分析

• 时间复杂度：摊还复杂度$O(1)$，最坏情况下的时间复杂度为$O(n)$。最坏情况下，stk1中存放了整个空间内所有的元素，共n个，需要将所有的元素从stk1中弹出并压入stk2，一共要进行2n次操作。

• 空间复杂度：$O(1)$

摊还分析

摊还分析给出了所有操作的平均性能。摊还分析的核心在于，最坏情况下的操作一旦发生了一次，那么在未来很长一段时间都不会再次发生，这样就会均摊每次操作的代价。

来看下面这个例子，从一个空队列开始，依次执行下面这些操作：

$$pus{h}_1,pus{h}_2,\dots ,pus{h}_n,po{p}_1,po{p}_2\dots ,po{p}_n$$

单次 出队 操作最坏情况下的时间复杂度为 $O(n)$。考虑到我们要做 n 次出队操作，如果我们用最坏情况下的时间复杂度来计算的话，那么所有操作的时间复杂度为 $O(n^2)$。

然而，在一系列的操作中，最坏情况不可能每次都发生，可能一些操作代价很小，另一些代价很高。因此，如果用传统的最坏情况分析，那么给出的时间复杂度是远远大于实际的复杂度的。例如，在一个动态数组里面只有一些插入操作需要花费线性的时间，而其余的一些插入操作只需花费常量的时间。

在上面的例子中，出队 操作最多可以执行的次数跟它之前执行过 入队 操作的次数有关。虽然一次 出队 操作代价可能很大，但是每 n 次 入队 才能产生这么一次代价为 n 的 出队 操作。因此所有操作的总时间复杂度为：n(所有的入队操作产生） + 2 * n(第一次出队操作产生） + n - 1(剩下的出队操作产生）， 所以实际时间复杂度为 $O(2n)$。于是我们可以得到每次操作的平均时间复杂度为 $O(2n/2n)=O(1)$。

以上的摊还分析来自于：

作者：LeetCode
链接：https://leetcode-cn.com/problems/implement-queue-using-stacks/solution/yong-zhan-shi-xian-dui-lie-by-leetcode/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

取队首元素（peek）

从弹出操作可以知道，在某一时刻，队首元素有可能在stk1的栈底，也有可能在stk2的栈顶，因此不太容易去定位。因此我们需要一个变量front去记录栈顶元素。

但是，假设当前front指向stk2的栈底，当stk2弹出至空后，front 就要指向stk1的栈底，这样明显不行。所以我们只让front始终指向stk1栈底，不定位到stk2；而stk2的栈顶就是队首，因此取stk2.top()即可。

该变量的变化会在入队操作发生，我们修改上文中的代码：

void push(int x)
{
    if (stk1.empty())
        front = x;
    stk1.push(x);
}

int peek()
{
    return !stk2.empty() ? stk2.top() : front;
}

复杂度分析

• 时间复杂度：$O(1)$

• 空间复杂度：$O(1)$

判断空（empty）

由于队列元素由 stk1 和 stk2 2个栈分别存储，所以队列为空的条件是这两个栈都为空。

bool empty()
{
    return stk1.empty() && stk2.empty();
}

复杂度分析

• 时间复杂度：$O(1)$

• 空间复杂度：$O(1)$

---

参考结果

Accepted
21/21 cases passed (0 ms)
Your runtime beats 100 % of cpp submissions
Your memory usage beats 86.74 % of cpp submissions (6.7 MB)