用两个栈创建队列

1.第一种方法：

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<stack>
using namespace std;

//Pop , push, front, back, empty;
template<class T>
class MyQueue
{
public:
    //判断队列是否为空。    empty
    bool empty()
    {
        if (head.empty() && reak.empty())
            return true;
        return false;
    }

    //队列添加元素            push
    void push(T val)
    {
        head.push(val);
    }

    //删除队列的元素： 队列的性质：先进先出        pop
    void Pop()
    {
        if (this->empty())                    //判断队列知否为空
            throw exception("MyQueue empty");
        if (!head.empty())                    //队列不为空，
        {
            if (reak.empty())                //中转栈为空
            {
                while (!head.empty())        //将数据拷进中转栈中，这样，就可以使第一个元素暴漏出来
                {
                    reak.push(head.top());
                    head.pop();
                }
            }
        }
        reak.pop();                        //删除中转栈的栈顶元素，即队列的第一个元素
    }

    
    //返回队列的队头元素
    T& Front()
    {
        if (this->empty())                    //判断队列知否为空
            throw exception("MyQueue empty");
        if (!head.empty())
        {
            if (reak.empty())
            {
                while (!head.empty())
                {
                    reak.push(head.top());
                    head.pop();
                }
            }
        }
        return reak.top();
    }


    //返回队列的队尾元素
    T& Back()
    {
        if (this->empty())                    //判断队列知否为空
            throw exception("MyQueue empty");
        if (!reak.empty())
        {
            if (head.empty())
            {
                while (!reak.empty())
                {
                    head.push(reak.top());
                    reak.pop();
                }
            }
        }

        return head.top();
    }

private:
    stack<T> head;        //队列的尾
    stack<T> reak;        //队列的头
};

//测试函数
void test01()
{
    MyQueue<int> que;
    //给队列添加元素
    for (int i = 0; i < 10; i++)
    {
        que.push(i + 10);
    }
    //返回队头元素
    cout<<que.Front()<<endl;
    //返回队尾元素
    cout << que.Back() << endl;

    //删除队头元素
    que.Pop();
    que.Pop();

    //返回队头元素
    cout << que.Front() << endl;
    //返回队尾元素
    cout << que.Back() << endl;
    //判断队列是否为空
    if (que.empty())
    {
        cout << "队列为空" << endl;
    }
    else
    {
        cout << "队列不为空" << endl;
    }

}


int main()
{
    try
    {
        test01();
    }
    catch (...){
        cout << "抛出其他异常" << endl;
    }

    system("pause");
    return EXIT_SUCCESS;
}

2.第二种方法：

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include <stack>
using namespace std;

class Myqueue
{
public:
    //判断队列是否为空。    empty
    bool empty()
    {
        if (s1.empty() && s2.empty())
            return true;
        return false;
    }

    //队列添加元素            push
    void push(int val)
    {
        s1.push(val);
    }

    //删除队列的元素： 队列的性质：先进先出        pop
    void Pop()
    {
        if (this->empty())
        {
            cout << "队列为空Error!!!" << endl;
            return;
        }
        //先把元素拷进中转栈
        if (!s1.empty())
        {
            if (s2.empty())
            {
                while (!s1.empty())
                {
                    s2.push(s1.top());
                    s1.pop();
                }
            }
        }
        //删除完元素后再拷进原来的栈
        if (!s2.empty())
        {
            s2.pop();
            while (!s2.empty())
            {
                s1.push(s2.top());
                s2.pop();
            }
        }

    }
    //返回队列的队头元素
    int& Front()
    {
        int* val = new int;
        if (this->empty())
        {
            throw exception("MyQueue empty");
        }
        //先把元素拷进中转栈
        if (!s1.empty())
        {
            if (s2.empty())
            {
                while (!s1.empty())
                {
                    s2.push(s1.top());
                    s1.pop();
                }
            }
        }
        if (!s2.empty())
        {
            *val = s2.top();
            while (!s2.empty())
            {
                s1.push(s2.top());
                s2.pop();
            }
        }
        return *val;
    }

    //返回队列的队尾元素
    int& Back()
    {
        
        if (this->empty())
        {
            throw exception("MyQueue empty");
            
        }
        return s1.top();
    }
private:
    stack<int> s1;            //队列的尾
    stack<int> s2;            //队列的头
};


void test02()
{
    Myqueue que;
    //给队列添加元素
    for (int i = 0; i < 10; i++)
    {
        que.push(i + 20);
    }
    //返回队头元素
    cout << que.Front() << endl;
    //返回队尾元素
    cout << que.Back() << endl;

    //删除队头元素
    que.Pop();
    que.Pop();

    //返回队头元素
    cout << que.Front() << endl;
    //返回队尾元素
    cout << que.Back() << endl;
    //判断队列是否为空
    if (que.empty())
    {
        cout << "队列为空" << endl;
    }
    else
    {
        cout << "队列不为空" << endl;
    }
}


int main02()
{

    test02();

    system("pause");
    return EXIT_SUCCESS;
}

总结： 这两种方法的不同之处在于：

　　1.第一种方法：只向中转栈容器拷贝一次，直至这个栈容器空。（即自建队列元素进入的那个栈容器）；

　　2.第二种方法：先向中转栈容器中拷贝，每次操作完后再将中转容器中剩余的元素拷贝回原来的栈容器（即自建队列元素进入的那个栈容器）；

困惑之处：

　　1.当时看到这道题的困惑之处在于，如何把两个栈容器绑定在一起，（当时陷入死循环，忘了创建类这中方法）。

　　2.当创建一个类时，用它定义的对象就可以作为自定义的队列。(也可以很好的把两个栈容器集成在一块)。