Day 10 补进度篇——栈和队列

最新推荐文章于 2024-09-10 18:20:25 发布

ty_aa9910

最新推荐文章于 2024-09-10 18:20:25 发布

阅读量726

点赞数 22

文章标签：数据结构

本文链接：https://blog.csdn.net/ty_aa9910/article/details/138503811

版权

今日任务：

理论基础

232.用栈实现队列

225. 用队列实现栈

在C++中，std::stack 是一个容器适配器，而不是一个容器本身。它基于另一个容器（如 std::deque 或 std::vector）来提供栈（后进先出，LIFO）的行为。

1. std::stack 是容器么？

不，std::stack 不是一个容器。它是一个容器适配器，它封装了对底层容器的访问，并提供了一个栈的接口（即 push(), pop(), top(), empty(), size() 等方法）。
2. 我们使用的 std::stack 是属于哪个版本的STL？

std::stack 是C++标准库（Standard Template Library, STL）的一部分，自C++98标准起就存在。因此，无论您使用的是C++98、C++03、C++11、C++14、C++17、C++20 还是更新的标准，std::stack 都应该可用。
3. STL中 std::stack 是如何实现的？

std::stack 的实现依赖于一个底层容器。默认情况下，这个容器是 std::deque，但您可以在创建 std::stack 的实例时指定其他容器类型（只要该容器支持 front(), back(), push_back(), pop_back() 等操作）。std::stack 适配器将这些底层容器的操作转换为栈操作。例如，push() 操作将元素添加到底层容器的末尾，pop() 操作从底层容器的末尾删除元素，top() 返回底层容器末尾的元素等。
4. std::stack 提供迭代器来遍历stack空间么？

不，std::stack 不提供迭代器来遍历栈空间。这是因为栈是一个后进先出（LIFO）的数据结构，其主要操作是添加和删除元素到/从栈顶，而不是遍历所有元素。因此，C++标准库的设计者决定不提供迭代器来遍历 std::stack 的元素。如果您需要遍历栈中的所有元素，您可能需要考虑使用其他数据结构，如 std::deque 或 std::vector。

请注意，虽然不能直接遍历 std::stack，但您可以通过复制栈中的元素到另一个可迭代的数据结构（如 std::vector）来间接遍历栈。这可以通过循环使用 top() 和 pop()（但注意在遍历后可能需要恢复栈的状态）或使用 std::stack 的成员函数（如果可用）来实现。然而，这种方法并不总是可行的或高效的，因为它依赖于 std::stack 的具体实现。

232.用栈实现队列

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

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

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);  将元素x压入入队栈stIn  
    }

    /** Removes the element from in front of queue and returns that element. */
    int pop() {
        // 如果出队栈stOut为空，则需要从入队栈stIn中转移数据  
        if (stOut.empty()) {
            // 从stIn导入数据直到stIn为空
            while(!stIn.empty()) { //检查入队栈（stIn）是否为空
                //首先调用stIn.top()来获取入队栈（stIn）的栈顶元素（即最后一个入队的元素）
                //这个元素被压入出队栈（stOut）的栈顶。这样，原本在stIn中最后入队的元素现在成了stOut中最早可以出队的元素。
                 将stIn的栈顶元素（即最后入队的元素）压入stOut  
                // 注意：这里的转移实际上是逆序的，但因为是从stOut的栈顶开始出队，所以最终顺序会恢复为FIFO 
                stOut.push(stIn.top()); 
                //调用stIn.pop()来移除入队栈（stIn）的栈顶元素
                stIn.pop();
            }
        }
        // 此时stOut的栈顶元素就是队列的最前端元素（即最先入队的元素）
        // 弹出并返回这个元素  
        int result = stOut.top();
        stOut.pop(); // 从stOut中弹出这个元素
        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函数的工作流程如下：

首先，它检查出队栈stOut是否为空。如果为空，说明队列中的所有元素都在入队栈stIn中。
如果stOut为空，则通过一个while循环将stIn中的所有元素转移到stOut中。由于栈是LIFO结构，这个转移过程实际上是逆序的，但因为我们从stOut的栈顶开始出队，所以最终出队的顺序仍然是按照它们入队的顺序（即FIFO）。
在元素从stIn转移到stOut之后，或者如果stOut原本就不为空，函数会直接从stOut的栈顶弹出一个元素，这就是队列的最前端元素（即最先入队的元素）。
该元素被赋值给result变量，并从stOut中删除。
最后，函数返回这个出队的元素result。

在栈的数据结构中，元素是按照后进先出（LIFO）的原则进行操作的。当我们将stIn（入队栈）中的元素转移到stOut（出队栈）时，这个过程是通过不断地将stIn的栈顶元素（即最后入队的元素）弹出并压入stOut来完成的。

假设stIn中的元素顺序是 A -> B -> C（A是最先入队的，C是最后入队的），那么栈顶元素就是C。当我们开始转移元素时：

首先，我们将stIn的栈顶元素C弹出并压入stOut，此时stOut的栈顶元素是C，stIn中剩下的元素是 A -> B。
接着，我们再次将stIn的栈顶元素B弹出并压入stOut，此时stOut的栈顶元素是B（C在其下），stIn中剩下的元素是 A。
最后，我们将stIn中剩下的唯一元素A弹出并压入stOut，此时stOut的栈顶元素是A（B和C在其下）。

peek函数的工作流程如下：

int res = this->pop();：这行代码调用了pop函数来获取队列的前端元素，并将其存储在变量res中。但这里有一个潜在的问题，因为pop函数通常用于移除并返回队列的前端元素，这意味着它会改变队列的状态（即减少一个元素）。
stOut.push(res);：为了保持队列的状态不变（即不真正移除元素），这行代码将刚刚从pop函数获得的元素res重新压入stOut栈中。这样，队列的前端元素仍然保留在stOut栈中，以供后续操作使用。
return res;：返回队列的前端元素

225. 用队列实现栈

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

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

为了满足栈的特性，即最后入栈的元素最先出栈，在使用队列实现栈时，应满足队列前端的元素是最后入栈的元素。

可以使用两个队列实现栈的操作，其中 queue1用于存储栈内的元素，queue 2作为入栈操作的辅助队列。

class MyStack {
public:

    //定义两个队列，用于模拟栈的行为
    queue<int> queue1;
    queue<int> queue2;
    MyStack() {
        //初始化栈结构，此处无需做特别的操作
    }
    //入栈操作，将元素x压入栈中
    void push(int x) {
        //将新元素x推入queue2
        queue2.push(x);
        //当queue1 不为空时，将queue1的所有元素逐个推入queue2
        //这样，新元素的x就会移动到queue2的队首，满足栈的后进先出特性
        while (!queue1.empty()){
            queue2.push(queue1.front());
            queue1.pop();
        }
        // 交换queue1和queue2的引用，此时queue1将包含栈中的元素，且新元素在队首
        swap(queue1,queue2);
    }
    //出栈操作，移除栈顶元素并返回该元素

    int pop() {
        // 取出queue1的队首元素（即栈顶元素）  
        int r = queue1.front();  
        //移除queue1的队首元素
        queue1.pop();
        //返回栈顶元素
        return r;
    }
    //获取栈顶元素，但不移除它 
    int top() {
        //直接返回queue1的队首元素（栈顶元素）
        int r=queue1.front();
        return r;
    }
    //判断栈是否为空
    bool empty() {
        // 返回queue1是否为空，因为queue1存储了栈中的元素  
        return queue1.empty();  

    }
};

一个队列在模拟栈弹出元素的时候只要将队列头部的元素（除了最后一个元素外）重新添加到队列尾部，此时再去弹出元素就是栈的顺序了。

class MyStack {
public:

    //定义两个队列，用于模拟栈的行为
    queue<int> que;

    MyStack() {
        //初始化栈结构，此处无需做特别的操作
    }
    //入栈操作，将元素x压入栈中
    void push(int x) {
        que.push(x);

    }
    //出栈操作，移除栈顶元素并返回该元素
    int pop() {
        
        int size = que.size();
        size--;
        while(size--){
            que.push(que.front());
            que.pop();
        }
        int result = que.front();
        que.pop();
        return result;

    }
    //获取栈顶元素，但不移除它 
    int top() {
        return que.back();
    }
    //判断栈是否为空
    bool empty() {
        // 返回queue是否为空 
        return que.empty();  

    }
};