代码随想录算法训练营第九天|栈与队列理论基础，232.用栈实现列队，225. 用队列实现栈

最新推荐文章于 2024-09-27 11:26:03 发布

unicorn0927

最新推荐文章于 2024-09-27 11:26:03 发布

阅读量842

点赞数 23

文章标签：开发语言 c++ 算法

本文链接：https://blog.csdn.net/weixin_72770304/article/details/136000285

版权

栈与队列理论基础

232.用栈实现列队

225. 用队列实现栈

栈与队列理论基础

在C++中，栈（Stack）和队列（Queue）是两种不同的数据结构，它们在数据管理和访问方式上有本质的区别。

栈（Stack）

栈是一种后进先出（LIFO, Last-In-First-Out）的数据结构，这意味着最后加入栈的元素将是第一个被移除的。想象一下一摞盘子，你只能在顶部添加或移除盘子。在C++中，栈可以通过标准模板库（STL）中的std::stack容器来实现。

特点：

后进先出。
只能在一端（栈顶）进行添加或删除操作。
主要操作有：push（添加元素到栈顶）、pop（从栈顶移除元素）、top（访问栈顶元素，但不移除）。

队列（Queue）

队列是一种先进先出（FIFO, First-In-First-Out）的数据结构，这意味着最先加入队列的元素将是第一个被移除的。想象一下排队买票，最先到的人将是最先买到票的人。在C++中，队列可以通过STL中的std::queue容器来实现。

特点：

先进先出。
在队列的末尾添加元素，在队列的开头移除元素。
主要操作有：push（或enqueue，将元素添加到队列末尾）、pop（或dequeue，从队列开头移除元素）、front（访问队列的第一个元素）、back（访问队列的最后一个元素）。

区别

访问顺序： 栈是后进先出，而队列是先进先出。
操作端点： 栈的操作仅在栈顶进行，而队列的操作在队列的两端进行，一端添加元素，另一端移除元素。
用途： 由于它们的特点，栈和队列适用于不同的场景。栈通常用于解决如递归、回溯等需要后退操作的问题，而队列适用于需要按顺序处理元素的场景，如任务调度、缓冲处理等。

C++中stack 是容器么？

在C++中，std::stack不是容器，而是一个容器适配器。容器适配器是一种使用底层容器提供的接口，为用户提供不同的接口或功能的类。具体来说，std::stack提供了一种限制性的接口，专注于LIFO（后进先出）策略，而不是直接操作底层容器的所有功能。

std::stack默认使用std::deque作为其底层容器，但也可以配置为使用其他类型的容器，如std::list或std::vector。通过模板参数可以指定这些底层容器，使得std::stack在行为上像一个栈，尽管底层可能是用一个完全不同的容器类型实现的。

栈的主要操作

push: 向栈顶添加一个元素。
pop: 移除栈顶元素。
top: 访问栈顶元素。
empty: 检查栈是否为空。
size: 返回栈中的元素数量。

这些操作隐藏了底层容器的复杂性，为用户提供了一个简单而专注的后进先出的数据结构接口。因此，虽然std::stack表现得像一个容器，但技术上讲，它是一个容器适配器。

我们使用的STL中stack是如何实现的？

std::stack是作为容器适配器实现的，这意味着它使用一个底层容器来提供其功能，而不是自身直接管理元素的存储。默认情况下，std::stack使用std::deque作为其底层容器，但也可以通过模板参数指定使用std::vector或std::list作为底层容器。std::stack提供的操作仅限于典型的栈操作

stack 提供迭代器来遍历stack空间么？

std::stack不提供迭代器来遍历栈。这是因为栈是一种严格的LIFO数据结构，其设计目的是仅允许访问栈顶元素。提供迭代器会与栈的基本原则相违背，因为迭代器允许遍历和访问栈中的任意元素，这不是栈设计的初衷。

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

stIn: 用于入队操作的栈。所有新加入的元素都被推入这个栈。
stOut: 用于出队操作的栈。当需要进行出队操作时，如果这个栈为空，则将stIn中的所有元素逆序转移到stOut中。

C++

class MyQueue {
public:
    stack<int> stIn;
    stack<int> stOut;
    /** Initialize your data structure here. */
    MyQueue() {

    }
    /** Push element x to the back of queue. */
    void push(int x) {
        stIn.push(x);
    }

    /** Removes the element from in front of queue and returns that element. */
    int pop() {
        // 只有当stOut为空的时候，再从stIn里导入数据（导入stIn全部数据）
        if (stOut.empty()) {
            // 从stIn导入数据直到stIn为空
            while(!stIn.empty()) {
                stOut.push(stIn.top());
                stIn.pop();
            }
        }
        int result = stOut.top();
        stOut.pop();
        return result;
    }

    /** Get the front element. */
    int peek() {
        int res = this->pop(); // 直接使用已有的pop函数
        stOut.push(res); // 因为pop函数弹出了元素res，所以再添加回去
        return res;
    }

    /** Returns whether the queue is empty. */
    bool empty() {
        return stIn.empty() && stOut.empty();
    }
};

pop() 和 peek()两个函数功能类似,pop将元素弹出来了但是peek没有。

225. 用队列实现栈

请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（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（双端队列）来模拟一个栈，只要是标准的栈操作即可。

c++

用辅助队列

class MyStack {
public:
    queue<int> que1;
    queue<int> que2; // 辅助队列，用来备份
    /** Initialize your data structure here. */
    MyStack() {

    }

    /** Push element x onto stack. */
    void push(int x) {
        que1.push(x);
    }

    /** Removes the element on top of the stack and returns that element. */
    int pop() {
        int size = que1.size();
        size--;
        while (size--) { // 将que1 导入que2，但要留下最后一个元素
            que2.push(que1.front());
            que1.pop();
        }

        int result = que1.front(); // 留下的最后一个元素就是要返回的值
        que1.pop();
        que1 = que2;            // 再将que2赋值给que1
        while (!que2.empty()) { // 清空que2
            que2.pop();
        }
        return result;
    }

    /** Get the top element. */
    int top() {
        return que1.back();
    }

    /** Returns whether the stack is empty. */
    bool empty() {
        return que1.empty();
    }
};

不用辅助队列

class MyStack {
public:
    queue<int> que;
    /** Initialize your data structure here. */
    MyStack() {

    }
    /** Push element x onto stack. */
    void push(int x) {
        que.push(x);
    }
    /** Removes the element on top of the stack and returns that element. */
    int pop() {
        int size = que.size();
        size--;
        while (size--) { // 将队列头部的元素（除了最后一个元素外） 重新添加到队列尾部
            que.push(que.front());
            que.pop();
        }
        int result = que.front(); // 此时弹出的元素顺序就是栈的顺序了
        que.pop();
        return result;
    }

    /** Get the top element. */
    int top() {
        return que.back();
    }

    /** Returns whether the stack is empty. */
    bool empty() {
        return que.empty();
    }
};