两个栈实现队列 以及两个队列实现栈

1.用两个栈来实现队列，栈是先进后出的，队列是先进先出的，这时，我们可以用stack1来专门入栈，stack2来专门出栈，具体地：

入队：直接入栈到stack1

出队：检测stack2是否为空，如果为空，则将stack1的所有元素移动到stack2中，

　　　　　　　　　　　　　再次判断stack2是否为空，如果为空抛出异常；

　　　　　　　　　　　　　如果非空，将stack2的栈顶元素出队。

代码如下:

#include <iostream>
#include <stack>
using namespace std;
//用两个栈实现一个队列stack1专门用来入队  stack2专门用来出队
template<class T>class Queue
{
public:
    Queue(void){};
    ~Queue(void){};
    void AppendTail(const T &ele);
    T DeleHead();
private:
    stack<T>stack1;
    stack<T>stack2;

};

//stack1专门用来入栈
template<class T> void Queue<T>::AppendTail(const T &ele)
{
    stack1.push(ele);
}
//stack2作为临时缓冲，将stack1入栈的元素逆序 然后出栈即可实现先入先出
template<class T> T Queue<T>::DeleHead()
{
    if (stack2.size()<=0)//stack2空 则将stack1的元素都放在stack2中
    {
        while (stack1.size()>0)
        {
            T node=stack1.top();
            stack2.push(node);
            stack1.pop();
        }
    }
    if (stack2.size()==0)//判断栈是否为空
    {
        cout<<"empty"<<endl;
        throw new exception();
    }
    T RetNode =stack2.top();//返回stack2的栈顶元素
    stack2.pop();//出栈
    return RetNode;
}

void main()
{
    Queue<int>*pQu=new Queue<int>();
    pQu->AppendTail(1);
    pQu->AppendTail(2);
    pQu->AppendTail(3);

    cout<<pQu->DeleHead()<<endl;
    pQu->AppendTail(4);
    pQu->AppendTail(5);
    cout<<pQu->DeleHead()<<endl;
    cout<<pQu->DeleHead()<<endl;
    cout<<pQu->DeleHead()<<endl;
    cout<<pQu->DeleHead()<<endl;
    cout<<pQu->DeleHead()<<endl;

}

　　

队列是先进先出的，而栈是后进先出的，那么我们如何用两个队列实现栈的操作呢？

方法一：

      我们可以让queue1专门用来入栈和出栈操作，让queue2作为储存queue1的n-1个元素，也就是除了最后一个入队元素，然后将queue1中的最后元素出列，然后将queue2中的　　n-1个元素放回queue1.

　　思路：

　　q1是专职进出栈的，q2只是个中转站

　　入栈时：直接入队列q1即可

　　出栈时：把q1的除最后一个元素外全部转移到队q2中,然后把刚才剩下q1中的那个元素出队列。之后把q2中的全部元素转移回q1中。

　　如下图所：

　　

#include <queue>
#include <iostream>
using namespace std;
template <class T>
class Stack
{
public:
	Stack(){};
	~Stack(){};
	void StackPush(const T&data);
	T StackPop();
private:
	queue<T>que1;
	queue<T>que2;
};
//que1专门用来入栈
template<class T> void Stack<T>::StackPush(const T&data)
{
	que1.push(data);
}
//que2作为临时存储que1的多余变量，当出栈后要将所有元素还给que1
template<class T> T Stack<T>::StackPop()
{
	if (que1.size()<=0)
	{
		cout<<"empty"<<endl;
		throw new exception("empty");
	}
	else//que1的变量大于等于1个时
	{
		while(que1.size()>1)//将最先入n-1个元素的存que2中
		{
			que2.push(que1.front());
			que1.pop();
		}
		T RetData=que1.front();//返回最后入的元素
		que1.pop();
		while(que2.size()>0)//再将que2的元素存回que1
		{
			que1.push(que2.front());
			que2.pop();
		}
		return RetData;
	}
}

void main()
{
	Stack<int > *pSt=new Stack<int >();
	pSt->StackPush(1);
	pSt->StackPush(2);
	pSt->StackPush(3);
	cout<<pSt->StackPop()<<endl;
	cout<<pSt->StackPop()<<endl;
	cout<<pSt->StackPop()<<endl;
//	cout<<pSt->StackPop()<<endl;//抛异常
}

　　结果如下图：

　　然后我们发现，如果队列中元素较多时，每当移除一个元素，那么剩余的n-1个元素都要拷贝进queue2，然后再从queue2拷进queue1,这样增加了时间复杂度，那么能不能有其他更好的办法呢？

方法二：

　　让两个栈都当做出栈或者入栈的队列，当入栈时候，先选定一个que1入栈，当出栈时候将que1的n-1个元素移动que2。那么下一次出栈的队列为que2,再将n-1个元素移动到que1，依次.....

　　那么入栈时候该选择哪个呢？很显然，入栈也是来回变的，每当有一次出栈操作时，下次入栈时所选的队列都会改变，这时候我们只需要一个标志位flag来选定该入哪个队列就好了。

　　代码如下：

#include <queue>
#include <iostream>
using namespace std;
template <class T>
class Stack
{
public:
    Stack(){};
    ~Stack(){};
    void StackPush(const T&data);
    T StackPop();
private:
    queue<T>que1;
    queue<T>que2;
    static bool flag;//用来标识该在哪个队列入栈的标识 
};


template<class T> bool Stack<T>::flag=true;//初始化为TRUE 在que1中入栈
template<class T> void Stack<T>::StackPush(const T&data)
{
    queue<T>*quTemp=NULL;//用于指向要入栈的队列，注意初始化格式
    if (flag)//标识用来决定该入栈到哪个队列
    {
        quTemp=&que1;
    }
    else 
    {
        quTemp=&que2;
    }
    quTemp->push(data);
}


template<class T> T Stack<T>::StackPop()
{
    flag=!flag;//将标识取反
    queue<T>*popTemp=NULL;//用于出栈的临时队列
    queue<T>*saveTemp=NULL;//用于保存n-1个多余变量的队列
    if (que1.size()>=1)
    {
        popTemp=&que1;
        saveTemp=&que2;
    }
    else
    {
        popTemp=&que2;
        saveTemp=&que1;
    }
    if (popTemp->size()<=0)
    {
        cout<<"Empty"<<endl;
        throw new exception("the stack is empty");
    }
    while(popTemp->size()>1)//出栈的队列中元素大于1个 移动到另一个队列中
    {
        saveTemp->push(popTemp->front());
        popTemp->pop();
    }
    T RetVal=popTemp->front();//返回最后一个元素
    popTemp->pop();
    return RetVal;
}


void main()
{
    Stack<int> *pSt=new Stack<int>();
    
    pSt->StackPush(1);
    pSt->StackPush(2);
    pSt->StackPush(3);
     cout<<pSt->StackPop()<<endl;
    cout<<pSt->StackPop()<<endl;

    pSt->StackPush(4);
    pSt->StackPush(5);    

    cout<<pSt->StackPop()<<endl;
    cout<<pSt->StackPop()<<endl;
    cout<<pSt->StackPop()<<endl;

}

运行结果如下图所示：