【数据结构】队列的链式存储结构

最新推荐文章于 2024-11-02 19:49:34 发布
最新推荐文章于 2024-11-02 19:49:34 发布
阅读量134 收藏 2
点赞数 1
文章标签： 数据结构 算法 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_67689541/article/details/130002760
版权

文章目录

⭐️写在前面的话⭐️

📒博客主页： 程序员好冰
🎉欢迎 【点赞👍 关注🔎 收藏⭐️ 留言📝】
📌本文由 程序员好冰 原创，CSDN 首发！
📆入站时间： 🌴2022 年 07 月 13 日🌴
✉️ 是非不入松风耳，花落花开只读书。
💭推荐书籍：📚《Java编程思想》，📚《Java 核心技术卷》
💬参考在线编程网站：🌐牛客网🌐力扣
🍭 作者水平很有限，如果发现错误，一定要及时告知作者哦！感谢感谢！🍭

队列的链式存储结构

0、自定义声明

需要定义两个结构体

一个表示单个结点的结构，数据和下一个结点的地址

另一个表示整个队列，队头和队尾结点

#include <stdio.h>
#include <stdlib.h>

//链队的实现
#define OK 1
#define ERROR 0

typedef int ElemType;
typedef int Status;

typedef struct LNode
{
    ElemType data;
    struct LNode *next;
}LNode;

typedef struct LinkQueue
{
    LNode *front;//front是头结点，不存放元素
    LNode *rear;
}LinkQueue;

1、初始化链队

初始链队，队头和队尾均指向头结点

并置 L->front->next=NULL;

Status InitQueue(LinkQueue *L)
{
    L->front=(LNode*)malloc(sizeof(LNode));
    L->rear=L->front;
    if(!L->front){
        printf("初始化失败.\n");
        return ERROR;
    }
    L->front->next=NULL;
    printf("初始化队列成功.\n");
    return OK;
}

2、判断队列是否为空

front和rear指向同一个位置，又因为front不存放元素，说明队列为空

Status QueueEmpty(LinkQueue L)
{
    if(L.front==L.rear){
        printf("队列为空.\n");
        return OK;
    }
    printf("队列不为空.\n");
    return ERROR;
}

3、队列的长度

从队头遍历到队尾

Status QueueLength(LinkQueue L)
{
    int i=0;
    LNode *p;
    p=L.front;
    while(L.rear!=p){
        i++;
        p=p->next;
    }
    printf("队列的长度为%d.\n",i);
    return OK;
}

4、清空队列

清空队列可以分为两步：

将遍历队列中的每个元素，并释放

将队头和队尾结点初始化

Status ClearQueue(LinkQueue *L)
{
    LNode *temp;
    while(!L->front->next){
        temp=L->front->next;
        L->front->next=temp->next;
        free(temp);
    }
    L->rear=L->front;
    L->front->next=NULL;
    printf("队列清空成功.\n");
    return OK;
}

5、入队

从队尾插入元素

Status EnQueue(LinkQueue *L,ElemType e)
{
    LNode *s=(LNode*)malloc(sizeof(LNode));
    if(!s){
        printf("初始化结点失败.\n");
        return ERROR;
    }
    s->data=e;
    L->rear->next=s;
    s->next=NULL;
    L->rear=s;
    printf("元素%d入队成功.\n",e);
    return OK;
}

7、销毁队列

先清空，再释放。

Status DestroyQueue(LinkQueue *L)
{
    ClearQueue(L);
    free(L);
    return OK;
}

8、获取队头元素

Status GetHead(LinkQueue L)
{
    if(QueueEmpty(L)){
        return ERROR;
    }
    printf("队头元素为:%d.\n",L.front->next->data);
    return OK;
}

9、出队

从队头删除元素

ElemType DeQueue(LinkQueue *L)
{
    if(QueueEmpty(*L)){
        return ERROR;
    }
    printf("队头元素%d出队成功.\n",L->front->next->data);
    LNode *p;
    p=L->front->next;
    L->front->next=p->next;
    //处理最后一个元素出队的情况
    if(L->rear==p){
       L->rear=L->front;
    }
    free(p);
    return OK;
}

10、打印队列中所有元素

//队列先进先出，先打印队头元素
Status PrintfQueue(LinkQueue L)
{
    if(QueueEmpty(L)){
        return ERROR;
    }
    printf("队列为:");
    LNode *p;
    p=L.front->next;
    while(p){
        printf("%d  ",p->data);
        p=p->next;
    }
    return OK;
}

主函数

int main()
{
    LinkQueue L;
    int input;
    int value;
    printf("请继续操作...\n");
    while(1){
        printf("\n==========================\n");
        printf("1、初始化循环队列.\n");
        printf("2、销毁队列.\n");
        printf("3、清空队列.\n");
        printf("4、判断队列是否为空.\n");
        printf("5、获得队头元素.\n");
        printf("6、插入队尾元素.\n");
        printf("7、删除队头元素.\n");
        printf("8、返回队列中元素个数.\n");
        printf("9、打印队列中所有元素.\n");
        printf("\n==========================\n");
        printf("请输入对应操作的序号:");
        scanf("%d",&input);
        switch(input){
        case 1:
            InitQueue(&L);
            break;
        case 2:
            DestroyQueue(&L);
            break;
        case 3:
            ClearQueue(&L);
            break;
        case 4:
            QueueEmpty(L);
            break;
        case 5:
            GetHead(L);
            break;
            break;
        case 6:
            printf("请输入需要入队的元素:");
            scanf("%d",&value);
            EnQueue(&L,value);
            break;
        case 7:
            DeQueue(&L);
            break;
        case 8:
            QueueLength(L);
            break;
        case 9:
            PrintfQueue(L);
            break;
        default:
            printf("输入的序号有误,请重新输入.\n");
            break;
        }
    }
    return 0;
}

程序源码

运行效果

image-20230407004526791 
#include <stdio.h>
#include <stdlib.h>

//链队的实现
#define OK 1
#define ERROR 0

typedef int ElemType;
typedef int Status;

typedef struct LNode
{
    ElemType data;
    struct LNode *next;
}LNode;

typedef struct LinkQueue
{
    LNode *front;//front是头结点，不存放元素
    LNode *rear;
}LinkQueue;

//函数声明
Status InitQueue(LinkQueue *L)
{
    L->front=(LNode*)malloc(sizeof(LNode));
    L->rear=L->front;
    if(!L->front){
        printf("初始化失败.\n");
        return ERROR;
    }
    L->front->next=NULL;
    printf("初始化队列成功.\n");
    return OK;
}

Status QueueEmpty(LinkQueue L)
{
    if(L.front==L.rear){
        printf("队列为空.\n");
        return OK;
    }
    printf("队列不为空.\n");
    return ERROR;
}

Status QueueLength(LinkQueue L)
{
    int i=0;
    LNode *p;
    p=L.front;
    while(L.rear!=p){
        i++;
        p=p->next;
    }
    printf("队列的长度为%d.\n",i);
    return OK;
}

Status ClearQueue(LinkQueue *L)
{
    LNode *temp;
    while(!L->front->next){
        temp=L->front->next;
        L->front->next=temp->next;
        free(temp);
    }
    L->rear=L->front;
    L->front->next=NULL;
    printf("队列清空成功.\n");
    return OK;
}

Status EnQueue(LinkQueue *L,ElemType e)
{
    LNode *s=(LNode*)malloc(sizeof(LNode));
    if(!s){
        printf("初始化结点失败.\n");
        return ERROR;
    }
    s->data=e;
    L->rear->next=s;
    s->next=NULL;
    L->rear=s;
    printf("元素%d入队成功.\n",e);
    return OK;
}

Status DestroyQueue(LinkQueue *L)
{
    ClearQueue(L);
    free(L);
    return OK;
}

Status GetHead(LinkQueue L)
{
    if(QueueEmpty(L)){
        return ERROR;
    }
    printf("队头元素为:%d.\n",L.front->next->data);
    return OK;
}

ElemType DeQueue(LinkQueue *L)
{
    if(QueueEmpty(*L)){
        return ERROR;
    }
    printf("队头元素%d出队成功.\n",L->front->next->data);
    LNode *p;
    p=L->front->next;
    L->front->next=p->next;
    //处理最后一个元素出队的情况
    if(L->rear==p){
       L->rear=L->front;
    }
    free(p);
    return OK;
}

//队列先进先出，先打印队头元素
Status PrintfQueue(LinkQueue L)
{
    if(QueueEmpty(L)){
        return ERROR;
    }
    printf("队列为:");
    LNode *p;
    p=L.front->next;
    while(p){
        printf("%d  ",p->data);
        p=p->next;
    }
    return OK;
}

int main()
{
    LinkQueue L;
    int input;
    int value;
    printf("请继续操作...\n");
    while(1){
        printf("\n==========================\n");
        printf("1、初始化循环队列.\n");
        printf("2、销毁队列.\n");
        printf("3、清空队列.\n");
        printf("4、判断队列是否为空.\n");
        printf("5、获得队头元素.\n");
        printf("6、插入队尾元素.\n");
        printf("7、删除队头元素.\n");
        printf("8、返回队列中元素个数.\n");
        printf("9、打印队列中所有元素.\n");
        printf("\n==========================\n");
        printf("请输入对应操作的序号:");
        scanf("%d",&input);
        switch(input){
        case 1:
            InitQueue(&L);
            break;
        case 2:
            DestroyQueue(&L);
            break;
        case 3:
            ClearQueue(&L);
            break;
        case 4:
            QueueEmpty(L);
            break;
        case 5:
            GetHead(L);
            break;
            break;
        case 6:
            printf("请输入需要入队的元素:");
            scanf("%d",&value);
            EnQueue(&L,value);
            break;
        case 7:
            DeQueue(&L);
            break;
        case 8:
            QueueLength(L);
            break;
        case 9:
            PrintfQueue(L);
            break;
        default:
            printf("输入的序号有误,请重新输入.\n");
            break;
        }
    }
    return 0;
}

🚀先看后赞，养成习惯！🚀

🚀 先看后赞，养成习惯！🚀

🎈觉得文章写得不错的老铁们，点赞评论关注走一波！谢谢啦！🎈

程序员好冰
关注
第三章 栈和队列 顺序存储结构和链式存储结构
04-20
本章将深入探讨两种重要的数据结构——栈和队列，以及它们的两种常见存储方式：顺序存储结构和链式存储结构。 栈（Stack）被称为“后进先出”（Last In, First Out，简称LIFO）的数据结构。栈的操作主要围绕两个...
作业 第三章 栈和队列 顺序存储结构和链式存储结构
04-20
本章主要探讨的是两种常用且基础的数据结构——栈（Stack）和队列（Queue），以及它们的两种基本存储方式：顺序存储结构（Sequential Storage Structure）和链式存储结构（Linked Storage Structure）。我们将深入...
数据结构之队列的链式存储
AHuRui的博客
05-16 5264
文章目录一、队列的链式存储结构结构体的定义：二、相关操作实现1.初始化2.依次对栈中的每个数据元素输出3.进队列4.出队列5.链队列中元素个数6.测试函数7.具体代码实现三、样例输出四、问题回答五、写在最后 队列的链式存储 这里是数据结构个人学习的笔记记录，如有问题欢迎指正说明 一、队列的链式存储结构 队列的链式存储结构，其实就是线性表的单链表，只不过它只能尾进头出，我们把它简单称为链队列。为了操作上的方便，我们将队头指针指向链队列的头结点，而队尾指针指向终端结点。空队列时，我们将队头指针和队尾指针都
数据结构：队列(顺序存储和链式存储)
2301_79601095的博客
07-25 1940
主要介绍了队列的概念和结构，还有队列的顺序存储实现和链式存储实现的详细说明和代码实现，最后再对比队列的顺序存储结构和链式存储结构的优缺点
队列的链式存储结构
weixin_61898526的博客
04-24 2961
队列的链式存储结构：只能尾进头出的单链表也叫链队列。 与顺序存储结构一样有front指针和rear指针，只不过front指向头结点，rear指向最后一个结点。 当front指针和rear指针都指向头结点时，链表为空。 链队列的结构代码： typedef struct QNode { type data; struct QNode *next; }QNode , *QueuePtr; typedef struct { Queu...
数据结构——队列的链式存储（优缺点及代码实现:C语言）
fuckfunk的博客
04-26 894
详细介绍数据结构中队列的链式存储结构 并通过C语言实现基本操作，最后附有完整示例
C语言数据结构-队列的链式存储
Blow out the reading lamp, full of moon
11-15 412
/只能在一端插入，一端删除 ，先进先出，后进后出。//队列（Queue）是具有一定操作约束的线性表。//队列的链式存储用一个单链表实现。
数据结构——链式队列和循环队列
2301_80401288的博客
08-21 1504
数据结构——队列 求点赞收藏关注！！！感谢各位大佬！！！
数据结构 - 链式队列
weixin_49303682的博客
12-26 3271
1.链式队列 链式队列 ： 用链表形式实现的队列。链表结点为队列数据存储区，链表结点包括两部分数据存储 区和指针存储区。 数据存储区 ：存放真实有效数据的区域。 指针存储区 ：存放下一个链表结点的地址。 2.创建链式队列 为链式队列申请内存，即为队首指针和队尾指针申请内存。 为链式队列头结点申请内存，头结点不存放有效数据，方便队列的操作。 将队首指针和队尾指针指向头结点，即队首指针和队尾指针相等。 链式队列头结点指针域为空，即为NULL；头结点数据域可不管，亦可为零，作为链式队列有效的
数据结构【队列-使用链式存储实现队列】
DMHY123的博客
07-25 1140
C语言代码实现链式队列
队列的链式存储结构及其基本运算实现
qq_57484399的博客
10-17 1399
前面我们介绍了顺序队列的存储 ,是利用数组存储数据 , 然后删除节点数据和添加节点数据都是在数组完成的 , 有一个弊端就是 ,当我们操作的数量很大时 , 如果数组存储结构就很难队列操作了 ,那就需要利用链式存储结构了
队列——链式存储结构实现
一个很懒的人
07-29 540
0.摘要 本文首先以思维导图的形式介绍链式队列的基本知识，其次给出代码中需要额外注意的地方，最后给出带头结点的队列代码实现方式 顺序队列（循环队列）实现，请参考我的另一篇博客： 队列——顺序存储结构实现( 循环队列 - 不同指针指向). 1.基本知识 2.代码注意点 队列结点定义、链式队列定义（结构体定义），链式队列中 front 和 rear 的引用，具体详情见代码！ 3.链式队列代码实现 带头结点 #include<bits/stdc++.h> using namespa.
数据结构：队列（链式存储、顺序存储）
12-07
在C语言中，为了实现这些功能，我们需要定义数据结构，例如`struct Node`（链式存储）或`int queue[MAX_SIZE]`（顺序存储），并编写相应的函数，如`createQueue()`, `isEmpty()`, `isFull()`, `enqueue()`, `dequeue...
队列顺序存储&链式存储.rar
04-12
本资源“队列顺序存储&链式存储.rar”提供了浙江大学在中国大学MOOC上《数据结构》课程中关于队列实现的源代码，主要包含两种存储方式：顺序存储和链式存储。 队列是一种先进先出（First In First Out, FIFO）的...
djb.rar_C++_c 循环 队列_数据队列_链式队列_队列 数据结构
09-23
3. **链式队列**：链式队列使用链表作为底层数据结构，每个元素（节点）包含数据和指向下一个元素的指针。链式队列的优势在于动态扩展性，无需预先确定大小，可以根据需要动态添加或删除节点。因此，链式队列在处理...
通用型函数——冒泡排序
2401_84654619的博客
10-29 422
计算机中，任何数据最终都是二进制数，故只需有足够的空间，就可以将任何数据存储起来，相应的，读取时使用数据类型容器识别就可还原原本的意思。memcpy函数用于将指定数量的字节从源内存地址（src）复制到目标内存地址（dest）。n : 要复制的字节数，类型为size_t表示要复制的字节的数量。代码：（char型）
数据结构和算法-动态规划(3)-经典问题
qq_36115196的博客
10-30 848
动态规划(Dynamic Programming): 计算并存储小问题的解， 并将这些解组合成大问题的解。
java-数据结构
2301_80708315的博客
10-30 1008
如果使用 left < right 作为条件，那么在最后一次迭代中，当 left 和 right 相邻时（即 left = right - 1），循环就会提前终止，从而可能错过目标元素（如果它正好位于 left 或 right 指向的位置）。left ==right 意味着它们指向的元素也会参与比较，left < right 只意味着middle指向的元素参与比较。l为总循环次数，当元素在最右边与最左边时的循环次数不一致。eg 当我的数组为{1，23，45，77，123}时我查找12时就会返回。
【数据结构篇】探索堆的算法的巧妙
最新发布
braveact的博客
11-02 574
⽤剩余的N-K个元素依次与堆顶元素来⽐较，不满⾜则替换堆顶元素 ，然后再将交换进去后的元素向下调整（保证这k个元素始终是堆），最后将剩余N-k个元素依次与堆顶元素⽐完之后，堆中剩余的K个元素就是所求的前k个最⼩或者最⼤的元素。对于Top-K问题，能想到的最简单直接的⽅式就是排序，但是：如果数据量⾮常⼤，排序就不太可取了 (可能数据都不能⼀下⼦全部加载到内存中)。依次将堆顶最大的数据与最后一个（不断发生变化）元素交换，每次都是将最大的数据放最后，可以想象一下，就是升序了。前k个最⼩的元素，则建⼤堆。
数据结构：顺序存储与链式存储解析
该资源是关于数据结构课程的讲解，主要关注基于顺序存储和链式存储的数据结构，特别是顺序队列的实现。课程适合计算机专业的学生，旨在提升问题解决能力和程序设计技能。 在数据结构中，顺序存储和链式存储是两种...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值