c++循环队列

wang -- 编程日记一：

实现循环队列（类模板方便以后使用）

首先是虚基类，相当于声明了几个队列的基本功能

template<class T>

class queue

{

public:

	queue(){};

	virtual bool EnQueue(const T& x) = 0; 

	virtual bool DeQueue(T& x) = 0;

	virtual bool getFront(T& x) = 0;

	virtual bool IsEmpty()const = 0;

	virtual bool IsFull()const = 0;

	virtual int getSize()const = 0;

	~queue(){};

};

注：其中的EnQueue(const T& x) = 0; 参数x是引用的参数，如果在函数中改变了x的值，其实参也会改变可能会出现错误，所以在前面加入const，这样如果在函数中改变了

x的值，编译时就会报错。

类似的在函数后面加入const是为了让这个函数不改变类的成员函数，如果改变了编译时就会报错。

循环队列:

循环队列利用element[maxSize]来储存队列中的元素，队列中有两个变量raer和front，分别表示队列的队尾和队头所在数组的下标，maxSize是数组的最大长度，默认为10.

每加入一个元素，队尾rear:(rear+1)%maxSize,每出队一个元素队头标记front:(front+1)%maxSize.(最好画个图以便理解) 

当队列为空rear = front.

当队列为满 (rear+1)%maxSize =front  所以循环队列只能存储maxSize-1个数据.

循环队列：继承自队列

template <class T>

class SeqQueue :public queue<T>

{

public:

    SeqQueue(int sz = 10);

    ~SeqQueue(){ delete[]elements; }

    bool EnQueue(const T& x);

    bool DeQueue(T& x);

    bool getFront(T& x)const;

    bool IsEmpty() const{ return (front == rear) ? true : false; }

    bool IsFull()const{ return ((rear + 1) % maxSize == front ? true : false); }

    int  getSize()const { return (rear - front + maxSize) % maxSize; }

protected:

	int rear, front;

	T *elements;

	int maxSize;

};

template <class T>
SeqQueue<T>::SeqQueue(int sz) :front(0), rear(0), maxSize(sz)
{
    elements = new T[maxSize];
};

template <class T>

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

{

	if (IsFull() == true) return false;

	elements[rear] = x;

	rear = (rear + 1) % maxSize;

	return true;

};

template <class T>

bool SeqQueue<T>::getFront(T &x) const

{

	if (IsEmpty() == true)return false;

	x = elements[front];

	return true;

};

template <class T>

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

{

	if (IsEmpty() == true) return false;

	x = elements[front];

	front = (front + 1) % maxSize;

	return true;

};

                                                                                 ----------wang

                                     有问题发我邮箱:568551096@qq.com