使用两个栈实现一个队列+使用两个队列实现一个栈

栈的特点是先进后出
队列的特点是先进先出

用两个栈实现一个队列，必须保证它先进先出
入栈和如队列没什么区别，区别就在出栈和出队列
用两个栈实现一个队列，入队列时可以将全部数据压入空栈s1，然后将栈s1的全部元素压入栈s2，此时s2的栈顶元素要出队列的元素了。

#include<stack>
template<class T>
class StackQueue
{
public:
    StackQueue()
    {}

    void Push(T data)
    {
        s1.push(data);
    }
    void Pop()
    {
        if(s1.empty()&&s2.empty())
            return ;
        else if(!s1.empty())    //s1不空
        {
            s1tos2();
            s2.pop();
        }
        else       //
        {
            s2.pop();
        }
    }
private:
    void s1tos2()
    {
        while(!s1.empty())
        {
            s2.push(s1.top());
            s1.pop();
        }
    }
private:
    stack<T> s1;
    stack<T> s2;
};

用两个队列实现栈
入栈和入队列没啥区别，直接压入，

出栈必须用队列实现栈的先进后出。
我们可以将压入队列q1的数据以出队列的顺序再压入另一个空的队列q2中，直到q1中只有一个元素，此时q1中的元素就是要出栈的元素了，然后q1.pop（）；这里空队列不一定就是q2，每一次出栈都会发生变化，这里只是为了说的方便一点。

#include<queue>

template<class T>
class QueueSatck
{
public:
    QueueSatck()
    {}
    void Push(T data)
    {
        if(!q1.empty())
        {
            q1.push(data);
        }
        else 
        {
            q2.push(data);
        }
    }
    void pop()
    {
        if(!q1.empty())
        {
            while(q1.size()>1)
            {
                q2.push(q1.front());
                q1.pop();
            }
            q1.pop();
        }
        else
        {
            while(q2.size()>1)
            {
                q1.push(q2.front());
                q2.pop();
            }
            q2.pop();
        }
    }


private:
    queue<T> q1;
    queue<T> q2;
};