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

两个问题中数据的出入我只说出，进的问题都一样没什么要讲的东西。

两个栈实现一个队列

如下图所示：
  根据栈的先进先出特性，和要实现的队列的先进后出特性。首先定义一个spush存储数据，另一个spop用以操作数据，图中红框内为实现的Myqueue，spush中1、2、3、4、5、6为入栈顺序也是压入队列的顺序，那么出栈顺序为6、5、4、3、2、1，首先spush出栈，压入spop，达到下次出栈顺序为1、2、3、4、5、6，即myqueue的出队列顺序。

#include <stack>
#include <deque>
#include <iostream>
using namespace std;

template<class T>
class Myqueue
{
public:
    void Push(const T& data)
    {
        spush.push(data);
    }
    void Pop()
    {
        if (spush.empty())
        {
            return ;
        }
        else
        {
            while(spush.size()>1)
            {
                T tmp=spush.top();
                spop.push(tmp);
                spush.pop();
            }
            spush.pop();
            while (!spop.empty())
            {
                T tmp=spop.top();
                spush.push(tmp);
                spop.pop();
            }
        }
    }
    bool Empty()
    {
        return spush.empty();
    }
    size_t Size()
    {
        return spush.size();
    }
protected:
    stack<T> spush;
    stack<T> spop;
};

两个队列实现一个栈

如下图所示：
  根据队列先进先出的特性，就像漏斗一样，先将数据倒进去到qpush，顺序为1、2、3、4、5、6，要得到漏斗最后倒进去的数据6，那么我们可以将6之前的数据先漏出来到qpop，只剩下6，这样就得到了想要的数据，之后再将刚刚漏出来的其余数据再装回去，方便下次操作，直到漏斗空了。

template<class K>
class MyStack
{
public:
    void Push(const K& data)
    {
        qpush.push(data);
    }
    void Pop()
    {
        if (qpush.empty())
        {
            return ;
        }
        else
        {
            while(qpush.size()>1)
            {
                K tmp=qpush.front();
                qpop.push(tmp);
                qpush.pop();
            }
            qpush.pop();
            while (!qpop.empty())
            {
                K tmp=qpop.front();
                qpush.push(tmp);
                qpop.pop();
            }
        }
    }
protected:
    queue<K> qpush;
    queue<K> qpop;
};