数据结构（C语言）读书笔记8：队列

1、队列（queue）的定义：队列是一种先进先出的线性表。即允许在表的一端进行插入，在另一端进行删除的线性表。

允许插入的一端叫队尾（rear），允许删除的一端叫队头（front）。

2、队列的抽象数据类型定义：

ADT Queue{

数据对象：D=｛ai | ai∈ElemSet，i=1，2，。。。。n｝

数据关系：R＝{ <ai-1, ai > | ai-1, ai∈D, i = 2, ..., n }

基本操作：

InitQueue(&Q)

操作结果：构造一个空队列Q。

DestoryQueue（&Q）

初始条件：队列Q已存在。

操作结果：队列Q被销毁，不再存在。

ClearQueue（&Q）

初始条件：队列Q已存在。

操作结果：将队列Q清为空队列。

QueueEmpty（Q）
初始条件：队列Q已存在。

操作结果：若Q为空队列，则返回TRUE,否则返回FALSE.

QueueLength（Q）

初始条件：队列Q已存在。

操作结果：返回Q的元素个数，即队列的长度。

GetHead（Q,&e）

初始条件：Q为非空队列。

操作结果：用e返回Q的队头元素。

EnQueue（&Q，e）

初始条件：队列Q已存在。

操作结果：插入元素e为Q新的队尾元素。

DeQueue（&Q，&e）

初始条件：Q为非空队列。

操作结果：删除Q队头元素，并用e返回其值。

QueueTraverse（Q，visit（））

初始条件：Q为非空队列。

操作结果：从队头到队尾，依次对Q的每个元素调用函数visit（），一旦visit（）失败，则操作失败。

}ADT Queue

3、双端队列

双端队列是限定插入和删除操作在表的两端进行的线性表。在实际使用中，还可以有输出受限的双端队列和输入受限的双端队列。

4、链队列——队列的链式表示和实现

————队列的链式存储结构————

typedef struct QNode{

QElemType data;

struct QNode *next;

}QNode,*QueuePre;

typedef struct{

QueuePre front;

QueuePre rear;

}LinkQueue;

————算法实现————————

Status InitQueue(LinkQueue &Q){

Q.front=Q.rear=(QueuePre)malloc(sizeof(QNode));

if(!Q.front) exit(OVERFLOW);

Q.front->next=NULL;

return OK;

}

Status DestoryQueue（LinkQueue &Q）{

while(Q.front)

{

Q.rear=Q.front->next;

free(Q.front);

Q.front=Q.rear;

}

return OK;

}

Status EnQueue（LinkQueue &Q，QElemType e）{

p=(QueuePre)malloc(sizeof(QNode));

p->data=e;

p->next=NULL;

Q.rear->next=p;

Q.rear=p;

return OK;

}

Status DeQueue(LinkQueue &Q,QElemType &e){

p=Q.front->next;

e=p->data;

Q.front->next=p->next;

if(Q.rear==p)Q.rear=Q.front;

free(p);

return OK;

}

5、循环队列———队列的顺序表示和实现

判断循环队列的空满的解决办法（1）另设一个标志位以区别队列是“空”还是“满”。（2），少用一个

空间元素，约定“队头指针在队尾指针的下一个位置”作为队满的标志。



队满：（rear+1）%MAXSIZE=front；

队空：rear=front；

————队列的顺序存储结构——————

#definde MAXSIZE 100

typedef struct {

QElemType *base;//初始化的动态分配存储空间

int front;

int rear;

}SqQueue;

————队列的算法描述————————

Status InitQueue(SqQueue &Q){

Q.base=(QElemType *)malloc(MAXSIZE*sizeof(QElemType));

if(!Q.base) exit(OVERFLOW);

Q.front=Q.rear=0;

return OK;

}

int QueueLength(SqQueue Q){

return (Q.rear-Q.front+MAXSIZE)%MAXSIZE;

}

Status EnQueue(SqQueue &Q,QElemType e){

if((Q.rear+1)%MAXSIZE==Q.front)return ERROR;

Q.base[Q.rear]=e;

Q.rear=(Q.rear+1)%MAXSIZE;

return OK;

}

Status DeQueue(SqQueue &Q,QElemType &e){

if(Q.front==Q.rear)return ERROR;

e=Q.base[Q.front];

Q.front=(Q.front+1)%MAXSIZE;

return OK;

}