C++ STL之适配器（stack与queue的相互实现）

        在C++中，标准库提供了三种顺序容器适配器：queue(FIFO队列)、priority_queue(优先级队列)、stack(栈) 。

种类	默认顺序容器	可用顺序容器	说明
queue	deque	list、deque	基础容器需要提供能使用push_front
stack	deque	vector、list、deque
priority_queue	vector	vector、deque	基础容器需要提供随机访问的能力

可以使用顺序容器，初始化适配器。

如：deque<int> deq;

       stack<int>  sta(deq);

   stack的操作有size()、empty()、top()、push()、pop()；queue的操作有size()、empty()、push()、pop()、back()、front()；priority_queue的操作有size()、empty()、push()、pop()、top()；

用两个栈实现队列的功能

#include <stack>
#include <exception>
template<typename T> class CQueue
{
public:
    CQueue(void);
    ~CQueue(void);
    // 在队列末尾添加一个结点queue.push(x)将x接到队列的末尾
    void appendTail(const T& node);

    // 删除队列的头结点queue.pop();弹出不会返回元素的值
    T deleteHead();
    int GetSize();//queue.size();得到队列的大小
    T GetFront();//queue.front();得到队列的最早被压入队列的元素。
    bool IsEmpty();//queue.empty();判断队列为空
    T GetBack();//queue.back();最后被压入队列的元素。

private:
    stack<T> StackCurrent;
    stack<T> StackAssist;

};
template <typename T> T CQueue<T>::GetBack()
{
    //if(CQueue<T>::IsEmpty())
    //throw new exception("The queue is empty.");
    if (!StackCurrent.empty())
    {
        return StackCurrent.top();
    }
    else
    {
        while (StackAssist.size() > 0)
        {
            T temp = StackAssist.top();
            StackAssist.pop();
            StackCurrent.push(temp);
        }
        return StackCurrent.top();
    }
        
}
template <typename T> bool CQueue<T>::IsEmpty()
{
    return StackCurrent.empty()||StackAssist.empty();
}
template <typename T> int CQueue<T>::GetSize()
{
    int temp = StackCurrent.size()+StackAssist.size();
    return temp;
}
template <typename T> T CQueue<T>::GetFront()
{
    if(StackAssist.empty() && StackCurrent.empty())
        throw new exception("The queue is empty.");
    if (!StackAssist.empty())
    {
        T temp = StackAssist.top();
        return temp;
    }
    else
    {
        while (StackCurrent.size() > 0)
        {
            T temp = StackCurrent.top();
            StackCurrent.pop();
            StackAssist.push(temp);
        }
        T temp = StackAssist.top();
        return temp;
    }    
}
template <typename T> CQueue<T>::CQueue(void)
{
}

template <typename T> CQueue<T>::~CQueue(void)
{
}
template<typename T>void CQueue<T>::appendTail(const T& node)
{
    StackCurrent.push(node);
}
template<typename T>T CQueue<T>::deleteHead()
{
    
    if(StackAssist.size() <= 0)
    {
        while (StackCurrent.size() > 0)
        {
            T temp = StackCurrent.top();
            StackCurrent.pop();
            StackAssist.push(temp);
        }
    }
    if (StackAssist.size() == 0)
    {
        throw new exception("The queue is empty.");

    }
    else
    {
       T temp = StackAssist.top();
       StackAssist.pop();
       return temp;
    }
    
}

用两个队列实现栈

#include <queue>
template<typename T> class CStack
{
    public:
        CStack();
        ~CStack();
        bool IsEmpty();
        int GetSize();
        T GetTop();
        T DeleHead();//删除栈顶元素
        void AddHead(const T &node);//在栈顶加入元素
private:
        queue<T> queueAssit;
        queue<T> queueCurrent;
};
template<typename T>void CStack<T>::AddHead(const T &node)
{
    queueAssit.push(node);
}
template<typename T>T CStack<T>::DeleHead()
{
    if (!queueAssit.empty())
    {
        while (queueAssit.size() > 1)
        {
            T temp = queueAssit.front();
            queueAssit.pop();
            queueCurrent.push(temp);
        }
        T temp = queueAssit.front();
        queueAssit.pop();
        return  temp;///返回删除的元素
    }
    else
    {
        while (queueCurrent.size() > 1)
        {
            T temp = queueCurrent.front();
            queueCurrent.pop();
            queueAssit.push(temp);
        }
        T temp = queueCurrent.front();
        queueCurrent.pop();
        return  temp;///返回删除的元素
    }
}
template<typename T>T CStack<T>::GetTop()
{
    if (!queueAssit.empty())
    {

        while (queueAssit.size() > 1)
        {
            T temp = queueAssit.front();
            queueAssit.pop();
            queueCurrent.push(temp);
        }
        T temp = queueAssit.front();
        return  temp;///返回删除的元素
    }
    else
    {
        while (queueCurrent.size() > 1)
        {
            T temp = queueCurrent.front();
            queueCurrent.pop();
            queueAssit.push(temp);
        }
        T temp = queueCurrent.front();
        return  temp;///返回删除的元素
    }
}
template<typename T> CStack<T>::CStack()
{
    ;
}
template<typename T> CStack<T>::~CStack()
{
    ;
}
template<typename T> bool CStack<T>::IsEmpty()
{
    return queueCurrent.empty()||queueAssit.empty();
}
template<typename T> int CStack<T>::GetSize()
{
    return queueCurrent.size()+queueAssit.size();
}