两个栈实现队列与两个队列实现栈

看到的一道面试题，要求用两个栈实现队列，然后自己写了下。今晚先写两个栈实现队列吧，明天再写两个队列实现栈。

stack  和 queue 的基本操作

1、stack

stack 模板类的定义在<stack>头文件中。
stack 模板类需要两个模板参数，一个是元素类型，一个容器类型，但只有元素类型是必要
的，在不指定容器类型时，默认的容器类型为deque。
定义stack 对象的示例代码如下：
stack<int> s1;
stack<string> s2;
stack 的基本操作有：
入栈，如例：s.push(x);
出栈，如例：s.pop();注意，出栈操作只是删除栈顶元素，并不返回该元素。
访问栈顶，如例：s.top()
判断栈空，如例：s.empty()，当栈空时，返回true。
访问栈中的元素个数，如例：s.size()。

2、queue

queue 模板类的定义在<queue>头文件中。
与stack 模板类很相似，queue 模板类也需要两个模板参数，一个是元素类型，一个容器类
型，元素类型是必要的，容器类型是可选的，默认为deque 类型。
定义queue 对象的示例代码如下：
queue<int> q1;
queue<double> q2;

queue 的基本操作有：

入队，如例：q.push(x); 将x 接到队列的末端。
出队，如例：q.pop(); 弹出队列的第一个元素，注意，并不会返回被弹出元素的值。
访问队首元素，如例：q.front()，即最早被压入队列的元素。
访问队尾元素，如例：q.back()，即最后被压入队列的元素。
判断队列空，如例：q.empty()，当队列空时，返回true。
访问队列中的元素个数，如例：q.size()

两个stack实现queue

#include <IOSTREAM>
#include <QUEUE>
#include <STACK>
using namespace  std;

/*
*整体思路:
*
*
*/
template<typename T>
class CQueue{
private:
    stack<T>  s1;
    stack<T>  s2;
public:
    T outQueue();   //出队
    void inQueue(T const& Data);  //入队
};

template<typename T>
void CQueue<T>::inQueue(T const& Data)
{
    s1.push(Data);
}

template<typename T>
T CQueue<T>::outQueue()
{
    while (s1.size())
    {
        T dataTemp = s1.top();
        s1.pop();
        s2.push(dataTemp);
    }
    if (!s2.size())
    {
        cout<<"Queue is Empty"<<endl;
        return 0;
    }

    T data = s2.top();
    s2.pop();

    return data;
}


int main()
{
    
//    int array[5] = {1,2,3,4,5};
    CQueue<int> myQueue;

    int i =0;
    for (i=0;i<5;i++)
    {
        myQueue.inQueue(i);
    }
    for (i=0;i<10;i++)
    {
        cout<<myQueue.outQueue()<<endl;
    }
    return 0;
}

两个queue 实现的stack

#include <IOSTREAM>
#include <QUEUE>
#include <STACK>
using namespace  std;

template<typename T>
class CStack{
private:
    queue<T> q1;
    queue<T> q2;
public:
    T outStack();
    void inStack(T const& data);
};


template<typename T>
void CStack<T>::inStack(T const& data)
{
    q1.push(data);
}


template<typename T>
T CStack<T>::outStack()
{
    while(q1.size()>1)
    {
        T dataTemp = q1.front();
        q2.push(dataTemp);
        q1.pop();
    }
    if (q1.size()==1)
    {
        T data = q1.front();
        q1.pop();
        return data;
    }

    while(q2.size()>1)
    {
        T dataTemp = q2.front();
        q1.push(dataTemp);
        q2.pop();
    }
    if (q2.size()==1)
    {
        T data = q2.front();
        q2.pop();
        return data;
    }
    cout<<"the Stack is Empty"<<endl;
    return NULL;
}


int main()
{
    CStack<int> myStack;
    int i =0;
    for (i=0;i<5;i++)
        myStack.inStack(i);
    for (i=0;i<10;i++)
        cout<<myStack.outStack()<<endl;
    return 0;
}