双端队列(数组表示)

 

#ifndef SEQDEQUE_H

#define SEQDEQUE_H

 

#include <iostream>

#include <assert.h>

using namespace std;

 

template<class T>

class SeqDeque

{

public:

     SeqDeque(int sz = 100);

     ~SeqDeque()

     {

         delete []elements;

     }

     bool GetHead(T& x)const;

     bool GetTail(T& x)const;

     bool EnQueue(const T& x);

     bool EnQueueHead(const T& x);

     bool EnQueueTail(const T& x);

     bool DeQueue(T &x);

     bool DeQueueHead(T &x);

     bool DeQueueTail(T &x);

     void MakeEmpty()   //置空操作，队头和队尾指针置为

     {

         front = rear = 0;

     }

     bool IsEmpty()const

     {

         return (front == rear) ? true : false;

     }

     bool IsFull()const

     {

         return ((rear + 1) % maxSize == front) ? true : false;

     }

private:

     int front,rear;    //队头和队尾指针

     T *elements;  //存放队元素的数组

     int maxSize;  //队列最大可容纳元素个数

};

 

template<class T>

SeqDeque<T>::SeqDeque(int sz /* = 100 */):front(0),rear(0),maxSize(sz)

{

     elements = new T[maxSize];

     assert(elements != NULL);

}

 

template<class T>

bool SeqDeque<T>::EnQueue(const T& x)

{

     return EnQueueTail(x);

}

 

template<class T>

bool SeqDeque<T>::DeQueue(T &x)

{

     T temp;

     bool tag = DeQueueHead(temp);

     x = temp;

     return tag;

}

 

template<class T>

bool SeqDeque<T>::GetHead(T &x) const

{

     if(IsEmpty() == true)

         return false;

     x = elements[front];

     return true;

}

 

template<class T>

bool SeqDeque<T>::EnQueueTail(const T &x)

{

     if(IsFull() == true)

         return false;

     elements[rear] = x;

     rear = (rear + 1) % maxSize;     //队尾指针加

     return true;

}

 

template<class T>

bool SeqDeque<T>::DeQueueHead(T &x)

{

     if(IsEmpty() == true)

         return false;

     x = elements[front];

     front = (front + 1) % maxSize;

     return true;

}

 

template<class T>

bool SeqDeque<T>::GetTail(T &x) const

{

     if(IsEmpty() == true)

         return false;

     x = elements[(rear-1+maxSize)%maxSize];

     return true;

}

 

template<class T>

bool SeqDeque<T>::EnQueueHead(const T &x)

{

     if(IsFull() == true)

         return false;

     front = (front-1+maxSize)%maxSize;

     elements[front] = x;

     return true;

}

 

template<class T>

bool SeqDeque<T>::DeQueueTail(T &x)

{

     if(IsEmpty() == true)

         return false;

     rear = (rear-1+maxSize)%maxSize;

     x = elements[rear];

     return true;

}

 

#endif