ch6_2 栈实现队列 && ch6_3 队列实现栈

1. 栈实现队列

使用两个栈， 一个作为输入栈，一个作为输出栈；

将一个栈当作输入栈，用于压入 $\text{push}$传入的数据；

另一个栈当作输出栈，用于$\text{pop}$ 和 $\text{peek}$ 操作。

每次 $\text{pop}$或 $\text{peek}$ 时，若输出栈为空则将输入栈的全部数据依次弹出并压入输出栈，这样输出栈从栈顶往栈底的顺序就是队列从队首往队尾的顺序。

1.2 步骤

1. 入队时： 当输入元素到队列时， 直接将元素压入到 输入栈；

2. 出队时： 当从队列中输出元素时，
   先判断队列是否为空：
   队列为空， 则返回；

   若队列不为空， 继续判断输出栈是否为空：
   输出栈为空： 将输入栈的元素全部压入到输出栈；
   输出栈不为空： 将输出栈的栈顶元素弹出；

1.3 关键点

lc 232 栈实现队列

容器 stack 栈中，

1. 自带的 top() 方法， 返回的是栈顶元素的一个引用， 该元素没有被移除；
2. 自带的 pop() 方法， 没有返回值， 只有移除栈顶元素的操作；

#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()){//  将输入栈元素全部压入输出栈
                stOut.push( stIn.top());
                stIn.pop();
            }
        }
        // top() 函数 ，返回栈顶元素的一个引用；
         int curEle = stOut.top();
         stOut.pop();
         return curEle;
    }

     //  实现返回队列开头元素,  但是元素不移除
     int peek(){
           int First = this->pop(); // 先使用已有的函数弹出 输出栈的栈顶元素；
           stOut.push(First);//  再将元素重新 压入到 输出栈；
           return  First;
    }

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

};

2. 队列实现栈；

2.1 知识点

原始自带queue 中的 方法：

1. 自带的 front（） 方法， 返回queue 中第一个元素的引用； 如果 queue 是常量，就返回一个常引用；如果 queue 为空，返回值是未定义的。

2. back() 方法： 返回queue 中最后一个元素的引用，如果 queue 是常量，就返回一个常引用；如果 queue 为空，返回值是未定义的。

3. pop() 方法： 删除 队列中 第一个元素， 注意与栈的pop 方法的区别；

2.2 方法， 使用两个队列实现栈；

一个主队列 que1， 一个辅助队列 que2；

模仿栈的 先进后出的功能时候，

1. 将 que1 中，除了最后一个元素以外的元素 全部 导入que2;

2. 新建一个变量res， 赋值为que1 的最后一个原素；

3. 移除 que1 的最后一个元素；

4. 弹出que1 的最后元素之后， 将 que2 的元素重新赋值给 que1;

5. 清空 que2

6. 返回栈顶元素 res;

#include "queue"

using namespace std;


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

    Mystack(){}   // 默认构造函数；

    void push(int x){ que1.push(x);}  //  将元素压入到 que1;

    //   实现弹出栈顶元素功能,   并返回弹出的栈顶元素数值；
    int pop(){
        // 先将 que1 中不包括最后队尾元素， 其余所有元素压入到 que2中；
        int size = que1.size();
        size--;  //  保留que1 的队尾元素；
        while (size--){
            que2.push(que1.front());  // 将que1 的队首元素压入到 que2;
            que1.pop();   // 移除que1 的队首元素；
        }

        int res = que1.front();  // que1 剩余的最后一个元素， 队尾元素 即要弹出的元素；
        que1.pop();  // 移除que1最后的队尾元素;

        // que1 的队尾元素清空后， 将 que2 重新赋值给 que1;
        que1 = que2;
        //  然后清空 que2
        while ( !que2.empty()){
            que2.pop();
        }
        return  res;
    }


    // 返回 栈的 栈顶元素；
    int top(){  return  que1.back();}


    //  如果 que1 为空， 栈为空；
    bool empty(){ return  que1.empty();}



};