算法--将两个栈封装成队列

纵然栈和队列是两种不同的数据结构，但是两者是可以相互转换的

把栈封装成队列

对于栈，就采用c++里面的stack
使用两个栈，栈是先进后出，而队列是先进先出
现在有两个栈，一个栈A放数据，另一个栈B为空，只要把前面栈A的数据
出栈然后压到栈B，然后出栈。因此数据只要从栈A进，从栈B出就可以了

但是，不是什么时候都能把栈A的数据压到栈B中，只有栈B为空才行。
所以对于队列的操作，进队列，直接把数据压到栈A，出队列，就从栈B
出栈，如果栈B不为空，直接出栈，如果栈B为空，需要把栈A的所有数据
都分别出栈压到栈B中，这样就形成了队列的操作。

template <typename T>
class Nqueue{
private:
    stack<T> stack1;
    stack<T> stack2;
public:
    T push(const T & node);
    void pull();
};
template <typename T>
void Nqueue<T>::push(const T & node)
{
    stack1.push(node);
}
template <typename T>
void Nqueue<T>::pull(const T & node)
{
    if(stack2.size() <= 0){
        while(stack1.size() > 0){
            T &data = stack1.top();
            stack1.pop();
            stack2.push(data);
        }
    }
    if(stack2.size == 0){
        cout << "the queue is empty" << endl;
    }
    T head = stack.top();
    stack2.pop();
    return head;
}

将两个队列封装程栈

上面的是用两个栈实现队列，同样，用两个队列同样也是可以实现栈的。
栈是先进先出，所以，把队列A的数据移到队列B，顺序还是不会变的。
思路就是从队列A不断出队放到队列B，直到剩下一个元素，然后把这个
元素出队。
进栈的话就直接放到队列A，出栈的话，如果队列A有元素，就不断把队列A
中的元素出队放到队列B直到最后一个元素，就直接出队相当于出栈。
如果队列A为空，则需要将队列B中的元素分别出队然后放到队列A，直到最后
一个元素，然后执行出队操作。
c++实现

template <typename T> class Nstack{
private:
    queue<T> q1;
    queue<T> q2;
public:
    void push(const T & element);
    T pop();
};

template <typename T>
void Nstack<T>::push(const T & element)
{
    q1.push(element);
}
template <typename T>
T Nstack<T>::pop()
{
    T front;

    if(q1.size() >  0){
        while(q1.size() != 1){
            front = q1.front();
            q2.push(front);
            q1.pop();
        }
        front = q1.front();
        q1.pop();
        return front;
    }
    if(q1.size() == 0){
        if(q2.size() > 0){
            while(q2.size() != 1){
                front = q2.front();
                q1.push(front);
                q2.pop();
            }
            front = q2.front();
            q2.pop();
            return front;
        }
    }
    cout << "the queue is empty" << endl;
    return NULL;
}