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

使用两个栈实现一个队列

思路一：
队列先进先出，栈先进后厨。
用两个栈实现一个队列。
先将数据压入栈stack1中，当stack2为空的时候，把stack1的输出弹出并压入stack2。

template<class T>
class CQueue
{
     public:
          CQueue (void);
          ~CQueue (void);
          void insert(const T& element)
          {     
               stack1.push(element);
          }

          T Delete()
          {
               if(stack2.size() <= 0)
               {
                    while(stack1.size() > 0)
                    {
                         T data = stack1.top();
                         stack1.pop();
                         stack2.push(data);
                    }
               }

               if(stack2.size() == 0)
               printf("stack1 is empty\n");

               //这里已经取到了top，所以之后要pop
               T head = stack2.top();
               stack2.pop();
               return head;
          }

private:
     stack<T> stack1;
     stack<T> stack2;
}

思路二：
入队是将元素压入stack1中。
出队时，判断stack2是否为空，如果不为空则直接弹出栈顶，如果为空，则将stack1倒入stack2，再依次弹出stack1。
这里就只用在有需要的时候倒一次数据。

两个队列模拟一个栈

思路：
队列先进先出，所以两个队列循环倒，只有其中一个队列只剩一个的时候将这个数据输出才是模拟了栈。

template<class T>
class CStack
{
     public:
          CStack (void);
          ~CStack (void);
          void insert(const T& element)
          {     
               if(!q1.empty())
                    q1.push(element);
               else
                    q2.push(element);
          }

          T Delete()
          {
              int ret = 0;
              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
               {
                    int i = q1.size();
                    //将q2中的数据pop到只剩下一个，并且输出
                    while(i > 1)
                    {
                         q2.push(q1.front());
                         q1.pop();
                         --i;
                    }
                    ret = q1.front();
                    q1.pop();
               }
                    return ret;
          }

private:
     queue<T> q1;
     queue<T> q2;
}