队列的链式存储实现

于 2023-05-19 15:29:23 发布
阅读量346 收藏
点赞数
分类专栏： 数据结构 文章标签： 链表 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_51141456/article/details/130725646
版权

文章目录

队列的链式存储实现

链式队列 ： 用链表形式实现的队列。链表结点为队列数据存储区，链表结点包括两部分数据存储

区和指针存储区。

数据存储区 ：存放真实有效数据的区域。

指针存储区 ：存放下一个链表结点的地址。

二、实现过程

1.链式队列概念图(有头结点)：

在这里插入图片描述

2.链式队列结构体：

头指针执行头结点，尾指针指向尾结点

//线性表存储结构
typedef struct LNode
{
        ElemType data;                  //存储队列中的元素。
        struct LNode* next;             //next指针

}LNode;

//队列的指针头和尾
typedef struct
{
  LNode *front,*rear;     // 队列的头指针和尾指针。
}LinkQueue,*PLinkQueue;

3.队列的基本操作

在这里插入图片描述

4.代码实现：

/*
        程序名:linkqueue.cpp 此程序演示队列的链表实现（带头结点）。
*/


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

typedef int ElemType;                   //自定义队列的数据元素为整数。

//线性表存储结构
typedef struct LNode
{
        ElemType data;                  //存储队列中的元素。
        struct LNode* next;             //next指针

}LNode;

//队列的指针头和尾
typedef struct
{
  LNode *front,*rear;     // 队列的头指针和尾指针。
}LinkQueue,*PLinkQueue;


//队列QQ的初始化操作。
int InitQueue(PLinkQueue QQ);

// 销毁队列QQ。
void DestroyQueue(PLinkQueue QQ);

// 清空队列。
void Clear(PLinkQueue QQ);

// 元素入队，返回值：0-失败；1-成功。
int InQueue(PLinkQueue QQ, ElemType *ee);

// 打印队列中全部的元素。
void PrintQueue(PLinkQueue QQ);

// 求队列的长度，返回值：>=0-队列QQ元素的个数。
int  Length(PLinkQueue QQ);

// 判断队列是否已满，链式队列不存在队满的说法。
int IsFull(PLinkQueue QQ);

// 判断队列是否为空，返回值：1-空，0-非空或失败。
int  IsEmpty(PLinkQueue QQ);

// 元素出队，返回值：0-失败；1-成功。
int OutQueue(PLinkQueue QQ, ElemType *ee);

// 获取队头元素，返回值：0-失败；1-成功。
// 只查看队头元素的值，元素不出队。
int GetHead(PLinkQueue QQ, ElemType *ee);


int main()
{
        LinkQueue QQ;     // 创建队列。

        memset(&QQ,0,sizeof(LinkQueue));

        InitQueue(&QQ);  // 初始化队列。

        ElemType ee;     // 创建一个数据元素。

        printf("元素（1、2、3、4、5、6、7、8、9、10）入队。\n");
        ee=1;  InQueue(&QQ, &ee);
        ee=2;  InQueue(&QQ, &ee);
        ee=3;  InQueue(&QQ, &ee);
        ee=4;  InQueue(&QQ, &ee);
        ee=5;  InQueue(&QQ, &ee);
        ee=6;  InQueue(&QQ, &ee);
        ee=7;  InQueue(&QQ, &ee);
        ee=8;  InQueue(&QQ, &ee);
        ee=9;  InQueue(&QQ, &ee);
        ee=10; InQueue(&QQ, &ee);

        printf("队列的长度是%d\n",Length(&QQ));

        printf("打印队列元素:\n");
        PrintQueue(&QQ);

        if (OutQueue(&QQ,&ee)==1)  printf("出队的元素值为%d\n",ee);
        if (OutQueue(&QQ,&ee)==1)  printf("出队的元素值为%d\n",ee);
        if (OutQueue(&QQ,&ee)==1)  printf("出队的元素值为%d\n",ee);
        if (OutQueue(&QQ,&ee)==1)  printf("出队的元素值为%d\n",ee);
        if (OutQueue(&QQ,&ee)==1)  printf("出队的元素值为%d\n",ee);
        if (OutQueue(&QQ,&ee)==1)  printf("出队的元素值为%d\n",ee);
        if (OutQueue(&QQ,&ee)==1)  printf("出队的元素值为%d\n",ee);

        printf("队列的长度是%d\n",Length(&QQ));
        PrintQueue(&QQ);

        printf("元素（11、12、13、14、15）入队。\n");
        ee=11;  InQueue(&QQ, &ee);
        ee=12;  InQueue(&QQ, &ee);
        ee=13;  InQueue(&QQ, &ee);
        ee=14;  InQueue(&QQ, &ee);
        ee=15;  InQueue(&QQ, &ee);

        printf("队列的长度是%d\n",Length(&QQ));


        PrintQueue(&QQ);
        // 只查看队头元素的值，元素不出队。
        if (GetHead(&QQ,&ee)==1)  printf("队头的元素值为%d\n",ee);


//      printf("清除前front=%p,rear=%p\n",QQ.front,QQ.rear);
        Clear(&QQ); // 销毁队列QQ。     
//      printf("清除后front=%p,rear=%p\n",QQ.front,QQ.rear);

//      printf("销毁前front=%p,rear=%p\n",QQ.front,QQ.rear);
        DestroyQueue(&QQ); // 销毁队列QQ。      
//      printf("销毁后front=%p,rear=%p\n",QQ.front,QQ.rear);
        return 0;
}

//队列QQ的初始化操作。
int InitQueue(PLinkQueue QQ)
{
        if(QQ == NULL){ printf("队列不存在\n"); return 0; }

        //创建头结点
        LNode* head=(LNode*)malloc(sizeof(LNode));
        if(head==NULL){ printf("内存不足，分配结点失败。\n");return 0; }

        head->next=NULL;

        QQ->front=QQ->rear=head;
        return 1;
}

// 销毁队列QQ。删除所有结点
void DestroyQueue(PLinkQueue QQ)
{
        //队列指针不存在 
        if(QQ==NULL){ printf("队列不存在\n"); return ; }

        // 未初始化 即头尾指针没有指向头结点
        if(QQ->front==NULL){
                printf("队列未初始化。\n");
                return ;
        }


        LNode* tmp=QQ->front;

        //逐个结点删除
        while(tmp != QQ->rear->next)
        {
                tmp=tmp->next;          //下个结点地址
                free(QQ->front);        //释放本结点地址
                QQ->front=tmp;          //指针指向下一个结点
        }

        QQ->front=QQ->rear=NULL;
        return ;
}

// 清空队列。删除了除头结点以外的所有结点
void Clear(PLinkQueue QQ)
{

        //队列指针不存在 
        if(QQ==NULL){ printf("队列不存在\n"); return ; }

        // 未初始化 即头尾指针没有指向头结点
        if(QQ->front==NULL){
                printf("队列未初始化。\n");
                return ;
        }

        LNode *head=QQ->front;          //保存头结点

        LNode* tmp=QQ->front->next;     //从首节点开始删除

        //逐个结点删除
        while(tmp != QQ->rear->next)
        {
                tmp=tmp->next;          //下个结点地址
                free(QQ->front);        //释放本结点地址
                QQ->front=tmp;          //指针指向下一个结点
        }

        QQ->front=QQ->rear=head;
        QQ->front->next=QQ->rear->next=NULL;
}

// 元素入队，返回值：0-失败；1-成功。
int InQueue(PLinkQueue QQ, ElemType *ee)
{
        //队列指针不存在
        if(QQ==NULL){ printf("队列不存在\n"); return 0; }

        //未初始化 即头尾指针没有指向头结点
        if(QQ->front==NULL){
                printf("队列未初始化。\n");
                return 0;
        }

        //新建一个结点
        LNode *newnode=(LNode*)malloc(sizeof(LNode));
        if(newnode==NULL)return 0;
        //将元素值赋值给新结点
        memcpy(&newnode->data,ee,sizeof(ElemType));


        newnode->next=NULL;
        QQ->rear->next=newnode;
        QQ->rear=newnode;

        return 1;
}

// 打印队列中全部的元素。
void PrintQueue(PLinkQueue QQ)
{
        //队列指针不存在
        if(QQ==NULL){ printf("队列不存在\n"); return ; }

        //未初始化 即头尾指针没有指向头结点
        if(QQ->front==NULL){
                printf("队列未初始化。\n");
                return ;
        }


        LNode* tmp=QQ->front->next;             //从首节点开始输出


        //当指针没查询到尾指针的next域，一直查询
        while(tmp!=QQ->rear->next){
                printf("%3d ",tmp->data);
                tmp=tmp->next;
        }

        printf("\n");
}

// 求队列的长度，返回值：>=0-队列QQ元素的个数。
int  Length(PLinkQueue QQ)
{
        //队列指针不存在
            if(QQ==NULL){ printf("队列不存在\n"); return 0; }

        //未初始化 即头尾指针没有指向头结点
        if(QQ->front==NULL){
                printf("队列未初始化。\n");
                return 0;
        }

        LNode* tmp=QQ->front->next;     //从首节点开始计数
        if(tmp==NULL)return 0;

        int length=1;                   //头结点序号为1 

        while(tmp!=QQ->rear)
        {
                length++;
                tmp=tmp->next;
        }

        return length;
}

// 判断队列是否已满，链式队列不存在队满的说法。
int IsFull(PLinkQueue QQ)
{
        //队列指针不存在
        if(QQ==NULL){ printf("队列不存在\n"); return 0; }
        return 1;
}

// 判断队列是否为空，返回值：1-空，0-非空或失败。
int  IsEmpty(PLinkQueue QQ)
{
        //队列指针不存在
        if(QQ==NULL){ printf("队列不存在\n"); return 0; }

        //首尾相等为空
        if(QQ->front==QQ->rear)return 1;
        return 0;

}
// 元素出队，返回值：0-失败；1-成功。
int OutQueue(PLinkQueue QQ, ElemType *ee)
{
        //队列指针不存在
        if(QQ==NULL){ printf("队列不存在\n"); return 0; }

        if(QQ->front==NULL){printf("队列未初始化");return 0;}

        if(IsEmpty(QQ)){ printf("队空,无元素可以出队。\n"); return 0; }          
        //队头元素出队
        LNode* tmp=QQ->front->next;

        //队尾
        memcpy(ee,&tmp->data,sizeof(ElemType));

        QQ->front->next=tmp->next;

        // 如果出队的是最后一个结点。
        if (QQ->rear==tmp) QQ->rear=QQ->front;
        free(tmp);

        return 1;
}
// 获取队头元素，返回值：0-失败；1-成功。
// 只查看队头元素的值，元素不出队。
int GetHead(PLinkQueue QQ, ElemType *ee)
{
        if(QQ==NULL){ printf("队列不存在\n"); return 0; }

        if(QQ->front==NULL){printf("队列未初始化");return 0;}

        if(IsEmpty(QQ)){ printf("队空,无元素可以出队。\n"); return 0; }

        //取队头元素
        memcpy(ee,&QQ->front->next->data,sizeof(ElemType));

        return 1;
}
队列的链接存储结构——基本操作的实现
YanMeiHe的博客
10-15 1856
链接存储的队列中的入队、出队、读取队头元素等操作的代码以及实现结果截图
队列的链式存储结构——（c++实现）
qq_29131907的博客
03-26 341
#pragma once class Node { public: Node(); ~Node(); friend class Queue; int data; Node *next; }; class Queue { public: Queue(); ~Queue(); void Push_Queue();//入栈 void Pop_Queue();//出栈 bool Is...
队列的链式存储结构及实现
热门推荐
重庆李四
12-26 1万+
队列的链式存储结构，其实就是线性表的单链表，只不过它只是尾进头出而已，我们把它简称为链队列。为了操作上的方便，我们将队头指针指向链队列的头结点，而队尾指针指向终端节点。如果 空队列时，front和rear都指向头结点。 入队操作： 在队尾添加元素,先将队尾元素的next指向添加的元素，然后将队尾指针重新指向新的队尾即可。 出队操作： 头结结
数据结构：队列的链式存储结构的实现
sinb妃的博客
01-08 530
题目： （1）用随机函数生成10个3位整数（100~999），把这些整数应用入队操作存于队列中； （2）应用遍历操作输出队列的内容； （3）把队列的内容翻转，应用出队操作输出队列的内容。 思路： 队列的特性为先进先出，利用此特点，为队列设置队首和队尾指针，入队时往队尾添加节点，出队时从队首删除节点即可 代码实现： #include "pch.h" #include <iostream>...
队列——链式存储结构实现
一个很懒的人
07-29 571
0.摘要 本文首先以思维导图的形式介绍链式队列的基本知识，其次给出代码中需要额外注意的地方，最后给出带头结点的队列代码实现方式 顺序队列（循环队列）实现，请参考我的另一篇博客： 队列——顺序存储结构实现( 循环队列 - 不同指针指向). 1.基本知识 2.代码注意点 队列结点定义、链式队列定义（结构体定义），链式队列中 front 和 rear 的引用，具体详情见代码！ 3.链式队列代码实现 带头结点 #include<bits/stdc++.h> using namespa.
队列的动态链式存储实现代码分享
09-04
链式存储的队列相比于顺序存储（如数组）有其优势，比如可以灵活地增加或减少存储空间，而无需预先确定队列的大小。此外，由于链表节点的插入和删除操作通常比数组快，因此在处理大量数据时，链式队列的效率可能更高...
队列顺序存储&链式存储.rar
04-12
本资源“队列顺序存储&链式存储.rar”提供了浙江大学在中国大学MOOC上《数据结构》课程中关于队列实现的源代码，主要包含两种存储方式：顺序存储和链式存储。 队列是一种先进先出（First In First Out, FIFO）的...
顺序存储和链式存储的泛型队列_C语言项目
04-12
本项目专注于实现顺序存储和链式存储的泛型队列，使用C语言作为编程工具，旨在提供灵活且高效的操作接口。下面我们将深入探讨相关知识点。 首先，队列是一种先进先出（First In First Out, FIFO）的数据结构，它的...
C++中实现队列类链式存储与栈类链式存储的代码示例
09-02
首先，我们来看队列的链式存储实现。队列是一种先进先出（FIFO）的数据结构，通常用于处理一组等待处理的任务或数据。在链式存储中，队列可以通过单链表实现，这里的`LinkQueue`类就是这样一个例子。`LinkQueue`类...
队列的链式存储C语言实现
04-04
以上就是用C语言实现队列链式存储的基本操作。这种实现方式具有灵活的内存管理和高效的插入与删除性能，尤其适用于大数据环境。通过这些基本操作，可以构建更复杂的数据处理系统，例如任务调度、消息传递等。在实际...
队列的链式存储结构的实现
qq_43411563的博客
04-26 2433
一、链式存储结构的定义 队列的链式存储结构，其实就是线性表的单链表。只不过它是只能尾进头出而已，我们称之为链队列。我们定义了两个指针，一个指向队列的头，一个指向队列的尾。这样进行插入和删除的操作时时间复杂度都为O(1)。如下图所示： 二、队列链式存储结构的简单实现 1、队列链式存储结构的整体实现 typedef int ElemType; typedef struct Node { ElemT...
数据结构C++边学边做--队列的链式存储结构实现
qq_39400324的博客
02-10 1761
队列的链式存储结构实现一、链队列的定义二、链队列数据结构定义三、链队列类实现1.类声明2.LinkQueue->构造函数3.~LinkQueue->析构函数4.EnQueue->入队5.DeQueue->出队6.GetQueue->取队头7.Empty->判断空队列四、链队列的测试1.主函数2.输出结果五、源代码获取（免积分） 一、链队列的定义   采用链式存储结构实现的队列称为链队列（linked queue）。可以对单链表进行改造得到链队列，表头对应队头，表尾对应队尾
数据结构（11）：队列的链式存储结构的实现
欢迎来到关关雎鸠儿的博客
08-14 212
程序代码： #include<stdio.h> #include<stdlib.h> #define ERROR 0 #define OK 1 #define TRUE 1 #define FALSE 0 typedef int QElemType; typedef int Status; typedef struct Qnode{ QElemType data; st...
队列的链式存储结构——C实现
qq_38236355的博客
09-14 369
队列的链式存储结构。队列常用链表来实现，简称为链队列。 本次设计的链队列有头结点，并且队首指向头结点，队尾指向链尾结点。 队列是先进先出的线性表，在队尾那一端插入元素，在队首那一端删除元素。 c语言代码： #define _CRT_SECURE_NO_WARNINGS #include<stdlib.h> #include<stdio.h> typedef char El...
队列的链式存储结构基本实现（C++）
SGL_LGS的博客
04-26 500
前面我们实现了队列的顺序存储结构的一般功能。并用循环列表使取第一个元素的时间复杂度从O(n)降到了O(1)。一般来说，当我们已知队列的最大可能长度时，用顺序存储结构实现，因为可以减少链式存储结构中寻址时间开销。但当我们不知道具体长度时，为了避免内存的浪费或者内存不够的情况，一般我们选择链式存储结构。 主要函数介绍： 本例实现中，利用了结构体存储节点信息。并利用了函数模板实现了队列链式存储结构的实例...
《大话数据结构》—— 队列的链式存储结构 —— C++、C# 代码实现
TAOTAO
11-06 517
目录 链队列 循环队列和链式队列的比较 链队列 实现队列的最好的方式就是使用单链表来实现,队列的链式存储结构，其实就是线性表的单链表，只不过它只能尾进头出而已——称为链队列。 那为了操作方便，头指针指向头结点，队尾指针指向终端节点，即最后一个结点元素。 设队首、队尾指针front和rear,front指向头结点，rear指向队尾 队列为空时，front 和 real 都指向头结...
C++实现队列链式存储源代码解析
队列链式存储是一种数据结构实现方式，用于在计算机程序中模拟队列的行为。队列是一种先进先出（FIFO）的数据结构，元素的添加（入队）发生在队列的尾部，而元素的移除（出队）则发生在队列的头部。链式存储结构是...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值