【数据结构】 链队列的基本操作 （C语言版）

于 2024-01-24 21:28:12 发布
阅读量1.8k 收藏 35
点赞数 21
文章标签： 数据结构 c语言 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_56814370/article/details/135831656
版权

目录

一、链队列

1、链栈的定义：

2、链栈的优缺点：

二、链队列的基本操作算法（C语言）    

1、宏定义

  2、创建结构体

3、链栈的初始化 

4、链队列的入队 

5、链队列的出队

6、取链队列的对头元素

7、链队列的销毁

8、链队列的清空

9、判断链队列是否为空

10、求队列长度

 11、遍历队列元素

三、链队列的基本操作完整代码（C语言）

  四、运行结果

一、链队列

1、链栈的定义：

链队列是一种线性数据结构，采用链表来实现队列的操作。链队列具有队头指针和队尾指针，用于指示队列元素所在的位置。链队列只允许在队尾插入元素，在队头删除元素，符合先进先出（First In First Out，FIFO）的原则。

2、链栈的优缺点：

链队列的优点：

  1. 动态分配空间：链队列使用链表实现，可动态分配和释放空间。因此，不需要预先分配大量存储空间，可以根据实际需求进行空间分配。
  2. 无需移动元素：相比普通队列，链队列在删除元素时无需移动大量元素，只需修改指针即可。这使得链队列在处理大规模数据时具有更高的效率。
  3. 适合处理用户排队等待的情况：链队列适用于处理用户排队等待的情况，例如银行排队、网络请求等。通过链队列，可以快速地插入新用户和删除已处理的用户。

链队列的缺点：

  1. 需要额外的存储空间：为了实现链表结构，链队列需要额外的存储空间来维护指针和节点。这会增加存储空间的消耗。
  2. 插入和删除操作可能引起内存分配和释放：在链队列中插入和删除元素时，可能需要动态分配和释放内存。这会增加操作的时间复杂度，并可能引起内存碎片化问题。
  3. 无法充分利用连续空间的优势：链表结构使得链队列无法像数组一样充分利用连续空间的优势，这会影响空间利用率和访问速度。

二、链队列的基本操作算法（C语言）    

1、宏定义
#define OK 1
#define ERROR 0
#define OVERFLOW -1

#define MAXSIZE 100

typedef int QElemtype;
typedef int Status;
  2、创建结构体
//创建结构体
typedef struct QNode {
    QElemtype data;
    struct QNode *next;
} QNode, *QueuePtr;

typedef struct {
    QueuePtr front;
    QueuePtr rear;
} LinkQueue;
3、链栈的初始化 
//链队列的初始化
Status InitQueue(LinkQueue &Q) {
    Q.front = Q.rear = (QueuePtr) malloc(sizeof(QNode));
    if (!Q.front) {
        exit(OVERFLOW);
    }
    Q.front->next = NULL;
    return OK;
}
4、链队列的入队 
//链队列的入队 
Status EnQueue(LinkQueue &Q, QElemtype e) {
    QueuePtr p = (QueuePtr) malloc(sizeof(QNode));
    if (!p) {
        exit(OVERFLOW);
    }
    p->data = e;
    p->next = NULL;
    Q.rear->next = p;
    Q.rear = p;
    return OK;
}
5、链队列的出队
//链队列的出队
Status DeQueue(LinkQueue &Q, QElemtype &e) {
    if (Q.front == Q.rear) {
        return ERROR;
    }
    QueuePtr p = Q.front->next;
    e = p->data;
    Q.front->next = p->next;
    if (Q.rear == p) {
        Q.rear = Q.front;
    }
    delete p;
    return OK;

}
6、取链队列的对头元素
//取链列的对头元素 
Status GetQueueHead(LinkQueue &Q, QElemtype &e) {
    if (Q.front == Q.rear) {
        return ERROR;
    }
    e = Q.front->next->data;
    return OK;

}
7、链队列的销毁
//队列的销毁
Status DestoryQueue(LinkQueue &Q) {
    while (Q.front) {
        Q.rear = Q.front->next;
        delete (Q.front);
        Q.front = Q.rear;
    }
//    printf("销毁成功！");
    return OK;
}
8、链队列的清空
//清空
Status ClearQueue(LinkQueue &Q) {
    Q.rear = Q.front->next;
    while (Q.front->next) {
        Q.rear = Q.rear->next;
        delete (Q.front->next);
        Q.front->next = Q.rear;
    }
    Q.rear = Q.front;
//    printf("清空成功！");
    return OK;
}
9、判断链队列是否为空
//判断是否为空
Status QueueEmpty(LinkQueue &Q) {
    if (Q.front == Q.rear) {
//        printf("队列为空！\n");
        return true;
    } else {
        return false;
    }
//    printf("该队列不为空！");
}
10、求队列长度
//求队列长度
Status QueueLength(LinkQueue Q) {
    int i = 0;
    while (Q.front != Q.rear) {
        i++;
        Q.front = Q.front->next;
    }
//    printf("该队列长度为：%d", i);
    return i;
}
 11、遍历队列元素
//遍历队列
Status QueueTraverse(LinkQueue Q) {
    QNode *p;
    if (Q.front == Q.rear) {
        return ERROR;
    }
    p = Q.front->next;//存储头元素
    printf("从队头依次读出该队列中的元素值为: ");
    while (p != NULL) {
        printf("%d ", p->data);
        p = p->next;
    }
    printf("\n");
    return OK;
}

三、链队列的基本操作完整代码（C语言）

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

#define OK 1
#define ERROR 0
#define OVERFLOW -1

#define MAXSIZE 100

typedef int QElemtype;
typedef int Status;

//创建结构体
typedef struct QNode {
    QElemtype data;
    struct QNode *next;
} QNode, *QueuePtr;

typedef struct {
    QueuePtr front;
    QueuePtr rear;
} LinkQueue;

//链队列的初始化
Status InitQueue(LinkQueue &Q) {
    Q.front = Q.rear = (QueuePtr) malloc(sizeof(QNode));
    if (!Q.front) {
        exit(OVERFLOW);
    }
    Q.front->next = NULL;
    return OK;
}

//链队列的入队 
Status EnQueue(LinkQueue &Q, QElemtype e) {
    QueuePtr p = (QueuePtr) malloc(sizeof(QNode));
    if (!p) {
        exit(OVERFLOW);
    }
    p->data = e;
    p->next = NULL;
    Q.rear->next = p;
    Q.rear = p;
    return OK;
}

//链队列的出队
Status DeQueue(LinkQueue &Q, QElemtype &e) {
    if (Q.front == Q.rear) {
        return ERROR;
    }
    QueuePtr p = Q.front->next;
    e = p->data;
    Q.front->next = p->next;
    if (Q.rear == p) {
        Q.rear = Q.front;
    }
    delete p;
    return OK;

}

//取链列的对头元素 
Status GetQueueHead(LinkQueue &Q, QElemtype &e) {
    if (Q.front == Q.rear) {
        return ERROR;
    }
    e = Q.front->next->data;
    return OK;

}


//队列的销毁
Status DestoryQueue(LinkQueue &Q) {
    while (Q.front) {
        Q.rear = Q.front->next;
        delete (Q.front);
        Q.front = Q.rear;
    }
//    printf("销毁成功！");
    return OK;
}

//清空
Status ClearQueue(LinkQueue &Q) {
    Q.rear = Q.front->next;
    while (Q.front->next) {
        Q.rear = Q.rear->next;
        delete (Q.front->next);
        Q.front->next = Q.rear;
    }
    Q.rear = Q.front;
//    printf("清空成功！");
    return OK;
}


//判断是否为空
Status QueueEmpty(LinkQueue &Q) {
    if (Q.front == Q.rear) {
//        printf("队列为空！\n");
        return true;
    } else {
        return false;
    }
//    printf("该队列不为空！");
}

//求队列长度
Status QueueLength(LinkQueue Q) {
    int i = 0;
    while (Q.front != Q.rear) {
        i++;
        Q.front = Q.front->next;
    }
//    printf("该队列长度为：%d", i);
    return i;
}


//遍历队列
Status QueueTraverse(LinkQueue Q) {
    QNode *p;
    if (Q.front == Q.rear) {
        return ERROR;
    }
    p = Q.front->next;//存储头元素
    printf("从队头依次读出该队列中的元素值为: ");
    while (p != NULL) {
        printf("%d ", p->data);
        p = p->next;
    }
    printf("\n");
    return OK;
}


//功能菜单列表
void show_help() {
    printf("******* 功能菜单列表 *******\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("10----退出------------------\n\n");
}


//主函数
int main() {
    LinkQueue LQ;
    Status reIn = InitQueue(LQ);
    if (reIn == OK) {
        printf("链队列初始时成功  \n");
    } else {
        printf("链队列初始时失败 \n");
    }

    while (1) {

        //功能菜单列表
        show_help();

        int flag;
        printf("请输入所需的功能编号：\n");
        scanf("%d", &flag);

        switch (flag) {
            case 1: {//入队
                Status EnQueueindex;
                printf("请输入插入元素(请在英文状态下输入例如:1): \n");
                scanf("%d", &EnQueueindex);
                Status rEnQueue = EnQueue(LQ, EnQueueindex);
                if (rEnQueue == OK) {
                    printf("向链队列入队%d成功！\n", EnQueueindex);
                } else {
                    printf("向链队列入队失败！\n");
                }
            }
                break;
            case 2: {//求链队列的长度
                int length = QueueLength(LQ);
                printf("链队列的长度为:%d。 \n\n", length);
            }
                break;
            case 3: {//出队
                QElemtype DeElem;
                Status DeEn = DeQueue(LQ, DeElem);
                if (DeEn == OK) {
                    printf("从链队列中出队成功，出队的元素为 %d! \n", DeElem);
                } else {
                    printf("从链队列中出队失败！\n");
                }
            }
                break;
            case 4: {//求队头元素
                QElemtype getEl;
                Status reGet = GetQueueHead(LQ, getEl);
                if (reGet == OK) {
                    printf("从链队列中取对头元素成功，队头元素为:%d! \n", getEl);
                } else {
                    printf("从链队列中取对头元素成功 \n");
                }
            }
                break;
            case 5: { //清空
                Status rClearStack = ClearQueue(LQ);
                if (rClearStack == OK) {
                    printf("链队列清空成功！\n");
                } else {
                    printf("链队列清空失败！\n");
                }
            }
                break;
            case 6: {//销毁
                Status rDestroyStack = DestoryQueue(LQ);
                if (rDestroyStack == OK) {
                    printf("链队列销毁成功！\n");
                } else {
                    printf("链队列销毁失败！\n");
                }
            }
                break;
            case 7: {///判空
                Status ClearStatus = QueueEmpty(LQ);
                if (ClearStatus == true) {
                    printf("链队列为空！\n\n");
                } else {
                    printf("链队列不为空！\n\n");
                }
            }
                break;
            case 8: {//批量插入
                int on;
                printf("请输入想要插入的元素个数：\n");
                scanf("%d", &on);
                QElemtype array[on];
                for (int i = 1; i <= on; i++) {
                    printf("向链队列第%d个位置插入元素为:", i);
                    scanf("%d", &array[i]);
                }

                for (int i = 1; i <= on; i++) {
                    Status InsertStatus = EnQueue(LQ, array[i]);
                    if (InsertStatus == OK) {
                        printf("向链队列第%d个位置插入元素%d成功！\n", i, array[i]);
                    } else {
                        printf("向链队列第%d个位置插入元素%d失败！\n", i, array[i]);
                    }
                }
            }
                break;
            case 9: {//输出链表元素
                QueueTraverse(LQ);
//                printf("\n");
            }
                break;
            case 10: {//退出程序
                return 0;
            }
                break;
            default: {
                printf("输入错误，无此功能，请检查输入:\n\n");
            }
        }
    }


    return 1;
}

  四、运行结果

殊迟
关注
  • 21
    点赞
  • 踩
  • 35
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
头歌数据结构循环队列及链队列的基本操作
05-18
头歌数据结构循环队列及链队列的基本操作 第1关循环队列的基本操作 第2关链队列的基本操作 稳过 栈是一种后进先出的数据结构，而在实际问题中还经常使用一种“先进先出”的数据结构。队列就是从日常生活中的排队现象抽象出来的线性表。
数据结构之栈和队列的代码实现（C语言）
12-30
这个资源主要是使用C语言实现的栈和队列两种数据结构基本操作，包含栈的入栈、出栈，队列的入队列、出队列的相关操作，具体包含如下几个： 1、顺序栈：入栈、出栈、获取栈顶元素、打印栈。 2、链栈：入栈、出栈、获取栈顶元素、打印栈。 3、顺序队列：入队列、出队列、获取队头元素，打印队列。 4、循环队列：入队列、出队列、获取队头元素，打印队列。 5、链队列：入队列、出队列、获取队头元素，打印队列。
数据结构(C语言版)——链队列(代码版)
09-25
里面包含了c文件和exe文件，基本操作为:1:初始化链队列2:销毁链队列3:清空链队列4:链队列是否为空5:返回链队列头元素6:元素入队7:元素出队8:当前链队列长度
链式队列的基本运算
09-03
本程序共设计了单链表上多项式相加需要的的6个基本操作运算，分别是链式队列的入队，出队，遍历，长度，取队头，以及销毁队列操作。附带实验报告。
数据结构C语言实现之链式队列的6种算法代码
huayutiancheng的专栏
09-01 724
#include stdio.h> #include stdlib.h> typedef int elemType; /************************************************************************/ /* 以下是关于队列链接存储操作的6种算法 */ /*********************
链队列基本运算的实现
mmdev
11-09 510
//链队列基本运算的实现 #include&lt;iostream&gt; using namespace std; typedef char datatype; //队列元素类型，假设为字符型 typedef struct node * pointer; //结点指针类型 struct node //链队结点结构 { datatype data; pointer next; }...
数据结构:链队列的基本操作(C语言实现)
weixin_57425841的博客
04-06 4467
链队列是用链表作为存储结构的队列。队列的特点是先入先出，后入后出。这里采用带头结点的链表结构，并设置一个头指针front和一个尾指针rear始终指向头节点和队尾结点。 #include<stdio.h> #include<stdlib.h> typedef struct Node /*定义队列结点结构*/ { int data; /*数据域*/ struct Node *next; /*指针域*/ }LinkQueueNode; typede
C语言 队列（循环队列和链队初始化进出队等基本操作）
m0_73070900的博客
04-23 1万+
循环队列、链队的初始化、进队和出队等基本操作-----
链队列的基本操作
机会是给有准备的人
05-23 1447
队列的链接存储结构称为链队列（linked queue)，通常用单链表表示，其节点结构与单链表的节点结构相同，为了使空队列和非空队列的操作一致，链队列也加上头节点，根据队列的先进先出特性，为了操作上的方便，设置对头指针，指向链队列的头节点，对尾指针指向终点节点
c语言数据结构 链队列的基本操作
12-02
链队列的基本操作 （1）建立链表队列 （2）入队一个元素 （3）出队一个元素 c语言实现的哦！！！ 配c语言版的数据结构！！
数据结构(C语言版)[严蔚敏]
04-27
《数据结构》（c语言版）是为“数据结构”课程编写的教材，也可作为学习数据结构及其算法的C程序设计的参数教材。学了数据结构后,许多以前写起来很繁杂的代码现在写起来很清晰明了. 本书的前半部分从抽象数据类型的...
C语言单链队列的表示与实现实例详解
01-20
而单链队列使用链表作为基本数据结果，因此不存在伪溢出的问题，队列长度也没有限制。但插入和读取的时间代价会比较高 2.实例代码： /* 单链队列——队列的链式存储结构 */ typedef struct QNode { QElemType data...
数据结构实验——队列子系统
07-31
设计一个字符型的链队列；编写队列的进队、出队、读队头元素、显示队列中全部元素程序；设计一个选择式菜单，以菜单方式选择队列的各种基本操作。
头歌 顺序表，链表，循环队列的基本操作和应用答案。
05-03
头歌数据结构的题目： 顺序表的基本操作和应用 链表的基本操作和应用， 循环队列的应用 同时还有一些附加题，n皇后和钓鱼
《数据结构》（C语言版）严蔚敏
08-31
《数据结构》（C语言版）是为“数据结构”课程编写的教材，也可作为学习数据结构及其算法的C程序设计的参数教材。学了数据结构后,许多以前写起来很繁杂的代码现在写起来很清晰明了. 本书的前半部分从抽象数据类型的...
链式队列的基本操作（C实现）
m0_61395860的博客
02-10 4205
一、链队列简介。 和链栈相似，适用于动态存储，由于是先进先出原则，因此可以用单链表表示队列，并设置一个头指针（front）和一个尾指针(rear)，入队时，尾指针(rear)后移，出队时，头指针（front）后移。 二、具体操作 1.结构体定义和初始化 采用结构体套用的方法，链表的结构中有前指针和后指针，而结点中有数据域和直接后继域。 #include<stdio.h> #include<stdlib.h> #include<string.h> #defi
数据结构之链队列（C语言）
C2395850595的博客
05-17 859
一、链队列的概念 链队列：使用链表实现的队列；具有队头指针和队尾指针，指示队列元素所在的位置。 特点： 1、只能队尾插入元素、在队头删除元素。 2、先进先出的线性表，先进入的元素出队，后进入的元素才能出队。 优点： 3、相比普通的队列，元素出队时无需移动大量元素，只需移动头指针。 4、可动态分配空间，不需要预先分配大量存储空间。 二、代码功能 1、创建单链表 2、创建链队列 3、初始化链队列 4、链队列的输出 5、链队列的元素的添加（入队） 6、链队列元素的删除（出队).
数据结构——链式队列【c语言版】
clear-ninghongkang的博客
11-22 6782
队列（quque）简称队，只允许在表的一端输入，在表的另一端删除(操作受限制的线性表)， 把进行插入的一段叫做队尾（表尾），把进入删除的一端叫做队首或队头（表头）。 队列最主要的特点：先进先出，FIFO（first in first out） 队列有其实有三种：顺序队列、循环队列、链式队列 采用链式存储结构实现的队列称为链队 下面是采用单链表来实现链式队列的过程： 在链队中只允许单链表的表头进行删除操作（出队），表尾进行插入操作（入队），因此需要...
C语言实现数据结构——链队列
热门推荐
weixin_51408717的博客
10-15 1万+
定义 前面学习了栈这种数据结构，我们知道他的特点是数据先进后出。与栈相反，队列的特点时数据先进先出。即first in firsr out,简称FIFO。 队列只允许在表的一端进行数据的插入，在另一端进行数据的删除。这和生活中的排队是一致的，最早进入队列的最先离开。在链表中，允许插入数据的一端叫队尾（rear），允许删除数据的一端叫队头（front）。假设将数据a,b,c,d,e,f输入到一个队列中，那么输入的顺序是a,b,c,d,e,f。输出的顺序也是a,b,c,d,e,f。 基本操作 初始化一个队列
educoder实训教学平台数据结构c语言循环队列及链队列的基本操作
最新发布
10-23
循环队列是一种特殊的队列，其特点是队列的元素在物理结构上是环形排列的。educoder实训教学平台提供了循环队列的基本操作，包括初始化、入队、出队和判空等。 循环队列的初始化操作是创建一个空队列，并设置队列的头指针和尾指针都为0。入队操作是往队尾插入一个元素，插入后尾指针向后移动一位，并将元素放入新的队尾位置。出队操作是将队首元素删除，删除后头指针向后移动一位。判空操作是通过比较队列的头指针和尾指针是否相等来确定队列是否为空。 链队列是使用链表实现的队列，其特点是可以动态地分配内存空间，不会造成内存溢出的问题。educoder实训教学平台也提供了链队列的基本操作，包括初始化、入队、出队和判空等。 链队列的初始化操作是创建一个空队列，并设置头指针和尾指针都指向空节点。入队操作是在链队列的尾部插入一个新节点，尾指针向后移动一位，并将新节点的数据放入新的尾节点。出队操作是删除链队列的头节点，头指针向后移动一位。判空操作是通过判断链队列的头指针和尾指针是否指向同一节点来确定队列是否为空。 通过educoder实训教学平台提供的循环队列和链队列的基本操作，学习者可以掌握数据结构中队列的实现方式和基本操作的原理，进而应用于解决一些实际问题。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

殊迟

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

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

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

打赏作者

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

抵扣说明：

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

余额充值