数据结构之链队列

最新推荐文章于 2024-05-12 06:30:00 发布
最新推荐文章于 2024-05-12 06:30:00 发布
阅读量1.4k 收藏 5
点赞数 1
分类专栏： 算法与数据结构 算法与数据结构 文章标签： 数据结构 链队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/XGsilence/article/details/18953867
版权

（1）链队列：用链表表示的队列。

（2）队列组成

首先说一下队列的节点。队列的节点是由数据data和存放地址的指针变量next两部分组成。

typedef struct QNode
{
    int data;
    struct QNode *next;
}QNode,*QueuePtr;
对于队列来说，要有对头指针front和队尾指针rear。并且这两个指针都是要指向队列的节点的。所以应该定义成结构体的指针类型。 

typedef struct
{
    QueuePtr front;//对头指针
    QueuePtr rear;//队尾指针
}LinkQueue;

在写这个结构体的时候脑袋突然短路一下。我在想，用QueuePtr定义的front和rear这两个指针变量里面是否也有data和next两部分。查阅资料后才发现不是那么回事。（C语言中指针变量所占字节大小）

（3）队列的基本操作

1、初始化队列

就是构造一个空队列。它的判断条件是：头指针和尾指针都指向头节点。如图所示：

/*--------------------------------------------------------------------------
操作目的：  初始化队列
初始条件：  无
操作结果：  构造一个空队列（空队列的判断条件为：头指针和尾指针均指向头节点）
函数参数：  LinkQueue *Q
返回值：    无
--------------------------------------------------------------------------*/
void InitQueue(LinkQueue *Q)
{
    Q->front = Q->rear = (QueuePtr)malloc(sizeof(QNode));
    if(Q->front == NULL)
    {
        printf("内存分配失败\n");
        exit(-1);
    }
    else
    {
        Q->front->next = NULL;//将对头指针指向的节点的next赋为NULL
        //Q->rear->next = NULL;//因为对头指针和队尾指针指向同一节点所以这两句写一句就可以
        //问题1、一个变量的同类型的指针变量怎样存储此变量？
        printf("分配内存成功\n");
    }
}
首先申请一块内存空间， 关于malloc和free函数的用法中，当申请空间后首先要判断是否申请内存成功。当判断成功之后才进行下一步操作。

2、销毁队列

怎样才算是销毁队列呢？就是将队列的元素全部释放掉之后，将front和rear两个指针都指向NULL。

/*------------------------------------------------------------
操作目的：  销毁队列
初始条件：  队列Q存在
操作结果：  销毁队列Q
函数参数：  待销毁的队列Q
返回值：    无
-------------------------------------------------------------*/
void DestroyQueue(LinkQueue *Q)
{
    while(Q->front != NULL)
    {
        Q->rear = Q->front->next;
        free(Q->front);
        Q->front = Q->rear;
    }
    printf("销毁队列成功");
    return ;
}
利用Q->front 是否等于NULL作为判断条件。首先将front指向的元素的下一个元素赋给rear。然后将front指向的元素释放。最后通过，Q->front = Q->rear将Q->front向下移动。通过这样的方式逐个释放队列的元素。当Q->front = NULL时，Q->rear 也就等于 NULL。

3、队列判空

此操作函数比较简单，就是判断对头指针是否等于队尾指针即可（Q->front == Q->rear）。如果等于返回true，否则返回false.

/*---------------------------------------------------
操作目的：  队列判空
初始条件：  队列Q存在
操作结果：  判断队列是否为空
函数参数：  队列Q
返回值：    true，false
----------------------------------------------------*/
bool QueueEmpty(LinkQueue *Q)
{
    if(Q->front == Q->rear)
        return true;
    else
        return false;
}
4、队列清空

队列清空与销毁队列的不同之处就是：队列清空保留头节点，并使对头指针front和队尾指针rear指向头节点，形成空队列。

/*---------------------------------------------------
操作目的：  将队列清空
初始条件：  队列Q存在
操作结果：  将队列Q清为空队列
函数参数：  队列Q
返回值：    无
----------------------------------------------------*/
void ClearQueue(LinkQueue *Q)
{
    QueuePtr p = Q->front->next;
    if(QueueEmpty(Q))
    {
        printf("队列不为空\n");
    }
    else
    {
        while(p != NULL)
        {
            Q->front->next = p->next;
            free(p);
            p = Q->front->next;
        }
        Q->rear = Q->front;//形成空队列（即对头、队尾指向头结点）
    }

    return ;
}
5、求队列的长度

求队列的长度时，首先应该判断一下时候为空队列。如果为空队列就不用再求队列的长度了。如果不是空队列，在进行下一步操作。

int QueueLength(LinkQueue *Q)
{
    int length = 0;
    QueuePtr p = Q->front;
    if(QueueEmpty(Q))
    {
        printf("队列为空队列");
        exit(-1);
    }
    else
    {
        while(p != Q->rear)
        {
            length ++;
            p = p->next;
        }
    }
    return length;
}
6、求队列对头的元素

要判断是否为空队列。

7、插入元素

队列插入元素只能在队尾。因此在插入节点的时候，让队尾指针指向的节点的next指向要插入的节点。之后，将队尾指针指向刚插入的节点。

/*-----------------------------------------------------
操作目的：  插入元素
初始条件：  队列Q存在
操作结果：  向队列Q中插入一个元素e
函数参数：  队列Q，待插入元素e
返回值：    无
------------------------------------------------------*/
void InsertQueue(LinkQueue *Q, int e)
{
    QueuePtr p;
    p = (QueuePtr)malloc(sizeof(QNode));
    if(p == NULL)
    {
        printf("动态分配内存失败");
        exit(-1);
    }
    p->data = e;
    p->next = NULL;
    Q->rear->next = p;
    Q->rear = p;
    return ;
}

插入队列如图所示：


8、删除元素

首相定义一个指针变量p，让它指向对头指针front指向的下一个元素。然后通过Q->front->next = p->next;可将p指向的节点删除。这里面有个特殊情况，就是当p指向的节点与队尾指针指向的节点为同一节点（队列中只有一个元素时），可以直接 Q->rear = Q->front;即可。

/*-----------------------------------------------------
操作目的：  删除元素
初始条件：  队列Q存在
操作结果：  从队列Q中删除一个元素
函数参数：  队列Q，待存放删除元素的变量e
返回值：    true,false
-------------------------------------------------------*/
bool DeQueue(LinkQueue *Q, int *e)
{
    QueuePtr p = Q->front->next;
    if(QueueEmpty(Q))
    {
        return false;
    }
    else
    {
        Q->front->next = p->next;
        *e = p->data;
        if(Q->rear == p)
            Q->rear = Q->front;
        return true;
    }
}

删除元素如图所示：



9、遍历队列

首先判断队列是否为空队列。若不为空队列，在进行下一步操作

bool QueueTraverse(LinkQueue *Q)
{
    QueuePtr p = Q->front->next;
    if(QueueEmpty(Q))
    {
        return false;
    }
    else
    {
        while(p != NULL)
        {
            printf("%d ",p->data);
            p = p->next;
        }
        return true;
    }
}

10、完整的代码 

#include <stdio.h>
#include <malloc.h>
#include <stdbool.h>

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

typedef struct
{
    QueuePtr front;//对头指针
    QueuePtr rear;//队尾指针
}LinkQueue;
/*--------------------------------------------------------------------------
操作目的：  初始化队列
初始条件：  无
操作结果：  构造一个空队列（空队列的判断条件为：头指针和尾指针均指向头节点）
函数参数：  LinkQueue *Q
返回值：    无
--------------------------------------------------------------------------*/
void InitQueue(LinkQueue *Q)
{
    Q->front = Q->rear = (QueuePtr)malloc(sizeof(QNode));
    if(Q->front == NULL)
    {
        printf("内存分配失败\n");
        exit(-1);
    }
    else
    {
        Q->front->next = NULL;//将对头指针指向的节点的next赋为NULL
        //Q->rear->next = NULL;//因为对头指针和队尾指针指向同一节点所以这两句写一句就可以
        //问题1、一个变量的同类型的指针变量怎样存储此变量？
        printf("分配内存成功\n");
    }
}
/*------------------------------------------------------------
操作目的：  销毁队列
初始条件：  队列Q存在
操作结果：  销毁队列Q
函数参数：  待销毁的队列Q
返回值：    无
-------------------------------------------------------------*/
void DestroyQueue(LinkQueue *Q)
{
    while(Q->front != NULL)
    {
        Q->rear = Q->front->next;
        free(Q->front);
        Q->front = Q->rear;
    }
    printf("销毁队列成功");
    return ;
}
/*---------------------------------------------------
操作目的：  队列判空
初始条件：  队列Q存在
操作结果：  判断队列是否为空
函数参数：  队列Q
返回值：    true，false
----------------------------------------------------*/
bool QueueEmpty(LinkQueue *Q)
{
    if(Q->front == Q->rear)
        return true;
    else
        return false;
}
/*---------------------------------------------------
操作目的：  将队列清空
初始条件：  队列Q存在
操作结果：  将队列Q清为空队列
函数参数：  队列Q
返回值：    无
----------------------------------------------------*/
void ClearQueue(LinkQueue *Q)
{
    QueuePtr p = Q->front->next;
    if(QueueEmpty(Q))
    {
        printf("队列不为空\n");
    }
    else
    {
        while(p != NULL)
        {
            Q->front->next = p->next;
            free(p);
            p = Q->front->next;
        }
        Q->rear = Q->front;//形成空队列（即对头、队尾指向头结点）
    }

    return ;
}
/*-----------------------------------------------------
操作目的：  求队列的长度
初始条件：  队列Q存在
操作结果：  返回Q的元素个数即为队列的长度
函数参数：  队列Q
返回值：    Length数据元素的个数
------------------------------------------------------*/
int QueueLength(LinkQueue *Q)
{
    int length = 0;
    QueuePtr p = Q->front;
    if(QueueEmpty(Q))
    {
        printf("队列为空队列");
        exit(-1);
    }
    else
    {
        while(p != Q->rear)
        {
            length ++;
            p = p->next;
        }
    }
    return length;
}

/*-----------------------------------------------------
操作目的：  求对头元素
初始条件：  队列Q存在
操作结果：  得到对头元素
函数参数：  队列Q，存放对头元素的e
返回值：    false,true
------------------------------------------------------*/
bool GetHead(LinkQueue *Q, int *e)
{
    if(QueueEmpty(Q))
    {
        return false;
    }
    else
    {
        *e = Q->front->next->data;
        return true;
    }
}
/*-----------------------------------------------------
操作目的：  插入元素
初始条件：  队列Q存在
操作结果：  向队列Q中插入一个元素e
函数参数：  队列Q，待插入元素e
返回值：    无
------------------------------------------------------*/
void InsertQueue(LinkQueue *Q, int e)
{
    QueuePtr p;
    p = (QueuePtr)malloc(sizeof(QNode));
    if(p == NULL)
    {
        printf("动态分配内存失败");
        exit(-1);
    }
    p->data = e;
    p->next = NULL;
    Q->rear->next = p;
    Q->rear = p;
    return ;
}
/*-----------------------------------------------------
操作目的：  删除元素
初始条件：  队列Q存在
操作结果：  从队列Q中删除一个元素
函数参数：  队列Q，待存放删除元素的变量e
返回值：    true,false
-------------------------------------------------------*/
bool DeQueue(LinkQueue *Q, int *e)
{
    QueuePtr p = Q->front->next;
    if(QueueEmpty(Q))
    {
        return false;
    }
    else
    {
        Q->front->next = p->next;
        *e = p->data;
        if(Q->rear == p)
            Q->rear = Q->front;
        return true;
    }
}
/*-----------------------------------------------------
操作目的：  遍历队列
初始条件：  队列Q存在
操作结果：  遍历出队列的元素
函数参数：  队列Q
返回值：    无
-------------------------------------------------------*/
bool QueueTraverse(LinkQueue *Q)
{
    QueuePtr p = Q->front->next;
    if(QueueEmpty(Q))
    {
        return false;
    }
    else
    {
        while(p != NULL)
        {
            printf("%d ",p->data);
            p = p->next;
        }
        return true;
    }
}

int main()
{
    int length,temp,temp_save;
    LinkQueue Queue;
    InitQueue(&Queue);
    if(QueueEmpty(&Queue))
    {
        printf("队列为空\n");
    }
    else
        printf("队列不为空\n");
    //DestroyQueue(&Queue);
    InsertQueue(&Queue, 1);
    InsertQueue(&Queue, 2);
    InsertQueue(&Queue, 3);
    InsertQueue(&Queue, 4);
    InsertQueue(&Queue, 5);
    QueueTraverse(&Queue);
    length = QueueLength(&Queue);
    printf("\n");
    printf("链队列的个数为：%d\n",length);
    if(GetHead(&Queue, &temp))
    {
        printf("%d\n",temp);
    }
    if(DeQueue(&Queue, &temp_save))
    {
        printf("%d\n",temp_save);
    }
    QueueTraverse(&Queue);
    ClearQueue(&Queue);
    if(QueueEmpty(&Queue))
    {
        printf("队列为空\n");
    }
    else
        printf("队列不为空\n");
}










喜欢哲学的女孩
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构——队列
m0_63020222的博客
03-21 3206
带头结点的单链表实现队列
队列的基本操作（顺序队列，循环队列，链队列）
So_cute_SJM的博客
01-17 2884
一. 定义： 和栈相反，队列是一种“先进先出”的线性表。即它只能在表的一端进行插入，在表的另一端删除元素。 在队列中，允许插入的一段叫做队尾，允许删除的一端则称为队头。 队列的插入操作称为进队，删除操作称为出队。 新插入的元素只能添加到队尾，被删除的元素只能是排在队头的元素。 二. 队列的顺序表示和实现： (一) . 顺序队列： 队列的顺序存储结构简称为“顺序队列”，它是由一个一维数...
数据结构之——队列详解
最新发布
2302_81016149的博客
05-12 1165
我们前面已经学习了栈，今天我们来学习队列，队列和栈一样，相对来说比较简单，随后，会为大家准备OJ练习题，敬请期待！只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出进行插入操作的一端称为队尾进行删除操作的一 端称为队头这里简单给大家解释一下：大家肯定都排过队（别说没有，我不信），大家在排好队先前前进时，是不是先站到队伍里的先走。队列的原理何其类似。因为，你可以猜一猜它为什么叫队列。可用下面图片帮助大家理解。明白了，基础知识，那就一起来实现一下队列吧。
【数据结构】链队列
weixin_56499830的博客
04-05 2447
文章目录1.链队列2.链式队列的头文件与函数声明3.函数3.1初始化3.2入队3.3出队3.4获取队头元素值3.5判空3.6查找3.7获取有效元素个数3.8销毁4.链队列的源文件与函数实现 1.链队列 链式队列----用链表实现，链式队列就是一个操作受限的单向链表 之前单链表结构体设计的时候，当时发现头节点所需要的成员变量(next域)，有效节点里都有，所以我们当时单链表头节点直接借用别人有效数据节点的结构体设计 所以我们之前常说头节点的数据域不使用，浪费掉。 现在设计链式队列，就会发现头节点需要两个指针
【数据结构】队列（queue）-链队列（图解、c++、java）
扑腾的江鱼复习仓库
01-20 2477
URLeisure的链队列“完美”复习资料。
数据结构：链队列
05-30
在众多的数据结构中，链队列是一种常用且实用的结构，尤其适用于处理动态变化的数据集合。本篇文章将详细探讨链队列，包括它的定义、工作原理以及如何在实际编程中实现。 链队列，顾名思义，是基于链表实现的队列...
头歌数据结构循环队列及链队列的基本操作
05-18
头歌数据结构循环队列及链队列的基本操作 第1关循环队列的基本操作 第2关链队列的基本操作 稳过 栈是一种后进先出的数据结构，而在实际问题中还经常使用一种“先进先出”的数据结构。队列就是从日常生活中的排队...
数据结构链队列基本操作
09-17
链队列是数据结构中一种特殊类型的队列，它利用链表作为底层数据结构实现队列的特性。在本文中，我们将深入探讨链队列的基本操作，以及如何使用C++实现一个无错误的链队列。 首先，理解链队列的概念至关重要。链...
数据结构链队列的基本运算.cpp
08-13
数据结构（严蔚敏）实验代码
php 数据结构之链表队列
10-19
链表队列是一种数据结构，它结合了链表和队列的特点。在计算机科学中，链表是一种线性数据结构，其中的元素不是在内存中连续存储的，而是通过指针链接。而队列是一种先进先出（FIFO, First In First Out）的数据结构...
数据结构中循环队列的清空、销毁、求队长、遍历、取首元素等操作及运用
热门推荐
wys_NO1的博客
11-03 1万+
数据结构中队列有好几种形式，本文写的是循环队列，以下为原创代码。创建c++工程： 头文件一：基本定义和头文件 #include"stdlib.h" #include"stdio.h" #define MAXQSIZE 100 #define OK 1 #define ERROR -1 #define TURE 1 #define FALSE 0 #define O
队列的定义和算法的实现
进击的Explorer
08-29 749
与栈相反，队列（queue） 是一种先进先出 （first in first out，缩写为FIFO ）的线性表。它只允许在表的一端进行插入，而在另一端删除元素。在队列中，允许插入的一端叫做队尾 （rear），允许删除的一端则称为 队头（front）。 1、链队列–队列的链式表示和实现 用链表表示的队列简称为链队列 ，一个链队列需要两个分别指示队头和队尾的指针（分别称为头指针和尾指针）才能唯一确定。我们给链队列添加一个头结点，并令头指针指向头结点。因此，空的链队列的判决条件为头指针和尾指针均指向头结点。如下
数据结构篇——链队列
handsomeRE的博客
07-03 1955
数据结构篇——链队列
【数据结构】队列的介绍
WINGREZ‘S BLOG
08-01 2815
参考资料：《数据结构（C语言版）严蔚敏著》 版权说明：未经作者允许，禁止转载。如引用本文内容，需标明作者及出处。如本文侵犯了您的权益，请联系我删除并致歉。 文章说明：如文章中出现错误，请联系我更改。如您对文章的内容有任何疑问，也欢迎来与我讨论。 本文正在施工中...请稍等... 队列的介绍 基本概念 1、队列是一种特殊的线性表，它只允许在表的一端进行插入操作，而在另一端进行删除操作。 2、队...
【数据结构】队列（链式队列）
一个喜欢猫咪的程序员
12-12 713
【数据结构】队列（链式队列）的实现
数据结构：队列之链队列
weixin_42072280的博客
03-11 1206
队列的链式存储 简称链队列，它是限制仅在表头进行删除操作和表尾进行插入操作的单链表。 队列的链式存储类型描述： //链式队列结点 typedef struct LinkNode{ dataType data; struct LinkNode *next; }LinkNode; //链式...
12.数据结构 队列_链队列_队列的链式表示和实现
打工人的博客
10-27 199
typedef int QElemType; typedef struct QNode { QElemType data; QNode *next; }*QueuePtr; struct LinkQueue { QueuePtr front, rear;//队头、队尾指针 }; 在这里插入代码片
队列当前元素个数计算
12november的博客
05-22 4955
（rear+maxSize-front）%MaxSize
数据结构链队列的实现
11-03
链队列是一种基于链表实现的队列，它的队头和队尾分别位于链表的头部和尾部。链队列的实现需要定义一个队列结构体，包含队头和队尾指针，以及链表节点结构体，包含数据域和指向下一个节点的指针。链队列的入队操作需要在队尾插入新节点，出队操作需要在队头删除节点。具体实现细节如下： ```C++ // 定义链表节点结构体 struct Node { int data; Node* next; }; // 定义链队列结构体 struct Queue { Node* front; // 队头指针 Node* rear; // 队尾指针 }; // 初始化链队列 void initQueue(Queue& q) { q.front = q.rear = new Node{0, nullptr}; // 创建一个空节点作为哨兵节点 } // 判断链队列是否为空 bool isEmpty(Queue& q) { return q.front == q.rear; } // 入队操作 void enqueue(Queue& q, int x) { Node* newNode = new Node{x, nullptr}; // 创建新节点 q.rear->next = newNode; // 将新节点插入队尾 q.rear = newNode; // 更新队尾指针 } // 出队操作 void dequeue(Queue& q) { if (isEmpty(q)) return; // 队列为空，直接返回 Node* p = q.front->next; // 指向队头节点 q.front->next = p->next; // 删除队头节点 if (q.rear == p) q.rear = q.front; // 如果队列只有一个节点，更新队尾指针 delete p; // 释放节点内存 } ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值