队列、循环队列操作及其链队列操作

一、队列

1.队列的表示和操作的实现

1.1相关术语

队列是仅在表尾进行插入操作，在表头进行删除操作的线性表。

表尾即an端，称为队尾；表头即a1端，称为队头。

它是一种先进先出（FIFO）的线性表。

插入元素称为入队；删除元素称为出队。

队列的存储结构为链队或顺序队（常用循环顺序队）

1.2队列的相关概念

1.3队列的常见应用

脱机打印输出：按申请的先后顺序依次输出。

多用户系统中，多个用户排成队，分时地循环使用CPU和主存。

按用户的优先级排成多个队，每个优先级一个队列。

实时控制系统中，信号按接收的先后顺序依次处理。

网络电文传输，按到达的时间先后顺序依次进行。

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

ADT Queue{
    数据对象：D={a(i)|a(i)∈ElemSet,i=1,2,...,n,n>=0)
    数据关系：R={<a(i-1),a(i)>|a(i-1),a(i)∈D,i=2,...,n)   约定其中a1端为队列头，an端为队列尾。
    基本操作：
        InitQueue(&Q)           操作结果：构造空队列Q
        DestroyQueue(&Q)        条件：队列Q已存在；操作结果：队列被销毁
        ClearQueue(&Q)          条件：队列Q已存在；操作结果：将Q清空
        QueueLength(Q)          条件：队列Q已存在；操作结果：返回Q的元素个数，即队长
        GetHead(Q,&e)           条件：Q为非空队列；操作结果：用e返回Q的队头元素
        EnQueue(&Q,e)           条件：队列Q已存在；操作结果：插入元素e为Q的队尾元素  
        DeQueue(&Q,e)           条件：Q为非空元素；操作结果：删除Q的队头元素，用e返回值
        ......还有将队列置空，遍历队列等操作......
}ADT Queue

3.队列的顺序表示和实现

3.1队列的顺序表示

队列的物理存储可以用顺序存储结构，也可用链式存储结构。相应地，队列的存储方式也分为两种，即顺序队列和链式队列。

队列的顺序表示——用一维数组base[MAXQSIZE]

#define MAXQSIZE 100    //最大队列长度
Typedef struct{  
    QElem Type*base;    //初始化的动态分配存储空间
    int front;          //头指针
    int rear;           //尾指针
}SqQueue; 

3.2假上溢

解决假上溢的方法：

1. 将队中元素依次向队头方向移动。

缺点：浪费时间。每移动一次，队中元素都要移动。

2.将队空间设想成一个循环的表，即分配给队列的m个存储单元可以循环使用，当rear为maxqsize时，若向量的开始端空着，又可以从头使用空着的空间。当front为maxqsize时，也是一样。

解决假上溢的方法——引入循环队列

base【0】接在base【MAXQSIZE-1】之后，若rear+1==M，则令rear=0；

实现方法：利用模（mod，C语言中：%）运算。

插入元素：Q.base[Q.rear]=x;

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

删除元素：x=Q.base[s.front]

Q.front=(Q.front+1)%MAXQSIZE

循环队列：循环使用为队列分配的存储空间。

队空：front==rear

队满：front==rear

队空和队满时，头指针和尾指针都指在同一地方。无法区分队空和队满。

解决方案：

1. 另外设一标志以区别队空、队满。

2. 另设一个变量，记录元素个数。

3. 少用一个元素空间。

循环队列解决队满时判断方法——少用一个元素空间：

队空：front==rear

队满：（rear+1)%MAXQSIZE==front //队尾指针再+1，就与队头指针重合

3.3循环队列操作——队列的初始化

Status InitQueue(SqQueue &Q){
    Q.base=new QElemType[MAXQSIZE]     //分配数组空间
    //Q.base=(QElemType*)
    //malloc(MAXQSIZE*sizeof(QElemType));
    if(!Q.base)exit(OVERFLOW);            //存储分配失败
    Q.front=Q.rear=0;                //头指针尾指针置为0，队列为空
    return OK;
}

3.4循环队列操作——求队列的长度

int QueueLength(SqQueue Q){
    return(Q.rear-Q.front+MAXQSIZE)%MAXQSIZE;
}

3.5循环队列操作——循环队列入队

Status EnQueue(SqQueue &Q,QElemType){
    if((Q.rear+1)%MAXQSIZE==Q.front)return ERROR;//队满
    Q.base[Q.rear]=e;    //新元素加入队尾
    Q.rear=(Q.rear+1)%MAXQSIZE;   //队尾指针+1
    return OK;
}

3.6循环队列操作——循环队列出队

Status DeQueue(SqQueue &Q,QElemType &e){
    if(Q.front==Q.rear)return ERROR;    //队空
    e=Q.base[Q.front]     //保存对头元素
    Q.front=(Q.front+1)%MAXQSIZE;   //队头指针加1
    return OK;
}

3.7循环队列操作——取队头元素

SElemType GetHead(SqQueue Q){
    if(Q.front!=Q.rear)  //队列不为空
    return Q.base[Q.front];  //返回队头指针元素的值，队头指针不变

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

4.1链队列的定义

若用户无法估计所用队列的长度，则宜采用链队列

链队列的类型定义：

#define MAXQSIZE 100  //最大队列长度
typedef struct Qnode{
    QElemType data;
    stuct Qnode *next;
}QNode,*QuenePtr;
typedef struct{
    QuenePtr front;  //队头指针
    QuenePtr rear;  //队尾指针
}LinkQueue;

4.2链队列的操作——链队列初始化

Status InitQueue(LinkQueue &Q){
    Q.front=Q.rear=(QueuePtr)malloc(sizeof(QNode));
    if(!Q.front)exit(OVERFLOW);
    Q.front->next=NULL;
    return OK;
}

4.3链队列的操作——销毁链队列

算法思想：从队头结点开始，依次释放所有结点

Status DestroyQueue(LinkQueue &Q){
    while(Q.front){
        p=Q.front->next;free(Q.front);Q.front=p;
    }//Q.rear=Q.front->next;free(Q.front);Q.front=Q.rear;
    return OK;
}

4.4链队列的操作——将元素e入队

Status EnQueue(LinkQueue &Q, QElemType e){
    p=(QueuePtr)malloc(sizeof(QNode));
    if(!p)exit(OVERFLOW);
    p->data=e;p->next=NULL;
    Q.rear->next=p;
    Q.rear=p;
    return OK;
}

4.5链队列操作——链队列出队

Status DeQueue(LinkQueue &Q,QElemType &e){
    if(Q.front==Q.rear)return ERROR;
    p=Q.front->next;
    e=p->data;
    Q.front->next=p->next;
    if(Q.rear==p)Q.rear=Q.front;
    delete p;
    return OK;
}

4.6链队列操作——求链队列的队头元素

Status GetHead(LinkQueue Q,QElemType &e){
    if(Q.front==Q.rear)return ERROR;
    e=Q.front->next->data;
    return OK;
}