队列

队列

一、   定义：队列元素只能从队尾插入（称为入队操作，enqueue），从队首删除（称为出对操作，dequeue）。

二、   ADT:

template <typename E>class Queue{

public:

Queue(){}            //构造函数

virtual ~Queue() {}   //析构函数

 

virtual void clear() = 0;                //清除

virtual void enqueue(const E&) = 0;      //入队

virtual void dequeue() = 0;              //出队

virtual const E& frontValue() const = 0; //队首元素

virtual int length() const = 0;          //队列长度

};

三、   顺序队列：

l  实现方法：listArray是一个指向存放队列元素数组的指针，队列的构造函数提供可选参数，以设置队列的最大长度。为了区分空队列和满队列，数组大小实际要比队列允许的最大长度大1。

l  代码如下:

template<typename E>class AQueue:public Queue < E > {

private:

int maxSize;  //最大长度

int front;          //队首元素

int rear;           //队尾元素

E* listArray;    //数组

public:

AQueue(int sz = defaultSzie)

{

     maxSize= sz + 1;

     rear= 0; front = 1;

     listArray= new E[maxSize];

}

~AQueue(){delete[] listArray; }

void clear(){ rear = 0; front = 1; }

void enqueue(const E& it)

{

     assert(((rear+ 2) % maxSize) != front, "Queue is full!");

     rear= (rear + 1) % maxSize;

     listArray[rear]= it;

}

E dequeue()

{

     assert(length()!= 0, "Queue is empty!");

     E it = listArrey[front];

     front= (front + 1) % maxSize;

     returnit;

}

const E& frontValue() const

{

     assert(length!= 0, "Queue is empty!");

     return listArray[front];

}

int length() const

{

     retrun ((rear+ maxSize) - front + 1) % maxSize;

}

};

 

四、   链式队列

l  在初始化的时候，front和rear同时指向头节点，之后front总是指向头节点，而rear指向队列的尾结点。

l  代码如下：

template<typename E>class LQueue:public Queue < E > {

private:

Link<E>* front;  //队首元素

Link<E>* rear;   //队尾元素

int size;

public:

LQueue(intsz = defaultSize)

{

     front= rear = new Link<E>();

     size= 0;

}

~LQueue(){clear(); delete front; }

 

void clear()

{

     while(front->next != NULL)

     {

         rear= front;

         deleterear;

     }

     rear= front;

     size= 0;

}

void enqueue(const E& it)

{

     rear->next= new Link<E>(it, NULL);

     rear= rear->next;

     size++;

}

E dequeue()

{

     assert(size!= 0, "Queue is empty!");

     Eit = front->next->element;

     Link<E>*temp = front->next;

     front->next= temp->next;

     if(rear == temp) rear = front;

     deletetemp;

     size--;

     returnit;

}

const E& frontValue() const

{

     assert(size!= 0, "Queue is empty!");

     returnfront->next->element;

}

int length() const { return szie; }

};