38、栈与队列的转换

问题：栈和队列能相互转换吗？

问题分析：用栈实现队列等价于用“后进先出”的特性实现先进先出的特性。

解决方案：两个栈，stack_in，stack_out

实现思路：准备两个栈用于实现队列：stack_in和stack_out

当有新元素入队时：将其压入stack_in

当需要出队时：

stack_out.size()==0;将stack_in中的元素逐一弹出并压入stack_out，将stack_out的栈顶元素弹出

stack_out.size()>0,将stack_out的栈顶元素弹出

#include <iostream>
#include "LinkStack.h"
#include "LinkQueue.h"
using namespace std;
using namespace WSlib;
template <typename T>
class StacktoQueue:public Queue<T>
{
protected:
mutable LinkStack<T> m_stack_in;
mutable LinkStack<T> m_stack_out;
void move()const  //o(n)
{
if(m_stack_out.size()==0)
{
while(m_stack_in.size()>0)
{
m_stack_out.push(m_stack_in.top());//const函数里边只能调用const函数，而push和pop不是const函数，所以对象加mutable
m_stack_in.pop();
}
}
}
public:
void add(const T& e) //o(1)
{
m_stack_in.push(e);
}
  void remove() //o(n)
{
move();
if(m_stack_out.size()>0)
{
m_stack_out.pop();
}
else
{
THROW_EXCEPTION(InvalidOperationException,"No element");
}
}
T front() const //o(n)
{
move();
if(m_stack_out.size()>0)
{
return m_stack_out.top();
}
else
{
THROW_EXCEPTION(InvalidOperationException,"No element");
}
}
void clear()  //o(n)
{
m_stack_in.clear();
m_stack_out.clear();
}
int length() const //o(1)
{
return m_stack_in.size()+m_stack_out.size();
}
};
int main()
{
StacktoQueue<int>aq;
for(int i=0;i<10;i++)
{
aq.add(i);
}
while(aq.length()>0)
{
cout<<aq.front()<<endl;
aq.remove();
}
return 0;
}
//不是一个好的方案

2、是否可以用队列实现栈？

问题分析：用队列先进先出的特性实现栈后进后出的特性。

实现思路：准备两个队列用于实现栈：queue_1[in]和queue_2[out]

当有新元素入栈时：将其加入队列[in]

当需要出栈时：将队列[in]中n-1个元素出队列，并进入队列[out]中，将队列[in]中的最后一个元素出队列（出栈），交换两个队列的角色：queue_1[out]和queue_2[in]。

#include <iostream>
#include "LinkStack.h"
#include "LinkQueue.h"
using namespace std;
using namespace WSlib;
template <typename T>
class StacktoQueue:public Queue<T>
{
protected:
mutable LinkStack<T> m_stack_in;
mutable LinkStack<T> m_stack_out;
void move()const
{
if(m_stack_out.size()==0)
{
while(m_stack_in.size()>0)
{
m_stack_out.push(m_stack_in.top());//const函数里边只能调用const函数，而push和pop不是const函数，所以对象加mutable
m_stack_in.pop();
}
}
}
public:
void add(const T& e)
{
m_stack_in.push(e);
}
  void remove()
{
move();
if(m_stack_out.size()>0)
{
m_stack_out.pop();
}
else
{
THROW_EXCEPTION(InvalidOperationException,"No element");
}
}
T front() const
{
move();
if(m_stack_out.size()>0)
{
return m_stack_out.top();
}
else
{
THROW_EXCEPTION(InvalidOperationException,"No element");
}
}
void clear()
{
m_stack_in.clear();
m_stack_out.clear();
}
int length() const
{
return m_stack_in.size()+m_stack_out.size();
}
};


template <typename T>
class QueuetoStack:public Stack<T>
{
protected:
LinkQueue<T> m_queue_1;
LinkQueue<T> m_queue_2;
LinkQueue<T>* m_pin;
LinkQueue<T>* m_pout;
void move() const
{
int n=m_pin->length()-1;
for(int i=0;i<n;i++)
{
m_pout->add(m_pin->front());
m_pin->remove();
}
}
void swap() //o(1)
{
LinkQueue<T>* temp=NULL;
temp=m_pin;
m_pin=m_pout;
m_pout=temp;
}
public:
QueuetoStack() //o(1)
{
m_pin=&m_queue_1;
m_pout=&m_queue_2;
}
void push(const T& e) //o(1)
{
m_pin->add(e);
}
    void pop()  //o(n)
{
if(m_pin->length()>0)
{
move();
m_pin->remove();
swap();


}
else
{
THROW_EXCEPTION(InvalidOperationException,"No element in current stack");
}
}
T top() const //o(n)
{
if(m_pin->length()>0)
{
move();
return m_pin->front();
}
else
{
THROW_EXCEPTION(InvalidOperationException,"No element in current stack");
}
}
    void clear() //o(n)
{
m_queue_1.clear();
m_queue_2.clear();
}
int size() const //o(1)
{
return m_queue_1.length()+m_queue_2.length();
}
};
int main()
{
QueuetoStack<int>aq;
for(int i=0;i<10;i++)
{
aq.push(i);
}
while(aq.size()>0)
{
cout<<aq.top()<<endl;
aq.pop();
}
return 0;

}

小结：栈和队列在实现上非常类似，可以相互转化实现。两个站后进先出叠加得到先进先出的特性，两个队列先进先出相互配合得到后进先出的特性，栈和队列相互转化的学习有助于强化本质的理解。