数据结构——队列

最新推荐文章于 2024-09-16 09:59:01 发布

ljxb20161022

最新推荐文章于 2024-09-16 09:59:01 发布

阅读量151

点赞数

分类专栏：数据结构文章标签：数据结构

本文链接：https://blog.csdn.net/m0_65558669/article/details/126945573

版权

数据结构专栏收录该内容

6 篇文章 1 订阅

订阅专栏

一、什么是队列

队列（queue）是只允许在一端进行插入操作，而在另一端进行删除操作的1线性表。

与栈相反，队列是一种先进先出（first in first out，fifo）的线性表。

与栈相同的是，队列也是一种重要的线性结构，实现一个队列同样需要顺序表或者链表作为基础。

二、队列的链式存储结构

队列既可以用链表表示，也可以用顺序表实现。跟栈相反的是，栈一般用顺序表实现，而队列我们常用链表实现，我们简称链队列。

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

typedef struct {
    QueuePtr front,rear;//队头、尾指针 空队列时，front和rear都指向头结点
}LinkQueue;

（一）创建一个队列

1、在内存中创建一个头结点

2、将队列的头指针和尾指针都指向头结点（此时是空队列）

initQueue(LinkQueue *q)
{
    q->front=q->rear=(QueuePrt)malloc(sizeof(QNode));
    if(!q->front)
        exit(0);
    q->front->next=NULL；
}

（二）入队操作过程

入队操作代码：

InsertQueue(LinkQueue *q,ElemType e)
{
    QueuePtr p;
    p=(QueuePtr)malloc(sizeof(QNode));
    if(p==NULL)
        exit(0);
    p->data=e;
    p->next=NULL;
    q->rear->next=p;
    q->rear=p;
}

（三）出队操作

1、将队列中的第一个元素移出，队头指针不发生改变，改变头结点的next指针即可

2、如果原队列中只有一个元素，应该处理队尾指针

3、出队操作代码

DeleteQueue(LinkQueue *q,ElemType *e)
{
    QueuePtr p;
    if(q->front==q->rear)
        return;
    p=q->front->next;
    *e=p->data;
    q->front->next=p->next;
    if(q->rear==p)
        q->rear=q->front;
    free(p);
}

（四）销毁一个队列

DestroQueue(LinnkQueue *q)
{
    while(q->front)
    {
        q->rear=q->front->next;
        free(q->front);
        q->front=q->rear;
    }
}

三、队列的顺序存储

原文链接：https://blog.csdn.net/weixin_40179091/article/details/106375586

队列的顺序实现是指分配一块连续的存储单元存放队列中的元素，并附设两个指针：队头指针front指向队头元素。队尾指针rear指向队尾元素的下一个位置（其实和单链表有无头结点是一样的，队尾指针你想指向最后一个元素或者最后一个元素的下一位都行，注意相应的操作随之变动就行）。

（一·）队列的顺序存储可描述为

#define MaxSize 50
typedef struct
{
    ElemType data[MaxSize];
    int front,rear;
}SqQueue;

初始状态（队空条件）：Q.front == Q,rear == 0。

进队操作：队不满时，先送值到队尾元素，再将队尾指针加1。

出队操作：队不空时，先去队头元素值，再将队头指针加1。

图1 队列的操作

图1所示为队列的初始状态，有Q.front == Q.front == 0成立，该条件可以作为队列判空的条件。但能否用Q.rear == MaxSize作为队列满的条件呢？显然不能，图3.6(d)中，队列中仅有一个元素，但仍然满足该条件，这时对垒出现“上溢出”，但这种溢出并不是真正的溢出，在data数组中仍然存在可以存放元素的空位置，所以这是一种“假溢出”。

（二）循环队列

前面已经指出了顺序队列的缺点，为了解决顺序队列的“假溢出”也就是空间只能用一次，严重浪费的问题，我们引出一个循环队列的概念。

循环队列就是将顺序队列臆造为一个环状的空间，即把存储队列元素的表从逻辑上视为一个环（用链表来的指针来向下会清晰很多），称为循环队列。当队首指针Q.front=MaxSize-1后，再前进一个位置就自动到0，实现上可以用取余来实现。

初始时：Q.front = Q.rear = 0;

队首指针进1：Q.front = (Q.front+1)%MaxSize。

队尾指针进1：Q.rear = (Q.rear+1)%MaxSize。

对列长度：（Q.rear+MaxSize-Q.front）%MaxSize。

出队入队时：指针都按顺时针方向进1。

图2 循环队列出入队示意图

根据我们前面所述，队空的时候：Q.front = Q.rear；那这样的话考虑一下队满的时候咋表示，顺着思路走，位指针要指向队尾的下一个，那不就是：Q.rear = Q.front 。这样不就队空队满无法区分了吗？

为了区分队空队满的情况，有以下三种处理方式：

牺牲一个单元来区分队空还是队满，如队时少用一个队列单元，约定以“队头指针在队尾指针的下一位置作为队满的标志”。如图16.2(d)所示。
队满：(Q.rear+1)%MaxSize == Q.front；

队空：Q.front == Q.rear。

队列中元素个数：(Q.rear - Q.front + MaxSize)%MaxSize。

类型中增设一个数据成员，专门记录队列中元素的个数。
类型中增设tag数据成员，以区分是队满还是队空。tag等于0时，若因删除导致Q.front == Q.rear，则为队空；tag等于1时，若因插入导致Q.front == Q.rear，则为队满。

（三）循环队列的操作

1、初始化

void InitQueue(SqQueue &Q)
{
    Q.rear = Q.front = 0;
}

2、判队空

bool isEmpty(SqQueue Q)
{
    if(Q.rear == Q.front)
        return true;
    return false;
}

3、入队

bool EnQueue(SqQueue &Q,ElemType x)
{
    if((Q.rear+1)%MaxSize == Q.front)
        return false;
    Q.data[Q.rear] = max;
    Q.rear = (Q.rear+1)%MaxSize;
    returrn true;
}

4、出队

bool DeQueue(SqQueue &Q,ElemType x)
{
    if(Q.rear == Q.front)
        return false;
    x = Q.data[Q.front];
    Q.front= (Q.front+1)%MaxSize;
    returrn true;
}