JZ-C-07

剑指offer第七题：利用两个栈实现队列

//============================================================================
// Name        : JZ-C-07.cpp
// Author      : Laughing_Lz
// Version     :
// Copyright   : All Right Reserved
// Description :利用两个栈实现队列
//============================================================================

#include <iostream>
#include <stack>
using namespace std;
template<typename T> //类模板，typename可替换为class
class CQueue {
public:
    CQueue(void); //缺省构造函数
    ~CQueue(void);
    void appendTail(const T& node); // 在队列末尾添加一个结点
    T deleteHead();
private:
    stack<T> stack1;
    stack<T> stack2;
};
//对使用类模板的类的函数，都要在前面加上类模板
template<typename T> CQueue<T>::CQueue(void) {
}
template<typename T> CQueue<T>::~CQueue(void) {
}
/**
 *队列的插入在队列尾部：此处实现是在stack1里push
 */
template<typename T> void CQueue<T>::appendTail(const T& element) { //这里为什么是&呢？
    stack1.push(element);
}
/**
 * 队列的取出在队列头部：此处实现是根据stack2中的栈顶元素是最先进入队列的元素（通过判断stack2是否为空）
 */
template<typename T> T CQueue<T>::deleteHead() {
    if (stack2.empty()) {
        //将stack1全部压入stack2中
        while (!stack1.empty()) {
            T& node = stack1.top();
            stack1.pop();
            stack2.push(node);
        }
    }
    if (stack2.empty()) { //再次判断，如果stack2栈空，说明队列已空★
        cout << "队列为空" << endl;
        throw new exception();
    }
    //从stack2中取出栈顶元素
    T node = stack2.top();
    stack2.pop();
    return node;
}
int main() {
    CQueue<char> queue;
    queue.appendTail('a');
    queue.appendTail('b');
    queue.appendTail('c');
    char result1 = queue.deleteHead();
    queue.appendTail('d');
    char result2 = queue.deleteHead();
    cout<<result1<<endl;
    cout<<result2<<endl;
    char result3 = queue.deleteHead();
    cout<<result3<<endl;
    char result4 = queue.deleteHead();
    cout<<result4<<endl;
//    char result5 = queue.deleteHead();//队列已为空
    return 0;
}

扩展：利用两个队列实现栈

//============================================================================
// Name        : JZ-C-07.cpp
// Author      : Laughing_Lz
// Version     :
// Copyright   : All Right Reserved
// Description :扩展：利用两个队列实现栈
//============================================================================

#include <iostream>
#include <queue>
using namespace std;
template<typename T> //类模板，typename可替换为class
class CStack {
public:
    CStack(void); //缺省构造函数
    ~CStack(void);
    void appendHead(const T& node); // 入栈
    T deleteHead(); //出栈
private:
    queue<T> queue1;
    queue<T> queue2;
};
//对使用类模板的类的函数，都要在前面加上类模板
template<typename T> CStack<T>::CStack(void) {
}
template<typename T> CStack<T>::~CStack(void) {
}
/**
 *入栈：此处实现是判断两个队列哪个为不为空（为空的队列用来出栈，交替使用）
 */
template<typename T> void CStack<T>::appendHead(const T& element) { //这里为什么是&呢？
    if (!queue1.empty()) {
        queue1.push(element);
    } else {
        queue2.push(element); //默认第一次入栈插入第二个队列
    }
}
/**
 * 出栈：此处实现是将某个不为空的队列除最后一个元素全部出队列并插入另一个队列中
 */
template<typename T> T CStack<T>::deleteHead() {
    if (queue1.empty() && queue2.empty()) {
        cout << "栈已为空，错误！" << endl;
        throw new exception();
    } else if (!queue1.empty()) {
        while (queue1.size() > 1) {
            T& node = queue1.front();
            queue1.pop();
            queue2.push(node);
        }
        T& node = queue1.front(); //将最后压入的元素出栈，出栈后queue1为空
        queue1.pop();
        return node;
    } else if (!queue2.empty()) {
        while (queue2.size() > 1) {
            T& node = queue2.front();
            queue2.pop();
            queue1.push(node);
        }
        T& node = queue2.front(); //将最后压入的元素出栈，出栈后queue2为空
        queue2.pop();
        return node;
    }
    return 0;//并没意义
}
int main() {
    CStack<char> stack;
    stack.appendHead('a');
    stack.appendHead('b');
    stack.appendHead('c');
    stack.appendHead('d');
    char result1 = stack.deleteHead();
    cout << result1 << endl;
    stack.appendHead('e');
    char result2 = stack.deleteHead();
    cout << result2 << endl;
    char result3 = stack.deleteHead();
    cout << result3 << endl;
    char result4 = stack.deleteHead();
    cout << result4 << endl;
    char result5 = stack.deleteHead();
    cout << result5 << endl;
//    char result6 = stack.deleteHead();//栈已为空
//    cout << result6 << endl;
    return 0;
}