数据结构——队列（queue）

最新推荐文章于 2024-08-22 22:49:21 发布
最新推荐文章于 2024-08-22 22:49:21 发布
阅读量2.2w 收藏 104
点赞数 19
分类专栏： 算法 数据结构 文章标签： 数据结构 线性表 队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012736685/article/details/76584997
版权

队列（queue）

队列（queue）：只允许在一端进行插入操作，而在另一端进行删除操作的线性表。
队列是一种先进先出（First In First Out）的线性表，简称FIFO。
允许插入的一端称为队尾，允许删除的一端称为队头

1、抽象数据类型

ADT 队列(Queue)
Data
    同线性表。元素具有相同的类型，相邻元素具有前驱和后继关系。
Operation
    InitQueue(*Q)：       初始化操作，建立一个空队列Q。
    DestroyQueue(*Q)：    若队列Q存在，則销毀它。
    ClearQueue(*Q)：      将队列 Q 清空。
    QueueEmpty(Q)：       若队列Q为空，送回true,否則退回false。
    GetHead(Q, *e)：      若队列Q存在且非空，用e返因队列Q的队头元素。
    EnQueue(*Q,e)：       若队列Q存在，插入新元素e到队列Q中并成为队尾元素。
    DeQueue(*Q, *e)：     刪除队列Q中队头元素，并用e返回其值。
    QueueLength(Q)：      送回队列Q的元素个教。
endADT

2、循环队列（顺序队列）

下图为队列的假溢出示意图，即下标 0 和 1 的位置还是空闲的，然而指向队尾的指针rear已经出现了数组越界的错误。为了避免这种情况，一般顺序队列也指循环队列。
假溢出

循环队列：采用环状顺序表来存放队列元素，并用两个指针，其中 front 指针指向队列的队头元素，rear指针指向队尾元素的下一个位置，往队列中加进或取出元素时分别改变这两个变量的计数。当头尾指针（front / rear）指向队列尾的元素（下标：QueueSize-1）时，其加1操作的结果是指向向量的下界0。

2.1 特殊情况的判定——空\满队列

  当队列为空或者满的时候都会出现 front == rear 的情况，即无法通过条件 front == rear 来判别队列是”空”还是”满”。

解决这个问题的方法至少有三种：
　　① 另设一布尔变量或标志变量以区别队列的空和满；
　　② 保留一个元素空间。约定入队前，测试对尾指针 rear 在循环意义下加1后是否等于 front，若相等则认为队满（注意：rear所指的单元始终为空），此时判空条件仍是 front == rear，判满条件改变；
　　③使用一个计数器记录队列中元素的总数（即队列长度）。
　　
　　下文针对②进行讨论。

2.2 实现

队列空的条件：
                  front == rear
队列满的条件：
         （rear + 1）% QueueSize == front
  其中，rear为指向队尾元素的下一位置的指针，front 为指向队头元素的指针。QueueSize为队列的最大长度。

通用计算队列长度公式：
     （rear - front + QueueSize） % QueueSize

代码实现

注意：传参的形式传址还是传实体对象，实体对象需要用实心点来指向成员，所以判断条件写成 Q.front==Q.rear；传址则为Q->front == Q->rear

#include "stdio.h"    
#include "stdlib.h"   
#include "io.h"  
#include "math.h"  
#include "time.h"

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAXSIZE 20 /* 存储空间初始分配量 */

typedef int Status; 
typedef int QElemType; /* QElemType类型根据实际情况而定，这里假设为int */

/* 循环队列的顺序存储结构 */
typedef struct
{
    QElemType data[MAXSIZE];
    int front;      /* 头指针 */
    int rear;       /* 尾指针，若队列不空，指向队列尾元素的下一个位置 */
}SqQueue;

Status visit(QElemType c)
{
    printf("%d ",c);
    return OK;
}

/* 初始化一个空队列Q */
Status InitQueue(SqQueue *Q)
{
    Q->front=0;
    Q->rear=0;
    return  OK;
}

/* 将Q清为空队列 */
Status ClearQueue(SqQueue *Q)
{
    Q->front=Q->rear=0;
    return OK;
}

/* 若队列Q为空队列,则返回TRUE,否则返回FALSE */
Status QueueEmpty(SqQueue Q)
{ 
    if(Q.front==Q.rear) /* 队列空的标志 */
        return TRUE;
    else
        return FALSE;
}

/* 返回Q的元素个数，也就是队列的当前长度 */
int QueueLength(SqQueue Q)
{
    return  (Q.rear-Q.front+MAXSIZE)%MAXSIZE;
}

/* 若队列不空,则用e返回Q的队头元素,并返回OK,否则返回ERROR */
Status GetHead(SqQueue Q,QElemType *e)
{

    if(Q.front==Q.rear) /* 队列空 */
        return ERROR;
    *e=Q.data[Q.front];
    return OK;
}

/* 若队列未满，则插入元素e为Q新的队尾元素 */
Status EnQueue(SqQueue *Q,QElemType e)
{
    if ((Q->rear+1)%MAXSIZE == Q->front)    /* 队列满的判断 */
        return ERROR;
    Q->data[Q->rear]=e;         /* 将元素e赋值给队尾 */
    Q->rear=(Q->rear+1)%MAXSIZE;/* rear指针向后移一位置， */
                                /* 若到最后则转到数组头部 */
    return  OK;
}

/* 若队列不空，则删除Q中队头元素，用e返回其值 */
Status DeQueue(SqQueue *Q,QElemType *e)
{
    if (Q->front == Q->rear)            /* 队列空的判断 */
        return ERROR;
    *e=Q->data[Q->front];               /* 将队头元素赋值给e */
    Q->front=(Q->front+1)%MAXSIZE;  /* front指针向后移一位置， */
                                    /* 若到最后则转到数组头部 */
    return  OK;
}

/* 从队头到队尾依次对队列Q中每个元素输出 */
Status QueueTraverse(SqQueue Q)
{ 
    int i;
    i=Q.front;
    while((i+Q.front)!=Q.rear)
    {
        visit(Q.data[i]);
        i=(i+1)%MAXSIZE;
    }
    printf("\n");
    return OK;
}

int main()
{
    Status j;
    int i=0,l;
    QElemType d;
    SqQueue Q;
    InitQueue(&Q);
    printf("初始化队列后，队列空否？%u(1:空 0:否)\n",QueueEmpty(Q));

    printf("请输入整型队列元素(不超过%d个),-1为提前结束符: ",MAXSIZE-1);
    do
    {
        /* scanf("%d",&d); */
        d=i+100;
        if(d==-1)
            break;
        i++;
        EnQueue(&Q,d);
    }while(i<MAXSIZE-1);

    printf("队列长度为: %d\n",QueueLength(Q));
    printf("现在队列空否？%u(1:空 0:否)\n",QueueEmpty(Q));
    printf("连续%d次由队头删除元素,队尾插入元素:\n",MAXSIZE);
    for(l=1;l<=MAXSIZE;l++)
    {
        DeQueue(&Q,&d);
        printf("删除的元素是%d,插入的元素:%d \n",d,l+1000);
        /* scanf("%d",&d); */
        d=l+1000;
        EnQueue(&Q,d);
    }
    l=QueueLength(Q);

    printf("现在队列中的元素为: \n");
    QueueTraverse(Q);
    printf("共向队尾插入了%d个元素\n",i+MAXSIZE);
    if(l-2>0)
        printf("现在由队头删除%d个元素:\n",l-2);
    while(QueueLength(Q)>2)
    {
        DeQueue(&Q,&d);
        printf("删除的元素值为%d\n",d);
    }

    j=GetHead(Q,&d);
    if(j)
        printf("现在队头元素为: %d\n",d);
    ClearQueue(&Q);
    printf("清空队列后, 队列空否？%u(1:空 0:否)\n",QueueEmpty(Q));
    return 0;
}

3、队列的链式存储结构（链队列）及实现

3.1 链队列定义

队头指针( front )指向链队列的头结点，而队尾指针( rear )指向终端结点。非空链队列如下所示。
非空链队列
当队列为空时，front和rear都指向头结点。
空链队列

结构如下：
#include "stdio.h"

/* QElemType类型根据实际情况而定，这里假设为int */
typedef int QElemType;

typedef struct QNode    /* 结点结构 */
{
    QElemType data;
    struct QNode *next;
} QNode,*QueuePtr;

typedef struct          /* 队列的链表结构 */
{
    QueuePtr front,rear; /* 队头、队尾指针 */
} LinkQueue;

int main()
{
    return 0;
}

3.2 入队操作

步骤：
1、根据图，我们先创建一个结点s，QueuePtr s=(QueuePtr)malloc(sizeof(QNode));
2、然后给s的data域赋值e，指针域next赋值null。s->data=e;s->next=NULL; 目的就是让它成为新任队尾元素。
3、前任队尾元素呢？直接让它的指针域指向s就行了。Q->rear->next=s;
4、别忘了把队尾指针重新指向新任队尾s。Q->rear=s;
插入操作

3.3 出队操作

一般情况：
这里写图片描述
如果链队列只剩下一个元素的时候，出队则如下图：
这里写图片描述

3.4 实现

#include "stdio.h"    
#include "stdlib.h"   
#include "io.h"  
#include "math.h"  
#include "time.h"

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAXSIZE 20 /* 存储空间初始分配量 */

typedef int Status; 

typedef int QElemType; /* QElemType类型根据实际情况而定，这里假设为int */

typedef struct QNode    /* 结点结构 */
{
   QElemType data;
   struct QNode *next;
}QNode,*QueuePtr;

typedef struct          /* 队列的链表结构 */
{
   QueuePtr front,rear; /* 队头、队尾指针 */
}LinkQueue;



Status visit(QElemType c)
{
    printf("%d ",c);
    return OK;
}

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

/* 销毁队列Q */
Status DestroyQueue(LinkQueue *Q)
{
    while(Q->front)
    {
         Q->rear=Q->front->next;
         free(Q->front);
         Q->front=Q->rear;
    }
    return OK;
}

/* 将Q清为空队列 */
Status ClearQueue(LinkQueue *Q)
{
    QueuePtr p,q;
    Q->rear=Q->front;
    p=Q->front->next;
    Q->front->next=NULL;
    while(p)
    {
         q=p;
         p=p->next;
         free(q);
    }
    return OK;
}

/* 若Q为空队列,则返回TRUE,否则返回FALSE */
Status QueueEmpty(LinkQueue Q)
{ 
    if(Q.front==Q.rear)
        return TRUE;
    else
        return FALSE;
}

/* 求队列的长度 */
int QueueLength(LinkQueue Q)
{ 
    int i=0;
    QueuePtr p;
    p=Q.front;
    while(Q.rear!=p)
    {
         i++;
         p=p->next;
    }
    return i;
}

/* 若队列不空,则用e返回Q的队头元素,并返回OK,否则返回ERROR */
Status GetHead(LinkQueue Q,QElemType *e)
{ 
    QueuePtr p;
    if(Q.front==Q.rear)
        return ERROR;
    p=Q.front->next;
    *e=p->data;
    return OK;
}


/* 插入元素e为Q的新的队尾元素 */
Status EnQueue(LinkQueue *Q,QElemType e)
{ 
    QueuePtr s=(QueuePtr)malloc(sizeof(QNode));
    if(!s) /* 存储分配失败 */
        exit(OVERFLOW);
    s->data=e;
    s->next=NULL;
    Q->rear->next=s;    /* 把拥有元素e的新结点s赋值给原队尾结点的后继，见图中① */
    Q->rear=s;      /* 把当前的s设置为队尾结点，rear指向s，见图中② */
    return OK;
}

/* 若队列不空,删除Q的队头元素,用e返回其值,并返回OK,否则返回ERROR */
Status DeQueue(LinkQueue *Q,QElemType *e)
{
    QueuePtr p;
    if(Q->front==Q->rear)
        return ERROR;
    p=Q->front->next;       /* 将欲删除的队头结点暂存给p，见图中① */
    *e=p->data;             /* 将欲删除的队头结点的值赋值给e */
    Q->front->next=p->next;/* 将原队头结点的后继p->next赋值给头结点后继，见图中② */
    if(Q->rear==p)      /* 若队头就是队尾，则删除后将rear指向头结点，见图中③ */
        Q->rear=Q->front;
    free(p);
    return OK;
}

/* 从队头到队尾依次对队列Q中每个元素输出 */
Status QueueTraverse(LinkQueue Q)
{
    QueuePtr p;
    p=Q.front->next;
    while(p)
    {
         visit(p->data);
         p=p->next;
    }
    printf("\n");
    return OK;
}

int main()
{
    int i;
    QElemType d;
    LinkQueue q;
    i=InitQueue(&q);
    if(i)
        printf("成功地构造了一个空队列!\n");
    printf("是否空队列？%d(1:空 0:否)  ",QueueEmpty(q));
    printf("队列的长度为%d\n",QueueLength(q));
    EnQueue(&q,-5);
    EnQueue(&q,5);
    EnQueue(&q,10);
    printf("插入3个元素(-5,5,10)后,队列的长度为%d\n",QueueLength(q));
    printf("是否空队列？%d(1:空 0:否)  ",QueueEmpty(q));
    printf("队列的元素依次为：");
    QueueTraverse(q);
    i=GetHead(q,&d);
    if(i==OK)
     printf("队头元素是：%d\n",d);
    DeQueue(&q,&d);
    printf("删除了队头元素%d\n",d);
    i=GetHead(q,&d);
    if(i==OK)
        printf("新的队头元素是：%d\n",d);
    ClearQueue(&q);
    printf("清空队列后,q.front=%u q.rear=%u q.front->next=%u\n",q.front,q.rear,q.front->next);
    DestroyQueue(&q);
    printf("销毁队列后,q.front=%u q.rear=%u\n",q.front, q.rear);

    return 0;
}
__盛夏光年__
关注
专栏目录
数据结构——队列
张许平的博客
04-30 421
队列也是一种数据结构，今天我们主要学习几种基本的队列，然后学习下队列在线程池中的应用。 1. 什么是队列？ 队列具有“先进先出，后进后出”的特点。支持操作的也有限，最基本的操作也只有两种： 入队enqueue()：放一个数据到队列尾部 出队dequeue()：从队列头部取出一个元素 从上图可以看出，队列和栈一样，都是操作受限的线性表数据结构。 队列作为一种非常基础的数据结构，应用...
数据结构——队列（queue）（普通方法+STL）（c++）
Passerby_XX的博客
02-15 2219
（蒟蒻的第一篇文章，希望dalao勿喷） （希望没问题） 声明： 1.本人变量定义的名称很low 2.本人用的方法也很low 3.但我觉得文章应该不low （盲目自信） 第一篇文章讲讲队列 队列（个人理解）：差不多是你在快餐店买饭，但你去结账的时候，发现收银台变成了移动的，所有顾客排成一条队，“收银台”从前往后移动，顾客只需要站在那里等“收银台”就行了，而这个“收银台”就是队列 但队列有一个问题，就是因为“顾客”不动，所以付完钱的“顾客”的位置就空出来了，这导致快餐店的空间要很大（数组要开大
数据结构——队列的讲解（超详细）
effort123_的博客
08-15 558
我们在之前刚讲述完对于栈的讲解，下面我们在讲另一个类似栈的数据结构——队列，它们都是线性表，但结构是大有不同，下面我们直接进入讲解！
数据结构之队列
最新发布
weixin_74772510的博客
08-22 2388
不会吧不会吧，不会有人不会队列吧......
数据结构：队列
soulmate______的博客
04-08 1119
队列 队列的定义与操作 队列queue的定义：入队在一端（队尾）进行而出队在另一端（队首）进行的线性表。即：先进先出的线性表 队列的操作 入队操作：将数据元素值插入队尾 出队操作：移除队首的数据元素 是否为空：判断队中是否包含数据元素 得到队长：获取队中实际包含数据元素的个数 清空操作：移除队中的所有数据元素 获取队首元素 //interface using System; using ...
数据结构韩顺平版（2）
qq_24573381的博客
04-08 308
队列 1.队列的一个使用场景 银行排队的案例: 2、队列介绍 1) 队列是一个有序列表，可以用数组或是链表来实现。 2) 遵循先入先出的原则。即：先存入队列的数据，要先取出。后存入的要后取出 3) 示意图：(使用数组模拟队列示意图) 3、数组模拟队列思路 队列本身是有序列表，若使用数组的结构来存储队列的数据，则队列数组的声明如下图, 其中 maxSize 是该队 列的最大容量。  因为队列的输出、输入是分别从前后端来处理，因此需要两个变量 front 及 ..
c++之数据结构——队列(queue)
weixin_45726901的博客
07-07 2984
关于队列的基本概念以及基本操作的c++实现队列的定义队列的基本理论队列的图解队列的基本操作队列的三种形式及其c++实现(以整型为例)-顺序队列 队列的定义 队列是一种最基本的数据结构，是一种只能在一端插入，另一端删除的特殊的线性表。 队列的基本理论 进行插入操作的一端称为队尾(rear)，进行删除操作的端称为队头(front)。 队列的插入操作叫做入队，删除操作叫做出队。 队列的特点：先进先出，故队列又称为先进先出（FIFO—first in first out）线性表。 队列的图解 每次出队时，队头
数据结构—— 队列基础
m0_59897687的博客
10-11 595
一、队列概述 队列是一种先入先出（FIFO 即 first input first output）的数据结构 在FIFO数据结构中，首先处理添加到队列中的第一个元素 如上图所示 新的元素会被插入在队列的末尾，该操作被称为“入队”（enqueue），即插入（insert）操作 删除元素时只能删除队列的第一个元素，该操作被称为“出队”（dequeue），即删除（delete）操作 二、操作实现 队列数据定义 类型 描述 enqueue(方法) ...
JavaScript数据结构——队列（Queue）
瓜冬瓜的博客
06-21 948
概念和结构 队列是一种先进先出（FIFO）的数据结构。 队列的第一个元素所在位置称为队头，最后一个元素所在位置称为队尾。 不包含任何元素的队列称为空队列。 队列的操作 队列有五种常用操作，分别为 入队 enqueue（element） 出队 dequeue（） 检查队头元素 front（） 检查队列是否为空 isEmpty（） 获取队列的长度 size（） JS实现 JS里面的队列结构也...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值