剑指offer笔记——面试题9：用两个栈实现队列

---

用两个栈实现一个队列

问题描述

用两个栈实现一个队列，队列的功能有：在队尾插入结点、在队列头部删除结点

代码

CQueue.h

#ifndef CQUEUE_H
#define CQUEUE_H
#include <iostream>
#include <stack>

template <typename T>
class CQueue
{
public:
    CQueue();
    ~CQueue();
    void appendTail(const T&);
    T deleteHead();
protected:
private:
    std::stack<T> stack1;
    std::stack<T> stack2;
};

#endif // CQUEUE_H

CQueue.cpp

#include "CQueue.h"
/**
 * 构造函数
 */
template <typename T>
CQueue<T>::CQueue()
{

}
/**
 * 析构函数
 */
template <typename T>
CQueue<T>::~CQueue()
{

}
/**
 * 在队尾插入结点
 */
template <typename T>
void CQueue<T>::appendTail(const T& node)
{
    stack1.push(node);  // 此时stack1和stack2中可以都有元素，也可以只有stack2中有，也可以stack1中有，都不会影响程序有效性
}
/**
 * 在队列头部删除结点
 */
template <typename T>
T CQueue<T>::deleteHead()
{
    if(stack2.empty())  // 只有stack2为空时才能把stack1元素插入stack2中，否则实现的就不是队列了
    {                    // stack2不为空时直接弹出stack2头部元素即可，stack1不需要动
        for(; !stack1.empty();)
        {
            stack2.push(stack1.top());
            stack1.pop();
        }
    }
    if(stack2.empty())  // 注意这里的异常处理，确保stack2不为空才能pop
    {
        std::logic_error e("queue is empty");
        throw new std::exception(e);
    }
    T head = stack2.top();
    stack2.pop();
    return head;
}

template class CQueue<int>;
template class CQueue<float>;
template class CQueue<double>;

main.cpp

#include <iostream>
#include "CQueue.h"

int main()
{
    CQueue<int> CQueue1;
    int num = 1;
    CQueue1.appendTail(num);
    num = 2;
    CQueue1.appendTail(num);
    num = 3;
    CQueue1.appendTail(num);
    std::cout << CQueue1.deleteHead() << std::endl;
    std::cout << CQueue1.deleteHead() << std::endl;
    std::cout << CQueue1.deleteHead() << std::endl;
    std::cout << CQueue1.deleteHead() << std::endl;
    return 0;
}

运行结果

相关题目：用两个队列实现一个栈

问题描述

用两个队列实现一个栈

代码

CStack.h

#ifndef CSTACK_H
#define CSTACK_H
#include <iostream>
#include <queue>

template <typename T>
class CStack
{
public:
    CStack();
    ~CStack();
    void appendHead(const T&);
    T deleteHead();
protected:
private:
    std::queue<T> queue1;
    std::queue<T> queue2;
};

#endif // CSTACK_H

CStack.cpp

#include "CStack.h"

/**
 * 构造函数
 */
template <typename T>
CStack<T>::CStack()
{

}
/**
 * 析构函数
 */
template <typename T>
CStack<T>::~CStack()
{

}
/**
 * 入栈
 */
template <typename T>
void CStack<T>::appendHead(const T& node)
{
    if((!queue1.empty() && queue2.empty()) || (queue1.empty() && queue2.empty()))
        queue1.push(node);
    else if(queue1.empty() && !queue2.empty())
        queue2.push(node);
    else
        std::cout << "something went wrong" << std::endl;
}

/**
 * 出栈
 */
template <typename T>
T CStack<T>::deleteHead()
{
    if(!queue1.empty() && queue2.empty())
    {
        for(; queue1.size() > 1;)
        {
            queue2.push(queue1.front());
            queue1.pop();
        }
        T temp = queue1.front();
        queue1.pop();
        return temp;
    }
    else if(queue1.empty() && !queue2.empty())
    {
        for(; queue2.size() > 1;)
        {
            queue1.push(queue2.front());
            queue2.pop();
        }
        T temp = queue2.front();
        queue2.pop();
        return temp;
    }
    else if(!queue1.empty() && !queue2.empty())
    {
        std::cout << "something went wrong" << std::endl;
        return T(-1);
    }
    else
    {
        std::cout << "the stack is empty, no node to pop" << std::endl;
        return T(-1);
    }
}

template class CStack<int>;
template class CStack<float>;
template class CStack<double>;

main.cpp

#include <iostream>
#include "CStack.h"

int main()
{
    CStack<int> CStack1;
    int num = 1;
    CStack1.appendHead(num);
    num = 2;
    CStack1.appendHead(num);
    num = 3;
    CStack1.appendHead(num);
    std::cout << CStack1.deleteHead() << std::endl;
    std::cout << CStack1.deleteHead() << std::endl;
    std::cout << CStack1.deleteHead() << std::endl;
    std::cout << CStack1.deleteHead() << std::endl;
    return 0;
}

运行结果