题目描述：

用两个栈来实现一个队列，完成队列的Push和Pop操作。队列中的元素为int类型。

思路一：有点死脑筋，每次pop后都默认下次是push操作，，，，。233主要是由于没把握好两个栈模拟时入队和出队的时机。考虑stack1和stack2的大小和入队出队的关系即可改进了

思路二：改进版（避免了默认下次是push操作导致的多余的push和pop操作）

stack2模拟出队，stack1模拟入队，
1.（出队）只要stack1还有元素，那么出队的应该是stack1的栈底元素，此时应该把stack1的元素出栈到stack2中，
2.（入队）因为要保证入队的顺序元素之间的元素正确，那么入栈时，stack2应该保持空，如多stack2非空那么stack2的元素应该出现在stack1的中

思路三：思路二的进一步提升？，，，剑指offer（版）

class Solution1
{
public:
    void push(int node) {
        stack1.push(node);
    }

    int pop() {
       while(!stack1.empty()){
            stack2.push(stack1.top());
            stack1.pop();
        }
        int ans=stack2.top();
        stack2.pop();
        while(!stack2.empty()){
            int top=stack2.top();
            stack1.push(top);
            stack2.pop();
        }
        return ans;
    }

private:
    stack<int> stack1;
    stack<int> stack2;
};
/*模拟队列：队列（先进先出），栈（先进后出），为了让栈模拟先进先出，即要能够将栈底元素pop出，保持其他元素的顺序，于是利用两个栈来回倒即可
1.首先借助stack1完成队列的入队操作，
此时如果要出队，那么应该是stack1的栈底元素，但是栈的出栈顺序是从顶部出栈的（先进后出）,
2.借助stack2将stack1的所有元素出栈到stack2中，那么stack1出栈完后，stack2的栈顶元素即是所想要的队列的出队元素，此时将stack2做pop（）操作即可
3.出队完成后此时stack2的栈可能非空，为了下次出栈准备，把stack2的元素全部出栈到stack1中，这样相当于把stack1的栈底元素pop（）出，即模拟了先进先出；
*/
class Solution2
{
public:
    void push(int node) {
        while(!stack2.empty()){
            stack1.push(stack2.top());
            stack2.pop();
         }
        stack1.push(node);
    }
    int pop() {
        while(!stack1.empty()){
            stack2.push(stack1.top());
            stack1.pop();
        }
        int result=stack2.top();
        stack2.pop();
        return result;
    }

private:
    stack<int> stack1;
    stack<int> stack2;
};
/*stack2模拟出队，stack1模拟入队，
1.（出队）只要stack1还有元素，那么出队的应该是stack1的栈底元素，此时应该把stack1的元素出栈到stack2中，
2.（入队）因为要保证入队的顺序元素之间的元素正确，那么入栈时，stack2应该保持空，如多stack2非空那么stack2的元素应该出现在stack1的中*/

class Solution3
{
public:
    void push(int node) {
       stack1.push(node);
    }
    int pop() {
        if(stack2.empty()){
            while(!stack1.empty()){
                stack2.push(stack1.top());
                stack1.pop();
            }
        }
        if(stack2.size() == 0)
        throw new exception("queue is empty");
        int result=stack2.top();
        stack2.pop();
        return result;
         
    }
private:
    stack<int> stack1;
    stack<int> stack2;
};

剑指offer版

template<typename T> void CQueue<T>::appendTail(const T& element)
{
    stack1.push(element);
} 

template<typename T> T CQueue<T>::deleteHead()
{
    if(stack2.size()<= 0)
    {
        while(stack1.size()>0)
        {
            T& data = stack1.top();
            stack1.pop();
            stack2.push(data);
        }
    }

    if(stack2.size() == 0)
        throw new exception("queue is empty");

    T head = stack2.top();
    stack2.pop();

    return head;
}

class Solution4{//队列模拟栈
public:
    void push(int node){
        queue1.push(node);
    }
    int pop(){
        if(queue1.size()==0&&queue2.size()==0){
            throw runtime_error("queque is empty");
        }
        if(queue1.size()==0&&queue2.size()!=0){
            while(queue2.size()>1){
                queue1.push(queue2.front());
                queue2.pop();
            }
            int ans=queue2.front();
            queue2.pop();
            return ans;
        }
        while(queue1.size()>1){
            queue2.push(queue1.front());
            queue1.pop();
        }
        if(queue1.size()==1){//这里判断可以不需要
            int ans=queue1.front();
            queue1.pop();
            return ans;
        }

    }
private:
    queue<int> queue1;
    queue<int> queue2;
};

剑指offer面试题9：用两个栈实现队列（两个队列模拟栈）

题目描述：

猜你喜欢