面试题7：用两个栈实现队列

/*cqueue.h*/
#ifndef _CQUEUE_
#define _CQUEUE_

#include "cstack.h"

template<class T>
class CQueue
{
public:
    CQueue(int queueSize);
    bool queueEn(const T& key);
    bool queueOut(T& key);
    bool queueEmpty(void);
    bool queueFull(void);
    void queueClear(void);
private:
    CStack<T> stackA;
    CStack<T> stackB;
};

#endif

/*cqueue.c*/
#include "stdafx.h"
#include "cqueue.h"

template<class T>
CQueue<T>::CQueue(int queueSize):stackA(queueSize),stackB(queueSize)
{
}

template<class T>
bool CQueue<T>::queueEn(const T&key)
{
    T tempKey;
    bool result;

    if(stackA.stackFull())
    {
        return false;
    }

    while(!stackA.stackEmpty())
    {
        result = stackA.stackPop(tempKey);
        if(true != result)
        {
            return result;
        }

        result = stackB.stackPush(tempKey);
        if(true != result)
        {
            return result;
        }
    }

    result = stackB.stackPush(key);    
    if(true != result)
    {
        return result;
    }

    while(!stackB.stackEmpty())
    {
        result = stackB.stackPop(tempKey);
        if(true != result)
        {
            return result;
        }

        result = stackA.stackPush(tempKey);
        if(true != result)
        {
            return result;
        }
    }

    return true;
}

template<class T>
bool CQueue<T>::queueOut(T &key)
{
    if(stackA.stackEmpty())
    {
        return false;
    }
    return stackA.stackPop(key);
}

template<class T>
bool CQueue<T>::queueEmpty(void)
{
    return stackA.stackEmpty();
}

template<class T>
bool CQueue<T>::queueFull(void)
{
    return stackA.stackFull();
}

template<class T>
void CQueue<T>::queueClear(void)
{
    stackA.stackClear();
}

附加一个stack的申明和实现：

#ifndef _CSTACK_
#define _CSTACK_

template<class T> class CStack
{
public:
    CStack(int stackSize);
    ~CStack();
    bool stackPush(const T &key);
    bool stackPop(T &key);
    bool stackGetPop(T &key) const;    
    void stackClear(void);
    bool stackEmpty(void) const
    {
        return stackTop == 0;
    };
    bool stackFull(void) const
    {
        return stackTop == stackSize;
    };
private:
    T * stackArry;
    int stackTop;
    int stackSize;
};

#endif

#include "cstack.h"

template<class T>  CStack<T>::CStack(int stackSize)
{
    stackArry = new T[stackSize];
    this->stackSize = stackSize;
    this->stackTop  = 0;
}

template<class T> CStack<T>::~CStack()
{
    delete []stackArry;
    stackSize = 0;
    stackTop  = 0;
}

template<class T> 
bool CStack<T>::stackPush(const T& key)
{
    if(true == stackFull())
    {
        return false;
    }
    else
    {
        stackArry[stackTop++] = key;
        return true;
    }
}

template<class T>
bool CStack<T>::stackPop(T &key)
{
    if(true == stackEmpty())
    {
        return false;
    }
    else
    {
        key = stackArry[--stackTop];
        return true;
    }
}

template<class T>
bool CStack<T>::stackGetPop(T &key) const
{
    if(true == stackEmpty())
    {
        return false;
    }
    else
    {
        key = stackArry[top-1];
        return true;
    }
}

template<class T>
void CStack<T>::stackClear(void)
{
    stackTop = 0;
}