两个栈实现一个队列

今天我要讲的是如何用两个栈实现一个队列。

我们知道对于栈，它是先进后出，而对于队列，它是先进先出。所以用两个栈实现一个队列最直观的思路就是：

设这两个栈分别为s1，s2，始终把s1作为存储空间，把s2作为临时空间。那么

    （1）入队时   把元素压入s1

    （2）出队时   先把s1中除最底下所有元素都倒入s2，然后弹出s1的唯一元素，再把s2中所有元素倒回s1

可以看出s2是一个辅助空间，这样做每次出队时都要先将元素从s1倒入s2，然后再从s2倒回s1。实际上我们还有

一个做法可以减少这里的"倒"次数，性能比较高，方法如下：

    （1）入队时   把元素压入s1

    （2）出队时   出队时，判断s2是否为空，如不为空，则直接弹出s2的栈顶元素，如为空，则把s1的除最

                底部元素外的所有元素逐个倒入s2，然后弹出s1的唯一元素

C++的模板类实现：

#include <iostream>
#include <string.h>
#include <stdio.h>

using namespace std;
const int N = 10005;

template<class T>
class Stack
{
    private:
    T S[N];
    int size;

    public:
    void clear();
    void push(const T&);
    bool empty();
    T pop();
};

template<class T>
void Stack<T>::clear()
{
    size = 0;
}

template<class T>
void Stack<T>::push(const T &x)
{
    if(size == N) return;
    S[size++] = x;
}

template<class T>
T Stack<T>::pop()
{
    if(size == 0) return NULL;
    return S[--size];
}

template<class T>
bool Stack<T>::empty()
{
    if(size == 0) return true;
    return false;
}

template<class T>
class Queue
{
    private:
    Stack<T> s1,s2;

    public:
    void clear();
    void push(const T&);
    bool empty();
    T pop();
};

template<class T>
void Queue<T>::clear()
{
    s1.clear();
    s2.clear();
}

template<class T>
void Queue<T>::push(const T &x)
{
    s1.push(x);
}

template<class T>
T Queue<T>::pop()
{
    if(!s2.empty()) return s2.pop();
    while(!s1.empty())
        s2.push(s1.pop());
    return s2.pop();
}

template<class T>
bool Queue<T>::empty()
{
    if(s1.empty() && s2.empty()) return true;
    return false;
}

int main()
{
    Queue<int> Q;
    Q.clear();
    for(int i=0;i<50;i++)
        Q.push(i);
    while(!Q.empty())
        cout<<Q.pop()<<" ";
    cout<<endl;
    return 0;
}