两个栈实现一个队列

1. 用两个堆栈实现一个队列。

思路：对于insert，把数据插入到第一个堆栈中；

      对于remove，如果第二个堆栈为空，把第一个堆栈的所有元素pop出来并放入第二个堆栈中，然后返回第二个堆栈的第一个元素。

// implement Queue by 2 stacks
using namespace std;
class Queueby2s{
private:
    Stack s1;
    Stack s2;
    int len;
public:
    Queueby2s(): len(0) { }
    int getSize() { return len; }
    void enQueue(int n)
    {
        s1.push(n);
        ++len;
    }
    void deQueue()
    {
        int ret;
        if(0 == len)
        {
         cout<<"UNDERFLOW!"<         return -1;
        }
        if(s2.size() == 0)
        {
            while(s1.size() > 0)
           {
              s2.push( s1.pop() );
           }
           ret = s2.pop();
           --len;
           return ret;
        }
    }
};

2. 用两个队列实现一个栈。

思路：对于Push: 如果两个队列都为空，就插入到第一个队列中；否则就插入到非空的那个队列中；

      对于Pop: 把非空的那个队列的每个元素remove出来，然后插入到另一个队列中，直到剩下最后一个元素，然后将其返回。

//implement Stack by 2 queues
class Stackby2q{
private:
    Queue q1;
    Queue q2;
    int len;
public:
    Stackby2q():len(0) {}
    int getSize() {return len;}
    void push(int n)
    {
        //if both queues empty, insert into q1.
        //otherwise, insert into the non-empty queue.
        if( ( q1.size() == 0 ) && ( q2.size == 0 ) )
        {
            q1.enqueue(n);
        }
        else if(q1.size() > 0)
            q1.enqueue(n);
        else if(q2.size() > 0)
            q2.enqueue(n);
        ++len;
    }
    int pop()
    {
        int ret;
        if(0 == len)
        {
            cout<<"UNDERFLOW!"<           return -1;
        }
        if(q1.size() > 0) // q2 is empty
        {
            while(q1.size() > 1)
            q2.enqueue( q1.dequeue() );
            ret = q1.dequeue();
         return ret;
        }
        else // q1 is empty
        {
            while(q2.size() > 1)
            q1.enqueue( q2.dequeue() );
            ret = q2.dequeue();
            return ret;
        }
    }
};

3. 用1个栈实现一个队列。

思路：用递归的方法把数据从最底部移出来。

 

4.用1个队列实现一个栈。

思路：对于每次pop，用递归的方法反转队列元素的排列，然后返回第一个元素。