数据结构—链队的操作及实现（CC++）

已于 2022-07-11 08:00:36 修改
阅读量577 收藏 1
点赞数
分类专栏： 链队列 文章标签： 数据结构 队列
于 2021-07-27 10:53:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52166656/article/details/119138423
版权

数据结构—链队的操作及实现（C/C++）

文章目录

1.0初始化定义

#include<iostream>
#include<cstdlib>
#define MAXSIZE 100    //定义数组的最大长度
#define OK 1
#define OVERFLOW -1
#define ERROR -1
typedef int QElemType;    // 自己定义的类型
typedef int status;      //  上同 
using namespace std;

1.1链队的结构体定义

typedef struct QNode
{
	QElemType data;   
	struct QNode *next;
}QNode,*Queueptr;
//嵌套定义
typedef struct
{
	Queueptr front; //Queueptr类型的头指针
	Queueptr rear;	//Queueptr类型的尾指针
}LinkQueue;//也就是说Queueptr类型的头指针里面包括数据域和next域

1.2链队列的入队操作

status ENQueue(LinkQueue *Q,QElemType e)
{
	QNode*p;
	p=new QNode;
	p->data=e; 
	p->next=NULL;
	Q->rear->next=p;
	Q->rear=p;
	return OK;
}

1.3链队列的出队操作

status DeQueue(LinkQueue *Q,QElemType *e)
{
	QNode*p;
	if(Q->front==Q->rear) 
	return ERROR;
	p=Q->front->next;
	*e=p->data;
	Q->front->next=p->next;
	if(Q->rear==p)	
	Q->rear=Q->front;
	delete p;
	return OK;
}

1.4取链队的队头元素

status GetHead(LinkQueue *Q)
{
	if(Q->front==Q->rear)
	{
		return ERROR;
	}
	else
	{
		return Q->front->next->data;
	}
}

1.5输出队列的元素

status printQueue(LinkQueue *Q)
{
	cout<<"当前队列:";
	Queueptr p=Q->front->next;
	while(p)
	{
		cout<<'\40'<<p->data ;
		p=p->next;
	}
	cout<<endl;
	return OK;
}

1.6求链队的长度

status QueueLength(LinkQueue *Q)
{
	int Length=0;
	if(Q->front==Q->rear)
	{
		return 0;
	}
	Queueptr p=Q->front->next;
	while(p)
	{
		p=p->next;
		Length++;
	}
	return Length;
}

1.7 C 主函数部分

int main()
{
	int n,m,t;
	QElemType e;
	LinkQueue Q;
	InitQueue(&Q);
	printf("请输入需要入队的次数：");
	scanf("%d",&n);
	for(int i=1 ;i<=n;i++)
	{
	printf("请输入第%d个元素的值：",i);
	scanf("%d",&m);
	ENQueue(&Q,m);
	}
	printQueue(&Q);
	printf("当前对头元素为：%d\n",GetHead(&Q));
	printf("当前链队长度为：%d\n",QueueLength(&Q));
	printf("\n");
	printf("\n");
	printf("请输入需要出队的次数：");
	scanf("%d",&t);
	for(int i=1;i<=t;i++)
	{
	DeQueue(&Q,&e);
	}
	printQueue(&Q);
	printf("当前对头元素为：%d\n",GetHead(&Q));
	printf("当前链队长度为：%d\n",QueueLength(&Q));
	return 0;
}

1.8 C++主函数部分

int main()
{
	int n,m,t;
	QElemType e;
	LinkQueue Q;
	InitQueue(&Q);
	cout<<"请输入需要入队的次数：";
	cin>>n;
	for(int i=1 ;i<=n;i++)
	{
	cout<<"请输入第"<<i<<"个元素的值：";
	cin>>m;
	ENQueue(&Q,m);
	}
	printQueue(&Q);
	cout<<"当前对头元素为："<<GetHead(&Q)<<endl;
	cout<<"当前链队长度为："<<QueueLength(&Q);
	cout<<endl<<endl;
	cout<<"请输入需要出队的次数：";
	cin>>t;
	for(int i=1;i<=t;i++)
	{
	DeQueue(&Q,&e);
	}
	printQueue(&Q);
	cout<<"当前对头元素为："<<GetHead(&Q)<<endl;
	cout<<"当前链队长度为："<<QueueLength(&Q);
	return 0;
}

1.9 C全部代码

#include<stdio.h>
#include<stdlib.h>
#define MAXSIZE 100    //定义数组的最大长度
#define OK 1
#define OVERFLOW -1
#define ERROR -1
typedef int QElemType;    // 自己定义的类型
typedef int status;      //  上同 
//链队列定义
typedef struct QNode
{
	QElemType data;   
	struct QNode *next;
}QNode,*Queueptr;
//嵌套定义
typedef struct
{
	Queueptr front; //Queueptr类型的头指针
	Queueptr rear;	//Queueptr类型的尾指针
}LinkQueue;//也就是说Queueptr类型的头指针里面包括数据域和next域

//链队列的初始化
status InitQueue(LinkQueue *Q)
{
	Q->front=Q->rear=(QNode*)malloc(sizeof(QNode)); //为头指针和尾指针开辟动态空间
	Q->front->next=NULL;     //初始头指针的next为空
	return OK;
}
//链队列的入队操作
status ENQueue(LinkQueue *Q,QElemType e)
{
	QNode*p;
	p=new QNode;
	p->data=e; 
	p->next=NULL;
	Q->rear->next=p;
	Q->rear=p;
	return OK;
}
//链队列的出队操作
status DeQueue(LinkQueue *Q,QElemType *e)
{
	QNode*p;
	if(Q->front==Q->rear) 
	return ERROR;
	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 GetHead(LinkQueue *Q)
{
	if(Q->front==Q->rear)
	{
		return ERROR;
	}
	else
	{
		return Q->front->next->data;
	}
}
//输出队列的元素
status printQueue(LinkQueue *Q)
{
	printf("当前队列:");
	Queueptr p=Q->front->next;
	while(p)
	{
		printf("%4d",p->data);
		p=p->next;
	}
	printf("\n");
	return OK;
}
//求链队的长度
status QueueLength(LinkQueue *Q)
{
	int Length=0;
	if(Q->front==Q->rear)
	{
		return 0;
	}
	Queueptr p=Q->front->next;
	while(p)
	{
		p=p->next;
		Length++;
	}
	return Length;
}

int main()
{
	int n,m,t;
	QElemType e;
	LinkQueue Q;
	InitQueue(&Q);
	printf("请输入需要入队的次数：");
	scanf("%d",&n);
	for(int i=1 ;i<=n;i++)
	{
	printf("请输入第%d个元素的值：",i);
	scanf("%d",&m);
	ENQueue(&Q,m);
	}
	printQueue(&Q);
	printf("当前对头元素为：%d\n",GetHead(&Q));
	printf("当前链队长度为：%d\n",QueueLength(&Q));
	printf("\n");
	printf("\n");
	printf("请输入需要出队的次数：");
	scanf("%d",&t);
	for(int i=1;i<=t;i++)
	{
	DeQueue(&Q,&e);
	}
	printQueue(&Q);
	printf("当前对头元素为：%d\n",GetHead(&Q));
	printf("当前链队长度为：%d\n",QueueLength(&Q));
	return 0;
}

2.0 C++全部代码

#include<iostream>
#include<cstdlib>
#define MAXSIZE 100    //定义数组的最大长度
#define OK 1
#define OVERFLOW -1
#define ERROR -1
typedef int QElemType;    // 自己定义的类型
typedef int status;      //  上同 
using namespace std;

//链队列定义
typedef struct QNode
{
	QElemType data;   
	struct QNode *next;
}QNode,*Queueptr;
//嵌套定义
typedef struct
{
	Queueptr front; //Queueptr类型的头指针
	Queueptr rear;	//Queueptr类型的尾指针
}LinkQueue;//也就是说Queueptr类型的头指针里面包括数据域和next域

//链队列的初始化
status InitQueue(LinkQueue *Q)
{
	Q->front=Q->rear=new QNode; //为头指针和尾指针开辟动态空间
	Q->front->next=NULL;     //初始头指针的next为空
	return OK;
}
//链队列的入队操作
status ENQueue(LinkQueue *Q,QElemType e)
{
	QNode*p;
	p=new QNode;
	p->data=e; 
	p->next=NULL;
	Q->rear->next=p;
	Q->rear=p;
	return OK;
}
//链队列的出队操作
status DeQueue(LinkQueue *Q,QElemType *e)
{
	QNode*p;
	if(Q->front==Q->rear) 
	return ERROR;
	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 GetHead(LinkQueue *Q)
{
	if(Q->front==Q->rear)
	{
		return ERROR;
	}
	else
	{
		return Q->front->next->data;
	}
}
//输出队列的元素
status printQueue(LinkQueue *Q)
{
	cout<<"当前队列:";
	Queueptr p=Q->front->next;
	while(p)
	{
		cout<<'\40'<<p->data ;
		p=p->next;
	}
	cout<<endl;
	return OK;
}
//求链队的长度
status QueueLength(LinkQueue *Q)
{
	int Length=0;
	if(Q->front==Q->rear)
	{
		return 0;
	}
	Queueptr p=Q->front->next;
	while(p)
	{
		p=p->next;
		Length++;
	}
	return Length;
}

int main()
{
	int n,m,t;
	QElemType e;
	LinkQueue Q;
	InitQueue(&Q);
	cout<<"请输入需要入队的次数：";
	cin>>n;
	for(int i=1 ;i<=n;i++)
	{
	cout<<"请输入第"<<i<<"个元素的值：";
	cin>>m;
	ENQueue(&Q,m);
	}
	printQueue(&Q);
	cout<<"当前对头元素为："<<GetHead(&Q)<<endl;
	cout<<"当前链队长度为："<<QueueLength(&Q);
	cout<<endl<<endl;
	cout<<"请输入需要出队的次数：";
	cin>>t;
	for(int i=1;i<=t;i++)
	{
	DeQueue(&Q,&e);
	}
	printQueue(&Q);
	cout<<"当前对头元素为："<<GetHead(&Q)<<endl;
	cout<<"当前链队长度为："<<QueueLength(&Q);
	return 0;
}

2.1运行截图

在这里插入图片描述

2.2参考书籍

《数据结构》(C语言版)（第2版）—严蔚敏 李冬梅 吴伟民 编著

2.3总结

多多关注！

芙如东海
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
《数据结构 1800题》
12-27
9. 数据结构的抽象操作的定义与具体实现有关。( )【华南理工大学 2002 一、1（1分）】 10. 在顺序存储结构中，有时也存储数据结构中元素之间的关系。( )【华南理工大学 2002 一、2 （1分）】 11. 顺序存储方式的...
操作系统银行家算法课程设计，任务书及源程序
03-03
为实现银行家算法，系统必须设置若干数据结构。 ———————————————— 版权声明：本文为CSDN博主「魏宇轩」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。 原文链接：...
C/C++实现队列的链式结构（链队）
m0_54202580的博客
10-17 1996
定义：用链表表示的队列简称为链队列。为了操作方便，这里采用带头结点的链表结构，并设置一个队头front和一个队尾指针rear，如图①图②所示。对头指针始终指向头结点，队尾指针指向最后一个元素。空的链队列的队头指针和队尾指针均指向头结点。 队列的基操作： ①InitQueue（Q） ②IsEmpty（Q） ③IsFull（Q） ④EnterQueue（Q） ⑤DeleteQueue（Q） ⑥GetHead（Q） ⑦ClearQueue（Q） ...
【数据结构C/C++】顺序与链式队列详解(附代码)
Zhangsama1的博客
08-17 9256
文章目录前言一、顺序队列二、链式队列1.引入库2.读入数据总结 前言 队列(queue)是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。队列是一种先进先出(First Input First Ouput)，的线性表，简称FIFO。允许插入的一端称为队尾，允许删除的一端称为队头。 既然是线性表，那么就可以分为顺序存储结构和链式存储结构。 队列存储结构的实现有以下两种方式： 顺序队列：在顺序表的基础上实现的队列结构； 链队列：在链表的基础上实现的队列结构；
队列与栈（模板）
csdn_lfy的博客
04-16 332
栈和队列都属于特殊的线性表 队列 #include <iostream> //循环队列 using namespace std; const int QueueSize=100;//100示例性数据 template<typename DataType> class CirQueue { public: CirQueue();//初始化空队列 ...
C语言 队列（循环队列和链队初始化进出队等基本操作）
热门推荐
m0_73070900的博客
04-23 1万+
循环队列、链队的初始化、进队和出队等基本操作-----
C++队列实现（链表）
jerryhao0216的博客
03-19 554
通俗的说，队列类似于我们日常生活中的排队，这个数据结构与栈不同，栈是先进后出（类似于弹匣），而队列是先进先出。此处引用百度百科对于队列的定义：队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。
python数据结构与算法详解与源码
08-20
数据结构与算法（Python） 一、引入概念 1-01算法引入 1-02 时间复杂度与大O表示法 1-03-最坏时间复杂度与计算规则 1-04-常见时间复杂度与大小关系 1-05-代码执行时间测量模块 1-06-Python列表类型不同操作的...
TD-SCDMA第三代移动通信系统、信令及实现
08-03
全书按其自然结构分为上篇和下篇：上篇主要介绍了3GPP定义的第三代移动通信系统的网络结构及接口规范。下篇（从第6章开始）详细介绍了用户终端设备协议栈的开发流程以及开发过程中使用的工具。希望读者通过对协议栈...
C语言实现对象编程之多态代码.rar
06-16
C++虚表方式的本质和包含的各个函数指针的操作数据结构类似。 ———————————————— 版权声明：本文为CSDN博主「沧海一笑-dj」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。...
【数据结构】链式队列的基本操作（C++）
weixin_63614711的博客
11-23 1784
数据结构——链式队列的基本操作
链队列（详解）---＞数据结构、C++实现
m0_54158068的博客
03-30 6731
链队列（详解）--->数据结构（队列）、C++实现
C++链式队列实现
Alexon Xu的博客
01-17 711
链式队列具有内存动态分配，内存利用率高的特点，在一些无法预先估计所需队列大小的场合使用链式队列是一个十分好的选择。下面是我最近学习链式队列的代码。注意这里的头结点不存储数据。 首先，要实现链式队列，首先要构造相应的数据结构，这里考虑使用两个指针分别指向队列的队头和队尾，队列使用单链表实现。代码如下：#include #include #include
链队列的C++实现
m0_73678116的博客
04-01 159
链队列从本质上来看就是操作受限的单链表，其中表尾代表队头，首元结点代表队尾（方便插入操作）。编写主函数测试：sketch.cpp。头文件：LinkQueue.hpp。每天都要加油哦 ^_^
链队列和循环队列的表示与实现-初始化、判空、求长、入队、出队、遍历、求头、求尾、清队、毁队
刘明的博客
06-04 4558
队列：队列是一种先进先出(first in first out,FIFO)的线性表。它只允许在一端进行插入，而在另一端进行删除的元素。在队列中允许插入的元素叫做队尾，允许删除的一端叫做队头。其结构如下：        1、链队列-----队列的链式表示与实现       链队列：用链表表示的队列；        一个链队列需要两个分别指示队头和队尾的指针（头指针和尾指针）才能唯一确定。
【数据结构】 链队列的基本操作 （C语言版）
最新发布
weixin_56814370的博客
01-24 1930
【数据结构】 链队列的基本操作 （C语言版）
链队的C++实现
抚琴弹出情凋零的博客
08-25 804
仅供参考 #include <iostream> using namespace std; // 函数结果状态代码 #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASIBLE -1 #define OVERFLOW -2 #define MAXSIZE ...
数据结构【队列】
huajian225的博客
06-15 2687
队列的概念 顺序队列 循环队列 顺序循环队列的ADT定义 1、简单结构体定义 2、初始化 3、队列的清空 4、计算队列的长度 5、判断队列是否为空 6、插入新的元素 7、元素的删除 8、遍历输出队列内的所有元素 链队列的ADT定义 1、链队列简单结构体定义 2、初始化链队列 3、判断链队列是否为空 4、清空链队列 5、销毁链队列 6、获取链队列的长度 7、获取链队列的头元素 8、在链队列尾插入新元素 9、删除链队列的头元素 10、遍历链队列中的元素 顺序队列和链式队列的比较
链队列的初始化，入队，出队，取对头元素功能实现
naozibuok的博客
04-20 2744
链队列是一种基于链表实现的队列结构，它通过移动头指针和尾指针来实现出队和入队。链队列包含多个结点，每个结点都有一个数据域和一个指向下一节点的指针。当要将元素添加到链队列时，只需新建一个结点，并将该结点加入到链表末尾即可，取出元素时，则只需获取链表头节点中的数据域，并释放该节点的空间。二、初始化图解printf("创建成功！\n");
cc++ 如何高效处理几个GB的数据的计算操作
06-11
处理几个GB的数据需要考虑内存的限制和计算的效率。以下是一些提高计算效率的方法： 1. 分批处理：将数据分批读入内存，进行计算后再输出结果，可以避免内存溢出的问题。 2. 使用多线程：利用多线程并行计算可以提高计算速度，但需要注意线程之间的同步和互斥。 3. 优化算法：选择合适的算法可以减少计算量，例如使用快速排序代替冒泡排序。 4. 利用硬件加速：使用GPU等硬件加速器可以大幅提高计算速度，但需要注意数据传输的效率。 5. 内存映射文件：使用内存映射文件可以将文件映射到内存中，避免频繁的IO操作，提高计算速度。 需要根据具体的场景和数据特点选择合适的方法来提高计算效率。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值