DAY 10 用栈实现队列 && 用队列实现栈

最新推荐文章于 2024-06-11 22:29:04 发布

喝哈喝哈

最新推荐文章于 2024-06-11 22:29:04 发布

阅读量808

点赞数 9

分类专栏：算法学习笔记文章标签：数据结构

本文链接：https://blog.csdn.net/qq_42734601/article/details/136449122

版权

算法学习笔记专栏收录该内容

18 篇文章 0 订阅

订阅专栏

队列是先进先出，栈是先进后出。

如图所示：

栈与队列理论1

首先要知道栈和队列是STL（C++标准库）里面的两个数据结构。

但C++标准库是有多个版本的，要知道我们使用的STL是哪个版本，才能知道对应的栈和队列的实现原理。

那么来介绍一下，三个最为普遍的STL版本：

HP STL 其他版本的C++ STL，一般是以HP STL为蓝本实现出来的，HP STL是C++ STL的第一个实现版本，而且开放源代码。
P.J.Plauger STL 由P.J.Plauger参照HP STL实现出来的，被Visual C++编译器所采用，不是开源的。
SGI STL 由Silicon Graphics Computer Systems公司参照HP STL实现，被Linux的C++编译器GCC所采用，SGI STL是开源软件，源码可读性甚高。

栈stack

来说一说栈，栈先进后出，如图所示：

栈与队列理论2

栈提供push 和 pop 等等接口，所有元素必须符合先进后出规则，所以栈不提供走访功能，也不提供迭代器(iterator)。不像是set 或者map 提供迭代器iterator来遍历所有元素。

栈是以底层容器完成其所有的工作，对外提供统一的接口，底层容器是可插拔的（也就是说我们可以控制使用哪种容器来实现栈的功能）。

所以STL中栈往往不被归类为容器，而被归类为container adapter（容器适配器）。

那么STL 中栈是用什么容器实现的？

从下图中可以看出，栈的内部结构，栈的底层实现可以是vector，deque，list 都是可以的，主要就是数组和链表的底层实现。

栈与队列理论3

我们常用的SGI STL，如果没有指定底层实现的话，默认是以deque为缺省情况下栈的底层结构。

deque是一个双向队列，只要封住一段，只开通另一端就可以实现栈的逻辑了。

队列queue

SGI STL中队列底层实现缺省情况下一样使用deque实现的。

我们也可以指定vector为栈的底层实现，初始化语句如下：

std::stack<int, std::vector<int> > third;  // 使用vector为底层容器的栈

刚刚讲过栈的特性，对应的队列的情况是一样的。

队列中先进先出的数据结构，同样不允许有遍历行为，不提供迭代器, SGI STL中队列一样是以deque为缺省情况下的底部结构。

也可以指定list 为起底层实现，初始化queue的语句如下：

std::queue<int, std::list<int>> third; // 定义以list为底层容器的队列

所以STL 队列也不被归类为容器，而被归类为container adapter（容器适配器）。

总结

1.STL中，C++中的stack、queue 是容器么？不是，而是归类为容器适配器。二者能由其他容器实现底层结构

2.stack、queue 都不提供迭代器，不允许有遍历行为。

3.stack、queue 都默认用deque实现底层结构。

4.std::deque（双端队列）是一个动态数组，允许在两端进行高效地插入和删除操作。

双端操作：std::deque 允许在队列的两端进行插入和删除操作。这意味着在队列的前端和后端都可以快速地插入和删除元素，使得它比 std::vector 更适合需要频繁在两端进行操作的情况。
动态扩展：std::deque 的内部实现使用了分块的方式，每个块都是一个固定大小的数组。在插入或删除元素时，如果需要，std::deque 会动态地分配或释放内存，以保证队列的有效扩展和收缩。
随机访问：std::deque 支持通过索引进行随机访问，即可以通过下标访问特定位置的元素。这使得在需要随机访问元素的场景中，std::deque 是一个更好的选择。
迭代器支持：std::deque 提供了正向迭代器和反向迭代器，可以使用迭代器遍历和修改容器中的元素。
功能丰富：除了基本的插入、删除和访问功能外，std::deque 还提供了一系列其他的成员函数，如 size() 获取容器中元素的数量，empty() 检查容器是否为空，clear() 清空容器中的元素等。

1.用栈实现队列

使用栈实现队列，队列应当支持一般队列支持的所有操作（push、pop、peek、empty）：

void push(int x) 将元素 x 推到队列的末尾
int pop() 从队列的开头移除并返回元素
int peek() 返回队列开头的元素
boolean empty() 如果队列为空，返回 true ；否则，返回 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

说明：

你只能使用标准的栈操作 —— 也就是只有 push to top, peek/pop from top, size, 和 is empty 操作是合法的。
你所使用的语言也许不支持栈。你可以使用 list 或者 deque（双端队列）来模拟一个栈，只要是标准的栈操作即可。
假设所有操作都是有效的（例如，一个空的队列不会调用 pop 或者 peek 操作）

思路

这是一道模拟题，不涉及到具体算法，考察的就是对栈和队列的掌握程度。

使用栈来模式队列的行为，如果仅仅用一个栈，是一定不行的，所以需要两个栈一个输入栈，一个输出栈，这里要注意输入栈和输出栈的关系。

下面动画模拟以下队列的执行过程：

//执行语句：
queue.push(1);
queue.push(2);
queue.pop(); //注意此时的输出栈的操作
queue.push(3);
queue.push(4);
queue.pop();
queue.pop();//注意此时的输出栈的操作
queue.pop();
queue.empty();

在push数据的时候，只要数据放进输入栈就好，但在pop的时候，操作就复杂一些，输出栈如果为空，就把进栈数据全部导入进来（注意是全部导入），再从出栈弹出数据，如果输出栈不为空，则直接从出栈弹出数据就可以了。

最后如何判断队列为空呢？如果进栈和出栈都为空的话，说明模拟的队列为空了。

#include<iostream>
#include<string>
#include<stack>

using namespace std;

class MyQueue {
public:
    stack<int> stIn;//进栈
    stack<int> stOut;//出栈

    MyQueue() {

    }

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

    int pop() {//从队列的开头移除并返回元素
        if (stOut.empty())//若出栈为空
        {
            while (stIn.empty() != true) {//取出所有进栈中的元素到出栈中去
                stOut.push(stIn.top());
                stIn.pop();//移除
            }
        }
        int result = stOut.top();
        stOut.pop();//移除
        return result;
    }

    int peek() {//返回队列开头的元素
        int res = this->pop();
        stOut.push(res);
        return res;
    }

    bool empty() {
        return stIn.empty() && stOut.empty();
    }
};

总结

1.通过两个栈的元素弹出与输入，实现将队列的先进先出的顺序。【把一个栈的数据导入另一个栈，数据的顺序发生反转】

2.可以看出peek()的实现，直接复用了pop()，要不然，对stOut判空的逻辑又要重写一遍。

再多说一些代码开发上的习惯问题，在工业级别代码开发中，最忌讳的就是实现一个类似的函数，直接把代码粘过来改一改就完事了。

这样的项目代码会越来越乱，一定要懂得复用，功能相近的函数要抽象出来，不要大量的复制粘贴，很容易出问题！（踩过坑的人自然懂）

工作中如果发现某一个功能自己要经常用，同事们可能也会用到，自己就花点时间把这个功能抽象成一个好用的函数或者工具类，不仅自己方便，也方便了同事们。

同事们就会逐渐认可你的工作态度和工作能力，自己的口碑都是这么一点一点积累起来的！在同事圈里口碑起来了之后，你就发现自己走上了一个正循环，以后的升职加薪才少不了你！

2.用队列实现栈

仅使用两个队列实现一个后入先出（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（双端队列）来模拟一个队列 , 只要是标准的队列操作即可。

示例：

输入：
["MyStack", "push", "push", "top", "pop", "empty"]
[[], [1], [2], [], [], []]
输出：
[null, null, null, 2, 2, false]

解释：
MyStack myStack = new MyStack();
myStack.push(1);
myStack.push(2);
myStack.top(); // 返回 2
myStack.pop(); // 返回 2
myStack.empty(); // 返回 False

提示：

1 <= x <= 9
最多调用100 次 push、pop、top 和 empty
每次调用 pop 和 top 都保证栈不为空

**进阶：**你能否仅用一个队列来实现栈。

思路

队列是先进先出的规则，把一个队列中的数据导入另一个队列中，数据的顺序并没有变，并没有变成先进后出的顺序。

所以用栈实现队列，和用队列实现栈的思路还是不一样的，这取决于这两个数据结构的性质。

但是依然还是要用两个队列来模拟栈，只不过没有输入和输出的关系，而是另一个队列完全用来备份的！

用两个队列que1和que2实现队列的功能，que2其实完全就是一个备份的作用，把que1最后面的元素以外的元素都备份到que2，然后弹出最后面的元素，再把其他元素从que2导回que1。

模拟的队列执行语句如下：

queue.push(1);        
queue.push(2);        
queue.pop();   // 注意弹出的操作       
queue.push(3);        
queue.push(4);       
queue.pop();  // 注意弹出的操作    
queue.pop();    
queue.pop();    
queue.empty();

#include<string>
#include<iostream>
#include<queue>

using namespace std;

class MyStack {
public:
    queue<int> que1;
    queue<int> que2;

    MyStack() {

    }

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

    int pop() {//移除并返回栈顶元素。
        
        
        while (!(que1.size() < 2 && que1.size() > 0)) {//只留一个元素
            que2.push(que1.front());
            que1.pop();
        }
        
        int result = que1.front();
        que1.pop();//移除最后一个元素
        que1 = que2;
        while (que2.empty() != true)
        {
            //que1.push(que2.front());//首个元素添加回que1
            que2.pop();//que2清除首个元素
        }

        return result;
    }

    int top() {
        // int tmp = this->pop();
        // que1.push(tmp);
        // return tmp;
        return que1.back();//简洁
    }

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

back() 方法可以用于查看队列中最后一个元素的值，但不会将该元素从队列中删除。它只是返回队列的尾部元素的值，不会改变队列的大小或内容。

优化

其实这道题目就是用一个队列就够了。

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

#include<string>
#include<iostream>
#include<queue>

using namespace std;

class MyStack {
public:
    queue<int> que1;
    //queue<int> que2;
    
    MyStack() {

    }

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

    int pop() {//移除并返回栈顶元素。
        
        int size = que1.size();
        size--;
                
        while (size--) { 将队列头部的元素（除了最后一个元素外） 重新添加到队列尾部
            que1.push(que1.front());
            que1.pop();
        }
        
        int result = que1.front();
        que1.pop();//移除元素

        return result;
    }

    int top() {

        return que1.back();//简洁
    }

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

时间复杂度: pop为O(n)，其他为O(1)
空间复杂度: O(n)

总结

1.队列间的数据移植不会改变数据的顺序；所以取出最后一个元素之前所有其他元素移进另一个队列，移除最后一个元素完了后再将刚刚的那些元素重新push回去。

2.一个队列的实现，就是将最后一个元素之前的所有其他元素，挨个push到队列本身的末尾，然后“最后一个元素”就到了首个位置了；再移除还是取值都可以。

喝哈喝哈

关注

9
点赞
踩
13

收藏

觉得还不错? 一键收藏
1
评论
DAY 10 用栈实现队列 && 用队列实现栈

1.STL中，C++中的stack、queue 是容器么？不是，而是归类为容器适配器。二者能由其他容器实现底层结构2.stack、queue 都不提供迭代器，不允许有遍历行为。3.stack、queue 都默认用deque实现底层结构。4.std::deque（双端队列）是一个动态数组，允许在两端进行高效地插入和删除操作。std::deque允许在队列的两端进行插入和删除操作。这意味着在队列的前端和后端都可以快速地插入和删除元素，使得它比更适合需要频繁在两端进行操作的情况。std::deque。
复制链接

扫一扫