数据结构之队列

最新推荐文章于 2023-07-29 21:18:50 发布

原创最新推荐文章于 2023-07-29 21:18:50 发布 · 510 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#数据结构

数据结构专栏收录该内容

10 篇文章

订阅专栏

About：队列

同栈一样，队列也是一种限定性的数据结构。因其只允许一端进行元素的插入（入队列），另一端进行元素的删除（出队列），由此可知，队列是一种先进先出（first in first out）类型的线性表。我们可称这种限定性线性表为FIFO结构。同时规定，入队列的一端为队尾，出队列的一端为队头。

若我们有一队列Q(a1,a2,…,an)，则称a1为队头元素，an为队尾元素。队列中元素按a1,a2,…,an的次序进入，退出时也只能按此顺序退出。这种现象就像我们排队一样，但不能考虑插队现象。

队列的表示和实现

因为基于线性表，所以队列也有两种存储方式，首先介绍一下链队列。

链队列

用链表表示的队列简称为链队列。在一个链队列中，我们用一个头指针（front）指向头结点，尾指针（rear）初始也指向头结点，该情况下为一个空队列。

由此我们来初始化一下链队列：

//  Status是函数的类型，其值是函数结果状态代码
typedef int Status;

//  QElemType是数据元素的类型
typedef int QElemType;

typedef struct QNode{
    QElemType data;
    struct QNode *next;
}QNode,*QueuePtr;

typedef struct {
    QueuePtr front;     //头指针
    QueuePtr rear;      //尾指针
}LinkQueue;

Status InitQueue(LinkQueue **Q)
{
    //构造一个空队列
    (*Q)=(LinkQueue *)malloc(sizeof(LinkQueue));
    (*Q)->front=(*Q)->rear=(QueuePtr)malloc(sizeof(QNode));
    if(!(*Q)->front) exit(OVERFLOW);
    (*Q)->front->next=NULL;
    return OK;
}

值得注意是，这里我们运用了两个结构体，一个用来表示结点，一个用来表示头，尾指针。

链队列的入队和出队

链队列的入队和出队操作和单链表数据元素的插入操作颇为类似。如果大家在之前的章节学的很稳的话，我想后续也应该如老狗了。

入队

当进行入队操作时，我们只需将新结点的指向为空，并将其添加到链表的末端即可,在添加过程中，要注意指针的指向顺序。

具体算法如下：

Status EnQueue(LinkQueue *Q,QElemType e)
{
    //插入元素e为新的对尾元素
    QNode *p=(QueuePtr)malloc(sizeof(QNode));
    if(!p) exit(OVERFLOW);
    p->data =e;
    p->next=NULL;
    Q->rear->next=p;	Q->rear=p;	//重点代码
    return OK;
}

这里先调整了末端结点的指向，再改变尾指针的指向。

出队

当进行出队操作时，我们只需free掉链表的第一个有效结点即可。free同时，注意改变各指针指向。

具体算法如下：

Status DeQueue(LinkQueue *Q,QElemType *e)
{
    //若队列不为空，则删除队头元素
    if(Q->front==Q->rear) return ERROR;
    QNode *p=Q->front->next;
    *e=p->data;
    Q->front->next=p->next;
    if(Q->rear==p) Q->rear = Q->front;      //当删到一个都没时
    free(p);
    return OK;
}

这里注意，当失去队列的最后一个有效结点时，尾指针要重新指向头结点，否则将失去尾指针。

循环队列

和顺序栈类似，在队列的顺序存储结构中，也是用一组地址连续的存储单元依次存放各数据元素的，也有front，rear指针指向队列的头元素和尾元素。但若完全像顺序栈一样，我们会发现这样一种情况：即实际空间并未占满，但rear指针已经开始构造新的空间了。这样的做法是及其浪费存储空间的。

一种较巧妙的方法是将顺序队列臆造成一个环形的空间，我们称这种结构为循环队列。在循环队列中，我们规定，当front==rear时，表示队列空间为空。当front==rear的下一个位置的存储地址时,表示队列空间已满。即我们少用了一个元素空间，来区别于有可能出现的两次front==rear情况。

由此我们来初始化一下循环队列：

//  Status是函数的类型，其值是函数结果状态代码
typedef int Status;

//  QElemType是数据元素的类型
typedef int QElemType;

//	最大队列长度
#define MAXQSIZE 100

typedef struct {
    QElemType *base;
    int front;
    int rear;
}SqQueue;

Status InitQueue(SqQueue **Q)
{
    //构造一个空队列
    *Q=(SqQueue *)malloc(sizeof(SqQueue));
    (*Q)->base=(QElemType *)malloc(MAXQSIZE*sizeof(QElemType));
    if(!(*Q)->base) exit(OVERFLOW);
    (*Q)->front=(*Q)->rear=0;
    return OK;
}

这里用数组下标的方式形象地描述了指针的运作。

循环队列的长度

因循环的原因，常规求取长度的方法已经不适用了。由数学思维，我们可以用如下式子求取队列的长度：

(Q->rear-Q->front+MAXQSIZE)%MAXQSIZE

循环队列的入队和出队

循环队列的入队出队操作和顺序栈类似。当插入一个新的队尾元素时，尾指针增1。当删除队头元素时，头指针增1。值得留心的是，这里的增1要有循环的思维。

入队

具体算法如下：

Status EnQueue(SqQueue *Q,QElemType e)
{
    //若队列未满，则插入新的队尾元素
    if((Q->rear+1)%MAXQSIZE==Q->front) return ERROR;
    Q->base[Q->rear]=e;
    Q->rear=(Q->rear+1)%MAXQSIZE;
    return OK;
}

因为循环，运用数学思维，这里的增1要对实际分配空间取余。

出队

具体算法如下：

Status DeQueue(SqQueue *Q,QElemType *e)
{
    //若队列不为空，则删除队头元素
    if(Q->front==Q->rear) return ERROR;
    *e=Q->base[Q->front];
    Q->front=(Q->front+1)%MAXQSIZE;
    return OK;
}