数据结构——【队列】知识介绍+基本操作代码

最新推荐文章于 2024-04-06 15:38:07 发布
最新推荐文章于 2024-04-06 15:38:07 发布
阅读量687 收藏
点赞数
文章标签： 数据结构 链表 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/x18037177724/article/details/129624260
版权
定义：
队列英文名称是Queue，是一种可以实现先进先出的存储结构。队列是在首尾两端进行操作，只能在一端 入队，另一端 出队。一般我们使用front，rear来表示队首和队尾；一般在队首进行删除元素，在队尾进行添加元素。
分类：
  1. 链式队列：用链表实现。
  1. 静态（顺序）队列：用数组实现。
注意事项：
  1. 使用静态队列通常是以循环的形式实现，而不是线性数组：原因是，如果使用线性数组，当有元素出队之后，因为入队是在队尾进行，所以前面的空间不能够再被利用，相当于前面的空间就是一次性的，这就造成了空间的浪费。
  2. 一个循环队列需要两个参数来确定：front，rear。这两个参数在不同情况之下的意义不太一样： ①队列初始化的时候，两个值都是0； ②队列非空的时候，front指向队列的第一个元素，rear指向队列最后一个元素的下一个位置； ③队列空的时候，front==rear，但不一定都等于0。
操作
新建队列
描述：
队列的初始情况是头指针和尾指针相等并且等于0，即Q->front==Q->rear==0。
入队操作
描述：
入队操作从队尾进行，每次一个元素入队都先把元素添加到队尾位置再把尾指针向上移动一位。
出队操作
描述：
出队操作从队首进行，每次一个元素出队都先把首位置元素删去，再把首指针向上移动一位。

顺序队列实现代码

#include <stdio.h>
#include <stdlib.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; 

//循环队列的顺序存储结构
typedef struct
{
    QElemType data[MAXSIZE];
    int front;       
    int rear;      
}SqQueue;


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

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

//若队列Q为空队列,则返回TRUR,否则返回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为新队尾元素
Status EnQueue(SqQueue *Q,QElemType e){
    
    //队列已满
    if((Q->rear+1)%MAXSIZE == Q->front)
        return ERROR;
    
    //将元素e赋值给队尾
    Q->data[Q->rear] = e;
    
    //rear指针向后移动一位,若到最后则转到数组头部;
    Q->rear = (Q->rear+1)%MAXSIZE;
    
    return OK;
}

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


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


int main(int argc, const char * argv[]) {
    // insert code here...
    printf("001--顺序队列表示与操作实现\n");
    
    Status j;
    int i=0,l;
    QElemType d;
    SqQueue Q;
    InitQueue(&Q);
    printf("初始化队列后，队列空否？%u(1:空 0:否)\n",QueueEmpty(Q));
    
    printf("入队:\n");
    while (i < 10) {
        EnQueue(&Q, i);
        i++;
    }
    QueueTraverse(Q);
    printf("队列长度为: %d\n",QueueLength(Q));
    printf("现在队列空否？%u(1:空 0:否)\n",QueueEmpty(Q));
    printf("出队:\n");
   
   //出队
    DeQueue(&Q, &d);
    printf("出队的元素:%d\n",d);
    QueueTraverse(Q);

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

链式队列的实现

#include <stdio.h>
#include <stdio.h>
#include <stdlib.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; 

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

typedef struct           
{
    QueuePtr front,rear; 
}LinkQueue;


//初始化队列
Status InitQueue(LinkQueue *Q){
    

    //头/尾指针都指向新生成的结点
    Q->front = Q->rear = (QueuePtr)malloc(sizeof(QNode));

    //2.判断是否创建新结点成功与否
    if (!Q->front) {
        return ERROR;
    }

    //3.头结点的指针域置空
    Q->front->next = NULL;
    
    return OK;
}


//销毁队列Q
Status DestoryQueue(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是否为空
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的新元素
Status EnQueue(LinkQueue *Q,QElemType e){
    
    //为入队元素分配结点空间,用指针s指向;
    QueuePtr s = (QueuePtr)malloc(sizeof(QNode));
    
    //判断是否分配成功
    if (!s) {
         return ERROR;
    }
    
    //将新结点s指定数据域.
    s->data = e;
    s->next = NULL;
    
    //将新结点插入到队尾
    Q->rear->next = s;
    
    //修改队尾指针
    Q->rear = s;
    
    return OK;
}


//出队列
Status DeQueue(LinkQueue *Q,QElemType *e){
    
    QueuePtr p;
    
    //判断队列是否为空;
    if (Q->front == Q->rear) {
        return ERROR;
    }
    
    //将要删除的队头结点暂时存储在p
    p = Q->front->next;
    
    //将要删除的队头结点的值赋值给e
    *e = p->data;
    
    //将原队列头结点的后继p->next 赋值给头结点后继
    Q->front->next = p ->next;
    
    //若队头就是队尾,则删除后将rear指向头结点.
    if(Q->rear == p) Q->rear = Q->front;
    
    free(p);
    
    return OK;
}

//获取队头元素
Status GetHead(LinkQueue Q,QElemType *e){
   
    //队列非空
    if (Q.front != Q.rear) {
        //返回队头元素的值,队头指针不变
        *e =  Q.front->next->data;
        return TRUE;
    }
    
    return  FALSE;
    
}

//遍历队列
Status QueueTraverse(LinkQueue Q){
    
    QueuePtr p;
    p = Q.front->next;
    while (p) {
        printf("%d ",p->data);
        p = p->next;
    }
    printf("\n");
    return OK;
}


int main(int argc, const char * argv[]) {
    // insert code here...
    printf("链队列的表示与操作!\n");
    
    Status iStatus;
    QElemType d;
    LinkQueue q;
    
    //初始化队列q
    iStatus = InitQueue(&q);
    
    //判断是否创建成
    if (iStatus) {
        printf("成功地构造了一个空队列\n");
    }
    
    //判断队列是否为空
    printf("是否为空队列?%d (1:是 0:否)\n",QueueEmpty(q));
    
    //获取队列的长度
    printf("队列的长度为%d\n",QueueLength(q));
    
    //插入元素到队列中
    EnQueue(&q, -3);
    EnQueue(&q, 6);
    EnQueue(&q, 12);
    
    printf("队列的长度为%d\n",QueueLength(q));
    printf("是否为空队列?%d (1:是 0:否)\n",QueueEmpty(q));
    
    //遍历队列
    printf("队列中的元素如下:\n");
    QueueTraverse(q);

    //获取队列头元素
    iStatus = GetHead(q, &d);
    if (iStatus == OK) {
        printf("队头元素是:%d\n",d);
    }
    
    //删除队头元素
    iStatus =DeQueue(&q, &d);
    if (iStatus == OK) {
        printf("删除了的队头元素为:%d\n",d);
    }
    
    //获取队头元素
    iStatus = GetHead(q, &d);
    if (iStatus == OK) {
        printf("新的队头元素为:%d\n",d);
    }
    
    //清空队列
    ClearQueue(&q);
    
    //销毁队列
    DestoryQueue(&q);
    
    
    
    return 0;
}
若东
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
队列的基本操作 源代码
03-25
/* 基础题 ⑴编写链接队列的基本操作函数。 ①进队操作 EnQueue(QUEUE **head,QUEUE **tail,int x) ②出队操作，队空 DeQueue(QUEUE **head,QUEUE **tail,int *cp) ③输出队列中元素 OutputQueue(QUEUE *head) ⑵调用上述函数 ①调用进队函数建立一个队列。 ②读取队列的第一个元数。 ③从队列中删除元数。 ④输出队列中的所有元数。 */ //允许插入的一端叫队尾（rear）,允许删除的一端叫队头（front） #include<stdio.h> #include<malloc.h> ………… ……
堆栈,队列基本操作代码
weixin_43911559的博客
08-11 331
目录堆栈的基本操作结构初始化判空进栈出栈读栈顶元素循环队列的基本操作结构初始化判空入队出队链式队列的基本操作结构初始化判空入队出队 堆栈的基本操作 结构 #define MaxSize 50 typedef int Elemtype; typedef struct{ //栈的顺序存储类型 Elemtype data[MaxSize]; int top; //栈顶指针,指向栈顶元素 }SqStack; typedef struct Linknode{ //栈的链式存储类型 El
C语言数据结构--队列 基本操作代码合集
最新发布
m0_70744482的博客
04-06 486
三段代码分别是队列的顺序存储，带头结点的链式存储队列，不带头结点的链式存储队列。都包括着初始化、判空、入队 、创建、出队、遍历操作，三段代码都是键入9999即输入结束，方便大家调试。
我与代码的日常：队列的基本操作（C语言版）
studyhardi的博客
03-17 358
#include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include &lt;assert.h&gt; typedef int QDataType; //链表节点 typedef struct QNode { QDataType val; struct QNode* next; }QNode; //队列 typedef struct Qu...
环型队列的基本操作 源代码
03-25
/* ⑶编写环型队列的基本操作函数 ①进队操作，返回1为队满 EnQueue(int *queue,int maxn,int *head,int *tail,int x) ②出队操作，返回1为队空 DeQueue(int *queue,int maxn,int *head,int *tail,int *cp) ③输出队列中元素 OutputQueue(int *quue,int maxn,int h,int t) ⑷调用上述函数实现下列操作，操作步骤如下： ①调用进队函数建立一个队列。 ②读取队列中的第一个元素。 ③从队列中删除元素。 ④输出队列中的所有元素。 */ #include<stdio.h> #include<malloc.h> #define MAXN 11 int EnQueue(int *queue,int maxn,int *head,int *tail,int x) { ………… ……
队列的基本操作c语言代码大全,数据结构――队列（循环队列）的基本操作（实现链队列逐一取出c语言代码）...
weixin_36221113的博客
05-17 217
队列队列是一种重要的线性结构，与栈相同也需要顺序表或者链表作为基础。队列是先进先出(first in first out)FIFO的线性表。所有数据从队列的一端进入，从另一端离开。队列中允许插入数据一端称队尾(rear)，允许数据离开的一端称队头(front)既可以是顺序表也可以是链表创建一个空队列入队列操作出队列操作实例分析/***********************************...
零基础征服数据结构算法Python版2023
04-14
分享一套python版的数据结构算法的视频教程——《零基础征服数据结构算法Python版》，2023年4月完结新课，提供配套的代码和课件下载！ 《零基础征服数据结构算法Python版》课程以985院校为授课标准，结合大厂面试所...
数据结构算法与应用-cpp语言描述.rar
10-21
本书在简要回顾了基本的C++程序设计概念的基础上，全面系统地介绍了队列、堆栈、树、图等基本数据结构，以及贪婪算法、分而治之算法、分枝定界算法等多种算法设计方法，为数据结构与算法的继续学习和研究奠定了一个...
谭浩强C语言程序设计，C++程序设计，严蔚敏数据结构，高一凡数据结构算法分析与实现.rar
06-13
*3.4.1 输入流与输出流的基本操作 *3.4.2 在输入流与输出流中使用控制符 3.4.3 用getchar和putchar函数进行字符的输入和输出 3.4.4 用scanf和printf函数进行输入和输出 3.5 编写顺序结构的程序 3.6 关系运算和逻辑...
AcWing算法基础课模板大全
07-14
数据结构 —— 代码模板链接 常用代码模板2——数据结构 链表与邻接表：树与图的存储 栈与队列：单调队列、单调栈 kmp Trie 并查集 堆 Hash表 搜索与图论 —— 代码模板链接 常用代码模板3——搜索与图论 DFS与BFS...
队列的基本操作
06-03
vs中实现队列的基本操作队列的进队、出队，返回队头，计算队列的大小
队列的定义及其基本操作
12-20
这是对队列的基本操作- **队列的定义** - **顺序队列及其操作** - **循环队列及其操作** - **链队列及其操作**
第四天-------队列的基本操作 附源码
可行的code
07-04 1225
一、 目的 1．掌握队列的思想及其存储实现。 2．掌握队列的常见算法的程序实现。 二、内容 1、内容 2、采用顺序存储实现循环队列的初始化、入队、出队操作。 3、采用链式存储实现队列的初始化、入队、出队操作。 4、在主函数中设计一个简单的菜单，分别测试上述算法。 5、*综合训练： 银行排队系统模拟:请用一个队列来模拟银行排队系统，队列中存储序号。请设置一个菜单，...
循环队列的基本操作
叶琼州的代码小窝
04-28 677
C++循环队列的基本操作
数据结构队列预习中需要注意的地方
zzl_2018122的博客
02-05 725
1. 队列的定义 队列是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。队列是一种先进先出的线性表。允许插入的一端称为队尾，允许删除的一端称为队头。 2. 队列的抽象数据类型 关于队列的操作有： (1) InitQueue(*Q):初始化操作，建立一个共队列Q (2) QueueEmpty(*Q):判断队列是否为空 (3) EnQueue(*Q,e):插入新元素到队列中并成为
数据结构伪代码的实现（队列篇）
Sword_demon的博客
06-11 1755
数据结构伪代码的实现（队列篇） 以循环队列为例 #include<stdio.h> #include<malloc.h> #include<stdbool.h> #define MAXSIZE 6 /* 定义数组最大长度 接下来有很多操作都是对MAXSIZE取余 这是一个循环队列 当队列满的时候需要 需要将队尾指向对头 例判断队列是否已满： if((pQ->rear+1)%MAXSIZE==pQ->fron
关于队列的操作注意事项
biao2488890051的博客
01-04 1225
这里是用链表实现的队列，主要注意一点，很难发现的隐形错误： // 1. 如果硬实时就绪队列前面的任务硬实时任务为挂起态，即已经执行完了，那么就从就绪队列里删除这个队首TAB if(IsEmpty(queueReadyHardTaskPtr)!=true) { for(i=0;i<queueReadyHardTaskPtr->Size;i+...
数据结构中队列基本操作的完整代码
03-25
以下是队列基本操作的完整代码： ``` #include #include // 队列结构体 typedef struct Queue { int front; // 队首指针 int rear; // 队尾指针 int size; // 队列大小 int *arr; // 队列数组指针 } Queue; ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

若东

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值