使用两个栈实现一个队列+使用两个队列实现一个栈

使用两个栈实现一个队列

始终维护s1作为存储空间，以s2作为临时缓冲区。

入队时，将元素压入s1。

出队时，将s1的元素逐个“倒入”（弹出并压入）s2，将s2的顶元素弹出作为出队元素，之后再将s2剩下的元素逐个“倒回”s1。

如图：（在下图的方法中做出优化）



优化

入队时，将元素压入s1。

出队时，判断s2是否为空，如不为空，则直接弹出顶元素；如为空，则将s1的元素逐个“倒入”s2，把最后一个元素弹出并出队。

这个思路，避免了反复“倒”栈，仅在需要时才“倒”一次。

注意：

要考虑没有元素可供出队时的处理（2个栈都为空的时候，出队操作一定会引起异常）。在实际写代码时，忽略这些判断或异常处理，程序会出现问题。

实现代码：

#include <stack>
template <class T>
class Queue
{
public:
Queue(void)
{}
~Queue(void)
{}

void Push_Tail(const T& p);
T DeleteHead();
private:
stack<T> s1;
stack<T> s2;
};

template <class T>
//在队列尾部添加数据
void Queue<T>::Push_Tail(const T& p)
{
s1.push(p);
}
template <class T>
T Queue<T>::DeleteHead()
{
T tmp = 0;
//若栈2为空
if (s2.empty())
{
while (!s1.empty())
{
tmp = s1.top();
s2.push(tmp);
s1.pop();
}
}

tmp = s2.top();
s2.pop();
return tmp;
}

测试代码：

#include <iostream>
using namespace std;
#include "Queue.h"

int main()
{
Queue<int> q1;
q1.Push_Tail(1);
int ret = q1.DeleteHead();
cout << ret << endl;
system("pause");
return 0;
}

使用两个队列实现一个栈

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

入栈：直接入队列q1即可

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

如图：





实现代码：

#include <queue>

template <class T>
class Stack
{
public:
Stack(void)
{}
~Stack(void)
{}
void Push_Tail(const T& p);
T DeleteHead();
private:
queue<T> q1;
queue<T> q2;
};

//在栈尾部添加数据
template <class T>
void Stack<T>::Push_Tail(const T& p)
{
//不为空执行push
if (!q1.empty())
{
q1.push(p);
}
else
{
q2.push(p);
}
}

//取出数据
template <class T>
T Stack<T>::DeleteHead()
{
int ret = 0;
//q1为空
if (q1.empty())
{
int i = q2.size();
//将q2的数据pop到只剩下一个
while (i > 1)
{
q1.push(q2.front());
q2.pop();
--i;
}
ret = q2.front();
q2.pop();
}
else//q1不为空
{
int i = q1.size();
while (i > 1)
{
q2.push(q1.front());
q1.pop();
--i;
}
ret = q1.front();
q1.pop();
}
return ret;
}

测试代码：

#include <iostream>
using namespace std;
#include "Queue.h"
#include "Stack.h"

int main()
{
/*Queue<int> q1;
q1.Push_Tail(1);
int ret = q1.DeleteHead();
cout << ret << endl;*/

Stack<int> s1;
s1.Push_Tail(5);
int ret = s1.DeleteHead();
cout << ret << endl;
system("pause");
return 0;
}

优化

q1是专职进出栈的，q2只是个中转站。元素集中存放在一个栈中，但不是指定(q1 或 q2)。

定义两个指针：pushtmp:指向专门进栈的队列q1； tmp：指向临时作为中转站的另一个栈q2

入栈：直接入pushtmp所指队列即可

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

（此处就不用指针指针了）效果一样~

优化之后的代码：

#include <queue>

template <class T>
class Stack
{
public:
Stack(void)
{}
~Stack(void)
{}
void Push_Tail(const T& p);
T DeleteHead();
private:
queue<T> q1;
queue<T> q2;
};

//在栈尾部添加数据
template <class T>
void Stack<T>::Push_Tail(const T& p)
{
if (!q1.empty())
{
q1.push(p);
}
else
{
q2.push(p);
}

}

template <class T>
T Stack<T>::DeleteHead()
{
int ret = 0;
if (!q1.empty())
{
while (q1.size() != 1)
{
q2.push(q1.front());
q1.pop();
}
ret = q1.front();
q1.pop();
}
else
{
while (q2.size() != 1)
{
q1.push(q2.front());
q2.pop();
}
ret = q2.front();
q2.pop();
}

return ret;
}