DAY9 栈与队列1

一、理论基础

 

一、我们使用的stack是属于哪个版本的STL？

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

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

1. HP STL 其他版本的C++ STL，一般是以HP STL为蓝本实现出来的，HP STL是C++ STL的第一个实现版本，而且开放源代码。

2. P.J.Plauger STL 由P.J.Plauger参照HP STL实现出来的，被Visual C++编译器所采用，不是开源的。

3. SGI STL 由Silicon Graphics Computer Systems公司参照HP STL实现，被Linux的C++编译器GCC所采用，SGI STL是开源软件，源码可读性甚高。

二、C++中stack 是容器么？（颠覆我以往学习的知识）=

栈是以底层容器完成其所有的工作，对外提供统一的接口，底层容器是可插拔的（也就是说我们可以控制使用哪种容器来实现栈的功能）。——》具体解释可以看下面的第三个问题，stl中stack的实现。

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

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

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

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

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

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（ 容器适配器）。

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

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

总：以上4个问题我只知道最后一个，我对数据结构的应用是真的还只停留在表面的应用上，还有待提高！

二、232.用栈实现队列

题目链接：力扣

我的思路：就挺简单了嘛，先把所有元素放到栈1里面，然后再把栈1里面的元素按照栈的规则，取出一个元素就放到栈2里面。

卡子哥：思路和我一样——》因为这道题就是个模拟题，没有什么思维难度。

定义2个栈：一个输入栈，一个输出栈，这里要注意输入栈和输出栈的关系。

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

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

转存失败重新上传取消

1.在push数据的时候，只要数据放进输入栈就好；

2.但在pop的时候，操作就复杂一些，输出栈如果为空，就把进栈数据全部导入进来（注意是全部导入），再从出栈弹出数据；如果输出栈不为空，则直接从出栈弹出数据就可以了。（难点）———》这个我觉得是难点，因为一开始思考的时候我没有把输入栈和输出栈之间的关系理清楚，也就是什么时候输出栈需要把数据放给输入栈，我一开始也想到了这个问题，但是我是觉得全部数据需要输入的数据都放到输入栈后，再全部转运到输出栈、再依次取出就行，主要是我当时没有仔细思考如果题目数据想先输入一点元素到队列里面，然后再输出一点，再输入一点的代码和流程应该是怎么样的。

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

在代码实现的时候，会发现pop() 和 peek()两个函数功能类似，代码实现上也是类似的，可以思考一下如何把代码抽象一下。

C++代码如下：

 class MyQueue {
 public:
     stack<int> stIn;//输入栈
     stack<int> stOut;//输出栈
     /**初始化数据结构——我这里不需要这个东西，所以不填就行. */
     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();
     }
 };

• 时间复杂度: push和empty为O(1), pop和peek为O(n)

• 空间复杂度: O(n)

函数复用

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

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

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

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

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

三、225. 用队列实现栈

题目链接：力扣

我的思路：我本来想着只用一个队列——元素进入队列的时候就正常进入；然后要取出元素的时候，先把所有元素取出，然后把队列中最末尾的元素拿出来，剩下的元素放回队列中（保持原来的顺序）

卡子哥思路：基本和我一样，只不过卡子哥有2种思路：

一、第一种是取出的元素里面不需要拿出来的元素放在了第二个队列里面。

如下面动画所示，用两个队列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();    

详细如代码注释所示：

 class MyStack {
 public:
     queue<int> que1;
     queue<int> que2; // 辅助队列，用来备份
     /** Initialize your data structure here. */
     MyStack() {
 ​
     }
     /** 入栈 和 入队列 的操作一样 */
     void push(int x) {
         que1.push(x);
     }
     /** 从栈中移除元素——本题关键 */
     int pop() {
         int size = que1.size();
         size--;
         while (size--) { // 将que1 导入que2，并留下最后一个元素——》因为while循环之前size已经递减了一次，所以while循环结束后队列中还会剩下一个元素。
             que2.push(que1.front());//que1.front()就是队列中第一个元素的值
             que1.pop();
         }
         int result = que1.front(); // 留下的最后一个元素就是要返回的值
         que1.pop();//清空que1
         que1 = que2;            // 再将que2赋值给que1
         while (!que2.empty()) { // 清空que2
             que2.pop();
         }
         return result;
     }
 ​
     /** 返回栈顶元素 */
     int top() {
         return que1.back();
     }
 ​
     /** Returns whether the stack is empty. */
     bool empty() {
         return que1.empty();
     }
 };

• 时间复杂度: push为O(n)，其他为O(1)

• 空间复杂度: O(n)

二、第二种：只用一个队列。

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

 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();
     }
 };

• 时间复杂度: push为O(n)，其他为O(1)

• 空间复杂度: O(n)