数据结构之队列（链式队列）的基本操作与实现

最新推荐文章于 2024-09-25 18:39:17 发布
最新推荐文章于 2024-09-25 18:39:17 发布
阅读量2.2w 收藏 353
点赞数 69
分类专栏： 数据结构 文章标签： 数据结构 队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baoitcore/article/details/121315166
版权
本文详细介绍了链式队列的概念和基本操作，包括初始化、判断队列是否为空、获取队列长度、入队、出队、获取队首元素等。通过C语言实现了一个链式队列的数据结构，并展示了主函数的运行结果，帮助读者理解链式队列的工作原理。
摘要由CSDN通过智能技术生成

这篇文章的末尾有完整的实现代码，书写不易，转载请附上本文章链接。

目录

一、链式队列的概念

二、链式队列的基本操作

（1）、链队的初始化

（2）、判断链队是否为空

（3）、求链队列的长度 

（4）、入队操作

（5）、求链队首元素

（6）、出队操作

（7）、主函数

（8）、运行结果

（9）、完整代码

一、链式队列的概念

         何为链式队列，想到链式队列大家应该都会想到顺序表的单链表的基本操作，我们来对比一下：单链表是用一个头指针或者是尾指针来实现元素的插入和删除等，即头插法和尾插法。而链式队列呢，我们都知道队列是一个在队首进行出队再队尾进行入队，而不是在一段完成任务，所以我们这里就需要两个指针分别指向队列的头front和尾rear，他们两个各司其职，当要进行出队操作时，头指针front说了算，当要进行入队操作时，尾指针rear说了算。

约束条件：我们把头指针指向队列中第一个元素的前一个位置，它里面不存东西，他只是一个标记，标记着它指向了一个队列，通过它可以找到这个队列，就像是单链表的头插法；而尾指针指向队列的最后一个元素。

二、链式队列的基本操作

         熟悉了链式队列的概念之后，我们就可定义链式队列的基本操作了，操作并不局限于我说的这些，根据实际情况，定义所需的操作。

（1）、链队的初始化

（2）、判断链队是否为空

（3）、求链队列的长度

（4）、入队操作

（5）、出队操作

（6）、求链队首元素 ，（我们也可以求链队的队尾元素）

三、基本操作的具体实现步骤

        首先声明一个队列节点结构体，结构体里包括这个节点的指针域next和数据域data。再声明一个队列结构体，包括指向这个队列的头指针front和尾指针rear。

#include <stdio.h>
#include <stdlib.h>
typedef int Elemtype;
//声明一个结构体来表示节点
typedef struct Node
{
     Elemtype data;   //节点数据域
     struct Node * next; //节点指针域
}QueueNode;
//声明一个结构体来定义上面这个结构体的两个指针
typedef struct
{
    QueueNode *front,*rear;//分别指向队首和队尾的指针
}LinkQueue;

（1）、链队的初始化

当前的链队是一个空的队，所以头指针尾指针和节点指针都指向同一个地方，指向空。

//首先进行初始化
void Init(LinkQueue *s)
{
    QueueNode * p;
    p=(QueueNode*)malloc(sizeof(QueueNode));//为指向节点的指针分配空间
    p->next=NULL;
    s->front=s->rear=p;     
}

（2）、判断链队是否为空

         因为我们在初始化的时候定义的头指针和尾指针指向同一个位置标记为空，所以我们就判断是否它们指向同一个地方。

//判断队列是否为空,为空返回真1，不为空返回假0
int Empty(LinkQueue s)
{
    //队空的条件是头指针和尾指针指向相同的地方
    if(s.front==s.rear)
    {
        return 1;
    }
    return 0;
}

（3）、求链队列的长度 

        我们就声名一个临时的节点类型的指针变量p，让它指向链队的第一个节点，在声明一个变量记录长度，当p指向的节点不为空时，就让长度增加一，同时，指针p也向后移动一个位置。

//求队列长度
int GetLength(LinkQueue s)
{
    //声明一个节点类型的指针
    QueueNode *p;
    //让p指向队列的头指针
    p=s.front;
    //声明一个变量用来记录队列当前长度
    int length=0;
    while(p->next)//当指针p所指的节点不为空时执行循环体
    {
        length++;
        p=p->next;
    }
    return length;//返回当前队列的长度
}

（4）、入队操作

          我们在文章开头说过，入队操作由队尾指针rear决定。我们声明一个节点类型的指针变量p，为它分配空间，然后将要入队的元素赋值给它，然后将rear指针指向这个节点，之后rear指针向后移动一位。这和顺序链表的尾插法的操作很类似，大家可以对比一下，思想是一样的。

//入队操作
 void Add(LinkQueue *s,Elemtype x)
 {
     //声明一个节点类型的指针变量用来存储要入队的元素
     QueueNode *p;
     p=(QueueNode*)malloc(sizeof(QueueNode));
     if(!p){
        printf("内存分配失败\n\n");
        return;
     }
     p->data=x;        //指针指向的节点的数据域存放x
     p->next=NULL;     //指针指向的节点的指针域置为空
     s->rear->next=p;   //将队列的尾指针的指针域next指向指针p所指的节点
     s->rear=p;         //将队列的尾指针向后移一位，指向刚入队的节点的位置
 }

（5）、求链队首元素

           我们这里只求了队首元素，没有求队尾元素。在求队首元素时，我们要判断一下队是否为空队列。如果不为空了我们再进行求队首元素的操作。直接返回头指针front指向的第一个元素的值。

 //获取队首元素
 Elemtype GetTop(LinkQueue s)
 {
     //首先判断队列是否为空
     if(Empty(s))
     {
         printf("队列为空，无法获取队首元素\n\n");
         return 0;
     }
     return s.front->next->data;//不为空的话就返回队首指针指向的第一个元素的数据域
 }

（6）、出队操作

       出队操作由队首指针front决定。我们要判断一下队是否为空队列。我们声明一个节点类型的指针变量p，将它指向队首元素的第一个节点的位置。然后让e记录下当前出队的元素的值。将队首指针指向第一个节点的下一个节点。这和顺序链表的头插法的删除操作很类似。要记着释放指向出队节点的指针。

 //出队操作
 void Del(LinkQueue *s,Elemtype *e)
 {
     //先判断队列是否为空
     if(Empty(*s))
     {
         printf("当前队列为空，无法执行出队操作\n\n");
         return;
     }
     //用临时变量保存出队的元素
     QueueNode *p;
     p=s->front->next;
     if(p==s->rear)    //如果p指向了队尾节点
     {
         s->front=s->rear;  //那么删除之后队首指针和尾指针指向同一个位置
     }
     *e=p->data;
     s->front->next=p->next;//将队首指针指向第一个节点的下一个节点。
     free(p);

 }

（7）、主函数

int main()
{
    //声明一个节点类型的变量
    Elemtype e;
    //声明一个顺序队名字为s
    LinkQueue s;
    //对这个顺序队进行初始化
    Init(&s);
    printf("==============================================================\n");
    printf("当前队列是否为空,为空返回真1，不为空返回假0：%d\n\n",Empty(s));
    printf("当前队列的长度为：%d\n\n",GetLength(s));
    //执行入队操作
    Add(&s,5);
    Add(&s,4);
    Add(&s,6);
    Add(&s,2);
    printf("==============================================================\n");
    printf("当前队列是否为空,为空返回真1，不为空返回假0：%d\n\n",Empty(s));
    printf("当前队列的长度为：%d\n\n",GetLength(s));
    //获取当前队首元素
    printf("==============================================================\n");
    e=GetTop(s);
    if(e){
        printf("当前队列的队首元素为：%d\n\n",e);
    }
    //执行出队操作
    printf("==============================================================\n");
    Del(&s,&e);
    printf("出队的元素为：%d，当前队列的长度为：%d\n\n",e,GetLength(s));
    //获取当前队首元素
    e=GetTop(s);
    if(e){
        printf("当前队列的队首元素为：%d\n\n",e);
    }

    //再执行一次出队操作
    printf("==============================================================\n");
    Del(&s,&e);
    printf("出队的元素为：%d，当前队列的长度为：%d\n\n",e,GetLength(s));
    //获取当前队首元素
    e=GetTop(s);
    if(e){
        printf("当前队列的队首元素为：%d\n\n",e);
    }
    //再执行一次出队操作
    printf("==============================================================\n");
    Del(&s,&e);
    printf("出队的元素为：%d，当前队列的长度为：%d\n\n",e,GetLength(s));
    //获取当前队首元素
    e=GetTop(s);
    if(e){
        printf("当前队列的队首元素为：%d\n\n",e);
    }
    return 0;
}

（8）、运行结果

（9）、完整代码

#include <stdio.h>
#include <stdlib.h>
typedef int Elemtype;
//声明一个结构体来表示节点
typedef struct Node
{
     Elemtype data;   //节点数据域
     struct Node * next; //节点指针域
}QueueNode;
//声明一个结构体来定义上面这个结构体的两个指针
typedef struct
{
    QueueNode *front,*rear;//分别指向队首和队尾的指针
}LinkQueue;
//首先进行初始化
void Init(LinkQueue *s)
{
    QueueNode * p;
    p=(QueueNode*)malloc(sizeof(QueueNode));
    p->next=NULL;
    s->front=s->rear=p;
}
//判断队列是否为空,为空返回真1，不为空返回假0
int Empty(LinkQueue s)
{
    //队空的条件是头指针和尾指针指向相同的地方
    if(s.front==s.rear)
    {
        return 1;
    }
    return 0;
}
//求队列长度
int GetLength(LinkQueue s)
{
    //声明一个节点类型的指针
    QueueNode *p;
    //让p指向队列的头指针
    p=s.front;
    //声明一个变量用来记录队列当前长度
    int length=0;
    while(p->next)//当指针p所指的节点不为空时执行循环体
    {
        length++;
        p=p->next;
    }
    return length;//返回当前队列的长度
}
//入队操作
 void Add(LinkQueue *s,Elemtype x)
 {
     //声明一个节点类型的指针变量用来存储要入队的元素
     QueueNode *p;
     p=(QueueNode*)malloc(sizeof(QueueNode));
     if(!p){
        printf("内存分配失败\n\n");
        return;
     }
     p->data=x;        //指针指向的节点的数据域存放x
     p->next=NULL;     //指针指向的节点的指针域置为空
     s->rear->next=p;   //将队列的尾指针的指针域next指向指针p所指的节点
     s->rear=p;         //将队列的尾指针向后移一位，指向刚入队的节点的位置
 }
 //获取队首元素
 Elemtype GetTop(LinkQueue s)
 {
     //首先判断队列是否为空
     if(Empty(s))
     {
         printf("队列为空，无法获取队首元素\n\n");
         return 0;
     }
     return s.front->next->data;//不为空的话就返回队首指针指向的第一个元素的数据域
 }
 //出队操作
 void Del(LinkQueue *s,Elemtype *e)
 {
     //先判断队列是否为空
     if(Empty(*s))
     {
         printf("当前队列为空，无法执行出队操作\n\n");
         return;
     }
     //用临时变量保存出队的元素
     QueueNode *p;
     p=s->front->next;
     if(p==s->rear)
     {
         s->front=s->rear;
     }
     *e=p->data;
     s->front->next=p->next;
     free(p);

 }
int main()
{
    //声明一个节点类型的变量
    Elemtype e;
    //声明一个顺序队名字为s
    LinkQueue s;
    //对这个顺序队进行初始化
    Init(&s);
    printf("==============================================================\n");
    printf("当前队列是否为空,为空返回真1，不为空返回假0：%d\n\n",Empty(s));
    printf("当前队列的长度为：%d\n\n",GetLength(s));
    //执行入队操作
    Add(&s,5);
    Add(&s,4);
    Add(&s,6);
    Add(&s,2);
    printf("==============================================================\n");
    printf("当前队列是否为空,为空返回真1，不为空返回假0：%d\n\n",Empty(s));
    printf("当前队列的长度为：%d\n\n",GetLength(s));
    //获取当前队首元素
    printf("==============================================================\n");
    e=GetTop(s);
    if(e){
        printf("当前队列的队首元素为：%d\n\n",e);
    }
    //执行出队操作
    printf("==============================================================\n");
    Del(&s,&e);
    printf("出队的元素为：%d，当前队列的长度为：%d\n\n",e,GetLength(s));
    //获取当前队首元素
    e=GetTop(s);
    if(e){
        printf("当前队列的队首元素为：%d\n\n",e);
    }

    //再执行一次出队操作
    printf("==============================================================\n");
    Del(&s,&e);
    printf("出队的元素为：%d，当前队列的长度为：%d\n\n",e,GetLength(s));
    //获取当前队首元素
    e=GetTop(s);
    if(e){
        printf("当前队列的队首元素为：%d\n\n",e);
    }
    //再执行一次出队操作
    printf("==============================================================\n");
    Del(&s,&e);
    printf("出队的元素为：%d，当前队列的长度为：%d\n\n",e,GetLength(s));
    //获取当前队首元素
    e=GetTop(s);
    if(e){
        printf("当前队列的队首元素为：%d\n\n",e);
    }
    return 0;
}

总结：学到这里对比一下顺序表，栈，队，有很多相同之处，各自又拥有自己的独特之处，结合我的前几篇关于数据结构的文章大家可以自己对比一下。

请尊重劳动成果，转载请注明原文链接和出处。

术业还未专攻
关注
专栏目录
链式队列的基本运算
09-03
本程序共设计了单链表上多项式相加需要的的6个基本操作运算，分别是链式队列的入队，出队，遍历，长度，取队头，以及销毁队列操作。附带实验报告。
链队列的基本操作和实现
11-22
链队列的基本操作和实现链队列的基本操作和实现
链式队列深潜：掌握数据流动的秘密
平凡程序猿~的博客
09-25 1148
队列是一种广泛应用于计算机科学的数据结构，具有先进先出（FIFO）的特性。在许多实际应用中，例如任务调度、缓冲区管理等，队列扮演着重要角色。本文将详细介绍队列的基本概念，并通过链表实现一个简单的队列。
数据结构--链式队列
09-12
1、实现顺序堆栈相关API函数 2、泛型编程思想 3、实体数据可以是基本类型或者复合类型 4、遍历时，使用回调函数。实现“策略”与“机制”分离 5、使用动态内存，保存链表节点及用户数据
【数据结构】 链队列的基本操作 （C语言版）
weixin_56814370的博客
01-24 3583
【数据结构】 链队列的基本操作 （C语言版）
链式队列的基本操作（详细）
qq_43346784的博客
07-08 8333
队列的基本操作（）链式 ，详细
链队列的基本操作
weixin_47881191的博客
12-09 3770
1、初始化一个链队列，输入队列元素； 2、对已建立的链队列实现遍历队列、求队列长度、队列的判空、获取队头队尾元素、队列的入队出队等操作。 3、最好用菜单形式对应各个操作，使其编程一个完整的小软件。 参考界面： #include<stdio.h> #include<stdlib.h> #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 #define OVERFLOW 0 #define MAXQSIZE 100
链式队列基本操作
LingXiaokai的博客
04-29 1232
/*链式队列:使用链节点管理数据成员(C语言实现版)*/ /*特点: 动态变长，使用链表作为基本数据结构: 头结点-->对头-->.....-->队尾 不存在伪溢出的问题，长度没有限制，但是插入和删除节点的时间代价较高(动态分配空间)*/ #include #include /*定义一个链表节点作为基本数据结构*/ typedef struct node { int dat
【数据结构复习自用】链式队列的基本操作
ckyl6178的博客
05-11 308
队列常见的基本操作 InitQueue(&Q) //初始化队列，构造一个空队列Q QueueEmpty(Q) //判队列空，若空返回true，不空返回false EnQueue(&Q,x) //入队，若Q未满，将x加入，使之成为新的队尾 DeQueue(&Q,&x) //出队，若Q非空，删除队头元素，并用x返回 GetHead(Q,&x) //读队头元素，若Q非空，将队头元素赋值给x //栈和队列是受限制的线性表，所以不是任何对线性表的操作都适用于栈和队列，
C++数据结构之链式队列实现
09-20
链式队列与数组实现的队列相比，优点在于动态扩展能力，它不需要预先确定队列的大小。 ### 2. 链式队列的节点结构 链式队列通常由一系列节点组成，每个节点包含一个数据域和一个指针域。在C++中，可以定义一个...
djb.rar_C++_c 循环 队列_数据队列_链式队列_队列 数据结构
09-23
3. **链式队列**：链式队列使用链表作为底层数据结构，每个元素（节点）包含数据和指向下一个元素的指针。链式队列的优势在于动态扩展性，无需预先确定大小，可以根据需要动态添加或删除节点。因此，链式队列在处理...
C++ 循环队列和链式队列的实现 数据结构 类模板
02-04
1. Queue.hpp是队列的基类，只定义基本操作，具体实现在另外两个hpp文件中 2. seqQueue.hpp是循环队列的实现 3. linkQueue.hpp是链式队列的实现 4. test.cpp是简单的测试文件，main函数在这里面
链式的队列的创建、插入、删除、遍历、取队首元素
Zhang_Yi_Lan的博客
10-24 9064
链式的队列的创建、插入、删除、遍历、取队首元素上午操作。 我们今天将的方式是比较简单的方式，没有动态的分配空间。#include <stdio.h> typedef struct { int queue[100]; int front; int rear; } sqqueue; //创建一个空的队列 int initqueue(sqqueue *sq) { if(s
C++ 链队列和循环队列基本操作
nichengwuxiao的博客
12-21 6259
一：目的 1. 用C++实现链队列的基本操作 2. 用C++实现循环队列的基本操作 二：链队列的实现 1. 定义数据结构和类，书写在Queue.h中 # include using namespace std; typedef int ElemType; typedef struct QNode { ElemType data; QNode *n
链式队列的基本操作
人生代码 ---- 公众号
06-07 498
1 创建队列 struct QUEUE * CreateQueue(void); 2 判对空 int QueueEmpty(struct QUEUE *); 3 入栈 struct NODE * EnQueue(struct NODE *rear); 4 输出整栈 void OutputQueue(struct QUEUE *); 5 取队列头元素 void GetTop(struct N...
数据结构-链队列的基本操作
西风的博客
11-09 747
//链队列的基本操作 #include using namespace std; typedef char elemtype; typedef struct queuelist { elemtype data; struct queuelist*next; }node;//链队数据结点的类型 typedef struct { node*front; node*rear; }linkque
【队列】链式结构实现队列的基本操作
OnePower
07-02 4331
链队列 队列的链式存储结构简称为链队列，它是限制仅在表头删除和表尾插入的单链表。 显然仅有单链表的头指针不便于在表尾做插入操作，为此再增加一个尾指针，指向链表的最后一个结点。于是，一个链队列由一个头指针唯一确定。 #include #include #include #define error(s) printf("%s", s) typedef char datatype
自己设计一段C语言代码，要求实现队列的基本操作。
最新发布
10-26
当然可以，这里是一个简单的C语言代码段，它实现了队列的两个基本操作：入队（enqueue）和出队（dequeue）。在这个例子中，我们使用数组作为底层数据结构。 ```c #include <stdio.h> #define MAX_SIZE 10 // 队列结构体 typedef struct { int data[MAX_SIZE]; int front; // 队头指针 int rear; // 队尾指针 } Queue; // 初始化队列 void initQueue(Queue *q) { q->front = -1; q->rear = -1; } // 判断队列是否为空 int isQueueEmpty(Queue *q) { return (q->front == -1); } // 判断队列是否已满 int isQueueFull(Queue *q) { return ((q->rear + 1) % MAX_SIZE == q->front); } // 入队操作 void enqueue(Queue *q, int value) { if (isQueueFull(q)) { printf("Queue is full.\n"); } else { if (q->front == -1) q->front = 0; q->rear = (q->rear + 1) % MAX_SIZE; q->data[q->rear] = value; printf("Inserted %d at rear of the queue.\n", value); } } // 出队操作 int dequeue(Queue *q) { if (isQueueEmpty(q)) { printf("Queue is empty.\n"); } else { int removedValue = q->data[q->front]; q->front = (q->front + 1) % MAX_SIZE; if (q-1; printf("Removed %d from the front of the queue.\n", removedValue); return removedValue; } } // 主函数演示队列操作 int main() { Queue q; initQueue(&q); enqueue(&q, 1); enqueue(&q, 2); enqueue(&q, 3); dequeue(&q); dequeue(&q); return 0; } ``` 这个代码首先定义了一个队列结构，包含了队头和队尾指针，以及一个数组来存储元素。然后实现了初始化、判断空/满队列、入队和出队的操作。在`main`函数中，展示了如何创建队列并进行基本操作。
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值