day10 232.用栈实现队列 225. 用队列实现栈

232.用栈实现队列

用两个栈模拟队列，一个是输入栈 一个是输出栈

• 在push数据的时候，只要数据放进输入栈就好，但在pop的时候，操作就复杂一些，输出栈如果为空，就把进栈数据全部导入进来（注意是全部导入），再从出栈弹出数据，如果输出栈不为空，则直接从出栈弹出数据就可以了。
• 最后如何判断队列为空呢？如果进栈和出栈都为空的话，说明模拟的队列为空了。

class MyQueue {
public:
    stack<int> stIn;        //  输入栈 例如1234栈顶为4
    stack<int> stOut;       //输出栈 4321栈顶为1 就实现队列操作
    MyQueue() {

    }
    //输入栈中输入数据
    void push(int x) {
        stIn.push(x);
    }
    
    int pop() {
        //说明数据都在stIn中
        if(stOut.empty()){
            while(!stIn.empty()){
                stOut.push(stIn.top());
                stIn.pop();
            }
        }
        //已经把数据放入输出栈中
        int result=stOut.top();
        stOut.pop();
        //用pop函数实现输出队列开头的元素
        return result;
    }
    
    int peek() {
        int res=this->pop();    //使用pop弹出输出栈栈顶的元素 也就是队列开头的元素
        stOut.push(res);    //因为pop函数弹出元素res，所以再添加进去
        return res;

    }
    //当输入栈和输出栈都为0时 表示队列为空
    bool empty() {
        return stIn.empty() && stOut.empty();
    }
};

/**
 * Your MyQueue object will be instantiated and called as such:
 * MyQueue* obj = new MyQueue();
 * obj->push(x);
 * int param_2 = obj->pop();
 * int param_3 = obj->peek();
 * bool param_4 = obj->empty();
 */

225. 用队列实现栈

使用一个队列实现：将队列的头部位置（除了最后一个元素）重新添加到队列末尾（也就是再队列中颠倒元素的顺序，变得和栈一样）

class MyStack {
public:
    queue<int> que;
    MyStack() {

    }
    
    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() {
        return que.empty();
    }
};

/**
 * Your MyStack object will be instantiated and called as such:
 * MyStack* obj = new MyStack();
 * obj->push(x);
 * int param_2 = obj->pop();
 * int param_3 = obj->top();
 * bool param_4 = obj->empty();
 */

使用两个队列实现栈：两个队列que1和que2实现队列的功能，que2其实完全就是一个备份的作用
4321是que1 1是队列头 ，对于栈来说4就是头，要保证队列和栈的输出顺序一致，就可以先把321放在que2中，然后输出4

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

    }
    
    void push(int x) {
        que1.push(x);
    }
    
    int pop() {
        int size=que1.size();
        //保证留下最后一个元素不会重新排序
        size--;
        //将que1的元素暂时放入que2中 剩下最后一个元素
        while(size--){
            que2.push(que1.front());
            que1.pop();
        }
        int result=que1.front(); //que1最后一个元素就是要输出的值
        que1.pop();
        que1=que2;  //再把que2赋值给que1
        while(!que2.empty()){   //清空que2 等待下一次备份
            que2.pop();
        }
        return result;
    }

    
    int top() {
        return que1.back();  //栈的头部就是队列的尾部
    }
    
    bool empty() {
        return que1.empty();
    }
};

/**
 * Your MyStack object will be instantiated and called as such:
 * MyStack* obj = new MyStack();
 * obj->push(x);
 * int param_2 = obj->pop();
 * int param_3 = obj->top();
 * bool param_4 = obj->empty();
 */