回首栈与队列

题目如下：分别用两个队列实现一个栈、两个栈实现一个队列。
不喜欢啰嗦了，直接上代码：

/************************************************************************/
/*
    用两个stack模拟queue
*/
/************************************************************************/
template <typename T> class CQueue {
public:
    CQueue(void) {}
    ~CQueue(void) {}

    void appendTail(const T& node);
    T deleteHead();

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

template<typename T> void CQueue<T>::appendTail(const T& element) {
    stack1.push(element);
}

template<typename T> T CQueue<T>::deleteHead() {
    if (stack2.size() <= 0) {
        while (stack1.size() > 0) {
            T& data = stack1.top();
            stack1.pop();
            stack2.push(data);
        }
    }

    if (stack2.size() == 0) {
        throw new exception("queue is empty.");
    }

    T head = stack2.top();
    stack2.pop();
    return head;
}

下面的是两个队列实现栈，给出了两个版本，方法名带1的表示稍作改进，咳咳细细审核一下，有错的地方还望批评指正：

/************************************************************************/
/*
    用两个queue实现stack
*/
/************************************************************************/

template<typename T> class CStack {
public:
    CStack():eleCnt(0) { }
    ~CStack() {}

    T pop();
    T pop1();
    void push(const T& element);
    void push1(const T& element);
    int getTotal();
private:
    queue<T> queue1;
    queue<T> queue2;
    int eleCnt;
};

template <typename T> int CStack<T>::getTotal() {
    return eleCnt;
}

template<typename T> void CStack<T>::push(const T& ele) {
    queue1.push(ele);
    eleCnt++;
}
//queue1 专门负责进出队列 
//queue2 用来做中转站
//坏处：每次出栈一个元素，都需要来回移动两遍元素
template<typename T> T CStack<T>::pop() {
    if (queue1.empty()) {
        throw new exception("stack is empty.");
    }
    T tmp;
    while (queue1.size() != 1) {
        tmp = queue1.front();
        queue1.pop();
        queue2.push(tmp);
    }

    tmp = queue1.front();
    queue1.pop();
    while (queue2.size() != 0) {
        T tmp1 = queue2.front();
        queue2.pop();
        queue1.push(tmp1);
    }
    return tmp;
}
template<typename T> void CStack<T>::push1(const T& ele) {
    if (queue1.empty() && queue2.empty()) {
        queue1.push(ele);
    }
    else if (queue1.size() > 0) {
        queue1.push(ele);
    }
    else if(queue2.size() > 0) {
        queue2.push(ele);
    }
    eleCnt ++;
}
//queue1和queue2轮流负责进出栈，但需要保证至少有一个栈是空的
template<typename T> T CStack<T>::pop1() {
    if (queue1.empty() && queue2.empty()) {
        throw new exception("stack is empty.");
    }

    T tmp;
    if (queue2.empty()) { //从queue1出栈
        while (queue1.size() != 1) {
            tmp = queue1.front();
            queue1.pop();
            queue2.push(tmp);
        }

        tmp = queue1.front();
        queue1.pop();
    }
    else {//从queue2出栈
        while (queue2.size() != 1) {
            tmp = queue2.front();
            queue2.pop();
            queue1.push(tmp);
        }
        tmp = queue2.front();
        queue2.pop();
    }
    return tmp;
}

验证如下：

int main(){
    CStack<int> stacks;
    stacks.push1(4);
    stacks.push1(3);
    stacks.push1(2);
    cout << stacks.pop1() << endl;
    system("pause");
    return 0;
}

结果是输出2.后进先出嘛~~