队列

循环队列

//Queue.h
template<typename T,int Size=10>
class Queue
{
public:
    Queue();
    void push(const T &);
    void pop();
    void empty();
    void full();
    T & front();
    T & rear();
    int length();
private:
    T _arr[Size];
    int _front;
    int _rear;
};

//Queue.cc
template<typename T,int Size>
Queue<T,Size>::Queue()
:_arr(new T[Size])
,_front(0)
,_rear(0)
{}

template<typename T,int Size>
void Queue<T,Size>::push(const T & elem)
{
    if(full())
    {
        cout << "full stack" << endl;
        return;
    }
    _arr[_rear++] = elem;
    _rear %= Size;
}

template<typename T,int Size>
void Queue<T,Size>::pop()
{
    if(empty())
    {
        cout << "empty stack" << endl;
        return;
    }
    ++_front;
    _front %= Size;
}

template<typename T,int Size>
bool Queue<T,Size>::empty()
{
    return _rear == _front;
}


template<typename T,int Size>
bool Queue<T,Size>::full()
{
    return (_rear+1) % Size = _front;
}

template<typename T,int Size>
int Queue<T,Size>::length()
{
    return (_rear-_front+Size)%Size
}

template<typename T,int Size>
T & front()
{
    return _arr[_front];
}

template<typename T,int Size>
T & rear()
{
    return _arr[_rear];
}

链队列

//Queue.h
typedef struct Queue
{
    int data;
    struct Queue *pnext;
}Queue,*QueuePtr;
class Queue
{
public:
    Queue();
    void enQueue(const int &);
    void deQueue();
    bool empty();
private:
    QueuePtr _pfront;
    QueuePtr _prear;
};

//Queue.cc
Queue::Queue()
:_front(NULL)
,_rear(NULL)
{}

void Queue::enQueue(const int data)
{
    QueuePtr p = (QueuePtr)malloc(sizeof(Queue));
    p->data = data;
    p->pnext = NULL;
    if(!_pfront)
        _pfront = p;
    _prear->pnext = p;
    _prear = p;
}

void Queue::deQueue()
{
    QueuePtr p = _pfront;
    free(_pfront);
    _pfront = p->pnext;
}

队列应用：层次遍历、计算机系统