C++实现单循环链的各种操作

已于 2022-07-03 15:59:43 修改
阅读量1.4k 收藏 16
点赞数 2
文章标签： c++ 开发语言 数据结构 链表 算法
于 2022-07-03 15:58:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_58240448/article/details/125585237
版权

1.什么是单链

        如果把单链表的最后一个节点的指针指向链表头部，而不是指向NULL，那么就构成了一个单向循环链表，通俗讲就是把尾节点的下一跳指向头结点。

                        

2.循环单链表节点结构体

         循环单链表的节点与普通单链表的节点相同并无本质的区别！

struct LNode {
	int data;    // 数据域
	LNode* next; // 指针域
};

typedef LNode LNode;     // LNode表示单链表的一个结点
typedef LNode* LinkList; // LinkList表示一个单链表

        对循环单链表节点进行初始化：主要还是为了避免异常！

bool InitList(LinkList& L) {
	L = new LNode;//C/语言中使用：L = (LNode *)malloc(sizeof(LNode));与前者作用等价申请新节点
	if (!L) {
		cout << "申请节点失败！" << endl;
		return false;
	}
	L->next = NULL;//初始化节点的后继指针为空，避免引起错误！
	return true;
}

3.对循环单链表的操作

 3.1打印循环单链表

bool PrintList(const LinkList& L) {
	LNode* p = L->next;//p是第一个节点
	LNode* r = L;//r是头节点
	cout << "该循环单链表的值为：";
	while (p->next != r->next) {//如果头节点的后继指针与首节点的指针指向同一个节点，证明已经到了链尾
		cout << p->data<<" ";//输出该节点的数据
		p = p->next;//未到链尾，移动指针向后移动到下一个节点
	}	
	cout << endl;
	return true;
}

3.2 求出循环单链表的长度

int Length(const LinkList& L) {
	LNode* p = L->next;//p是第一个节点
	LNode* r = L;//r是头节点
	int i=0;//记录长度
	while (p)//能进入此循环证明p存在
	{
		i++;//p存在，让长度加一
		p = p->next;//p向后移动
		if (p->next == r->next) {//如果头节点的后继指针与首节点的指针指向同一个节点，证明已经到了链尾
			//cout << "该循环单链表的长度为:"<<i << endl;//输出长度
			return i;//返回长度
		}
	}
}

3.3 使用尾插法创建单循环链表

bool TailCirculateList(LinkList& L) {
	LNode* p = L;//p是头节点
	LNode* t = L;//t是头节点
	int x;
	cout << "使用尾插法实现的单链表，请输入要创建的个数：" ;
	cin >> x;
	if (x < 1) {
		cout << "您输入的个数无效！" << endl; 
		return false; 
	}
	else if (x == 1) {//只输入一个节点时是特殊情况，进行特殊处理
		LNode* r = new LNode;
		cout << "请输入要输入的值：";
		cin >> r->data;
		p->next = r;
		r->next = t->next;
		return true;
	}
	cout << "请输入要输入的值：";
	while (x) {//x>1的情况
		LNode* r = new LNode;//申请新节点r
		cin >> r->data;//为新节点r填充数据
		p->next = r;//让头节点指向新的节点
		p = r;//p移动到新节点，尾插法在链尾插入新节点，所以头节点（其实只是个工作指针）也要移动到链尾，便于第下次添加
		x--;
	}
	p->next = t;//此时p是链尾节点，为了构造成循环链，让尾节点指向头节点

	PrintList(L);//打印单循环链
	return true;
}

3.4 使用头插法创建单循环链表

bool HeadCirculateList(LinkList& L){

	LNode* t = L;//t是头节点
	LNode* h = L;//h是头节点
	LNode* p = new LNode;//申请一个新节点p
	int x;
	cout << "使用头插法实现的单链表，请输入要创建的个数：";
	cin >> x;
	if (x < 1) {
		cout << "您输入的个数无效！" << endl;
		return false;
	}
	else if (x == 1) {//只输入一个数据时，特殊情况，进行处理
		LNode* p = new LNode;
		cout << "请输入要输入的值：";
		cin >> p->data;
		t->next = p;
		p->next = t->next;
		return true;
	}
	cout << "请输入要输入的值：";
	while (x) {
		LNode* r = new LNode;//申请一个新节点r
		cin >> r->data;//为新节点填充数据
		t->next = r;//头节点指向新节点
		r->next = h;//让新节点指向头节点
		h = t->next;//让工作指针回到头节点
		x--;
	}
	PrintList(L);//打印单循环链
	return true;
}

3.5 按值查找循环单链表

bool GetValueElem(LinkList& L) {
	LNode* p = L->next;
	LNode* t = L;
	int x,i=0;
	cout << "请输入您要查找的值：";
	cin >> x;
	while (p)
	{
		i++;
		if (p->data == x) {
			cout << "恭喜您要查找的值在该单链表中且在该链表的第"<<i<<"位！" << endl;
			return true;
		}
		else
		{
			p = p->next;
			if (p->next == t->next) {
				cout << "抱歉您要查找的值不在该单链表中！" << endl;
				return false;
			}
		}
		
	}
}

3.6 按位查找循环单链表   

bool GetBitElem(LinkList& L) {
	LNode* p = L;
	int x;
	cout << "请输入您要查找的位：";
	cin >> x;
	int k = x;
	if (x<1 || x>Length(L)) {
		cout << "您输入的位数无意义或不存在！" << endl;
		return false;
	}
	while (x)
	{
		p = p->next;
		x--;
	}
	cout << "您要查找的第" << k << "位的数据为:" << p->data << endl;
	return true;
}

3.7 在循环单链表中按位插入节点

bool Insert(LinkList& L) {
	LNode* p = L;
	LNode* r = L;
	cout << "请输入你要插入的位数:";
	int x;
	cin >> x;
	if (x<=0 || x>Length(L)) {
		cout << "您插入的位数无意义或不存在！" << endl;
		return false;
	}
	cout << "请输入你要插入的值：";
	if (x < Length(L)) {
		LNode *q = new LNode;
		cin >> q->data;
		if (x == 1) {
			q->next = p->next;
			 p->next=q;
			 q = p;
			PrintList(L);//打印单循环链
			return true;
		}
		while (x)
		{
			p = p->next;
			x--;
		}
		q->next=p->next;
		p->next = q;
		PrintList(L);//打印单循环链
		return true;
	}
	else if (x == Length(L)) {//在链尾插入
		LNode* q = new LNode;
		cin >> q->data;
		while (x)
		{
			p = p->next;
			x--;
		}
		p->next = q;
		q->next = r;
		PrintList(L);//打印单循环链
		return true;
	}
}

3.8 在单循环链表中按位删除节点

bool DeleteBit(LinkList& L) {
	int n;
	LNode* p = L;
	LNode* r;
	InitList(r);
	cout << "请输入你要删除的节点的位数;";
	cin >> n;
	int k = n;
	if (n <1 || n> Length(L)) {
		cout << "您想删除的节点不存在" << endl;
		return false;
	}
	else if (n == Length(L)) {
		while (n)
		{
			p = p->next;
			n--;
		}
		r->next = p->next;
		r->data = p->next->data;
		p->next = r->next->next;
		cout << "要删除第" << k << "位的值" << p->data << "删除成功！";
		free(r);
		PrintList(L);//打印单链表
		return true;
	}
	while (n) {
		if (n == 1) {
			r->next = p->next;
			r->data = p->next->data;
			p->next = r->next->next;	
			cout << "要删除第"<<k<<"位的值" << r->data << "删除成功！" ;
			free(r);
			PrintList(L);//打印单链表
			return true;
		}
		n--;
		p = p->next;//节点向后移动
	}
}

3.8 在单循环链表中按值删除节点

bool DeleteValue(LinkList& L) {
	LNode* p = L;
	LNode* r;
	InitList(r);
	int v,x=Length(L);
	cout << "请输入你要删除的值;";
	cin >> v;
	while (x)
	{
		if (p->next->data == v) {
			r->data = p->next->data;
			r->next = p->next->next;
			p->next = r->next;
			free(r);
			cout << "要删除值为" << v << "的节点删除成功！";
			PrintList(L);//打印单链表
			return true;
		}
		p = p->next;
		x--;
	}
	cout << "要删除值为" << v << "的节点在单链表中不存在！";
	return false;
}

3.8 在单循环链表中按位修改节点的值

bool ReviseBit(LinkList& L) {
	int n,v;
	LNode* p = L;
	cout << "请输入你要修改的节点的位数;";
	cin >> n;
	if (n<1 || n>Length(L)) {
		cout << "你要修改的节点的位数不存在或无意义！"<<endl;
		return false;
	}
	cout << "请输入你要修改的节点的值;";
	cin >> v;
	while (n)
	{
		p = p->next;
		n--;
	}
	p->data = v;
	PrintList(L);//打印单链表
	return true;
}

3.8 在单循环链表中按值修改节点的值

bool ReviseValue(LinkList& L) {
	int n=Length(L),q,h;
	LNode* p = L;
	cout << "请输入你要修改的前的值和修改后的值;";
	cin >> q;
	cin >> h;
	while (n)
	{
		if (p->next->data == q) {
			p->next->data = h;
			PrintList(L);//打印单链表
			return true;
		}
		p = p->next;
		n--;
	}
	cout << "该单链表中不存在值为"<<q<<"的节点！" << endl;
	return false;
}

4.完整代码


#include<iostream>

using namespace std;

struct LNode {
	int data;    // 数据域
	LNode* next; // 指针域
};

typedef LNode LNode;     // LNode表示单链表的一个结点
typedef LNode* LinkList; // LinkList表示一个单链表

//函数申明
int Length(const LinkList& L);
bool InitList(LinkList& L);
bool PrintList(const LinkList& L);




//1.初始化
bool InitList(LinkList& L) {
	L = new LNode;//C/语言中使用：L = (LNode *)malloc(sizeof(LNode));与前者作用等价申请新节点
	if (!L) {
		cout << "申请节点失败！" << endl;
		return false;
	}
	L->next = NULL;//初始化节点的后继指针为空，避免引起错误！
	return true;
}
//2.打印单链表
bool PrintList(const LinkList& L) {
	LNode* p = L->next;//p是第一个节点
	LNode* r = L;//r是头节点
	cout << "该循环单链表的值为：";
	while (p->next != r->next) {//如果头节点的后继指针与首节点的指针指向同一个节点，证明已经到了链尾
		cout << p->data<<" ";//输出该节点的数据
		p = p->next;//未到链尾，移动指针向后移动到下一个节点
	}	
	cout << endl;
	return true;
}
//3.求单链表的长度
int Length(const LinkList& L) {
	LNode* p = L->next;//p是第一个节点
	LNode* r = L;//r是头节点
	int i=0;//记录长度
	while (p)//能进入此循环证明p存在
	{
		i++;//p存在，让长度加一
		p = p->next;//p向后移动
		if (p->next == r->next) {//如果头节点的后继指针与首节点的指针指向同一个节点，证明已经到了链尾
			//cout << "该循环单链表的长度为:"<<i << endl;//输出长度
			return i;//返回长度
		}
	}
}
//4.使用尾插法创建单循环链 
bool TailCirculateList(LinkList& L) {
	LNode* p = L;//p是头节点
	LNode* t = L;//t是头节点
	int x;
	cout << "使用尾插法实现的单链表，请输入要创建的个数：" ;
	cin >> x;
	if (x < 1) {
		cout << "您输入的个数无效！" << endl; 
		return false; 
	}
	else if (x == 1) {//只输入一个节点时是特殊情况，进行特殊处理
		LNode* r = new LNode;
		cout << "请输入要输入的值：";
		cin >> r->data;
		p->next = r;
		r->next = t->next;
		return true;
	}
	cout << "请输入要输入的值：";
	while (x) {//x>1的情况
		LNode* r = new LNode;//申请新节点r
		cin >> r->data;//为新节点r填充数据
		p->next = r;//让头节点指向新的节点
		p = r;//p移动到新节点，尾插法在链尾插入新节点，所以头节点（其实只是个工作指针）也要移动到链尾，便于第下次添加
		x--;
	}
	p->next = t;//此时p是链尾节点，为了构造成循环链，让尾节点指向头节点

	PrintList(L);//打印单循环链
	return true;
}
//5.使用头插法创建单循环链
bool HeadCirculateList(LinkList& L){

	LNode* t = L;//t是头节点
	LNode* h = L;//h是头节点
	LNode* p = new LNode;//申请一个新节点p
	int x;
	cout << "使用头插法实现的单链表，请输入要创建的个数：";
	cin >> x;
	if (x < 1) {
		cout << "您输入的个数无效！" << endl;
		return false;
	}
	else if (x == 1) {//只输入一个数据时，特殊情况，进行处理
		LNode* p = new LNode;
		cout << "请输入要输入的值：";
		cin >> p->data;
		t->next = p;
		p->next = t->next;
		return true;
	}
	cout << "请输入要输入的值：";
	while (x) {
		LNode* r = new LNode;//申请一个新节点r
		cin >> r->data;//为新节点填充数据
		t->next = r;//头节点指向新节点
		r->next = h;//让新节点指向头节点
		h = t->next;//让工作指针回到头节点
		x--;
	}
	PrintList(L);//打印单循环链
	return true;
}
//6.按值查找单链表
bool GetValueElem(LinkList& L) {
	LNode* p = L->next;
	LNode* t = L;
	int x,i=0;
	cout << "请输入您要查找的值：";
	cin >> x;
	while (p)
	{
		i++;
		if (p->data == x) {
			cout << "恭喜您要查找的值在该单链表中且在该链表的第"<<i<<"位！" << endl;
			return true;
		}
		else
		{
			p = p->next;
			if (p->next == t->next) {
				cout << "抱歉您要查找的值不在该单链表中！" << endl;
				return false;
			}
		}
		
	}
}
//7.按位查找单链表
bool GetBitElem(LinkList& L) {
	LNode* p = L;
	int x;
	cout << "请输入您要查找的位：";
	cin >> x;
	int k = x;
	if (x<1 || x>Length(L)) {
		cout << "您输入的位数无意义或不存在！" << endl;
		return false;
	}
	while (x)
	{
		p = p->next;
		x--;
	}
	cout << "您要查找的第" << k << "位的数据为:" << p->data << endl;
	return true;
}


//8.插入节点
bool Insert(LinkList& L) {
	LNode* p = L;
	LNode* r = L;
	cout << "请输入你要插入的位数:";
	int x;
	cin >> x;
	if (x<=0 || x>Length(L)) {
		cout << "您插入的位数无意义或不存在！" << endl;
		return false;
	}
	cout << "请输入你要插入的值：";
	if (x < Length(L)) {
		LNode *q = new LNode;
		cin >> q->data;
		if (x == 1) {
			q->next = p->next;
			 p->next=q;
			 q = p;
			PrintList(L);//打印单循环链
			return true;
		}
		while (x)
		{
			p = p->next;
			x--;
		}
		q->next=p->next;
		p->next = q;
		PrintList(L);//打印单循环链
		return true;
	}
	else if (x == Length(L)) {//在链尾插入
		LNode* q = new LNode;
		cin >> q->data;
		while (x)
		{
			p = p->next;
			x--;
		}
		p->next = q;
		q->next = r;
		PrintList(L);//打印单循环链
		return true;
	}
}
//9.按位删除节点
bool DeleteBit(LinkList& L) {
	int n;
	LNode* p = L;
	LNode* r;
	InitList(r);
	cout << "请输入你要删除的节点的位数;";
	cin >> n;
	int k = n;
	if (n <1 || n> Length(L)) {
		cout << "您想删除的节点不存在" << endl;
		return false;
	}
	else if (n == Length(L)) {
		while (n)
		{
			p = p->next;
			n--;
		}
		r->next = p->next;
		r->data = p->next->data;
		p->next = r->next->next;
		cout << "要删除第" << k << "位的值" << p->data << "删除成功！";
		free(r);
		PrintList(L);//打印单链表
		return true;
	}
	while (n) {
		if (n == 1) {
			r->next = p->next;
			r->data = p->next->data;
			p->next = r->next->next;	
			cout << "要删除第"<<k<<"位的值" << r->data << "删除成功！" ;
			free(r);
			PrintList(L);//打印单链表
			return true;
		}
		n--;
		p = p->next;//节点向后移动
	}
}
//10. 按值删除节点
bool DeleteValue(LinkList& L) {
	LNode* p = L;
	LNode* r;
	InitList(r);
	int v,x=Length(L);
	cout << "请输入你要删除的值;";
	cin >> v;
	while (x)
	{
		if (p->next->data == v) {
			r->data = p->next->data;
			r->next = p->next->next;
			p->next = r->next;
			free(r);
			cout << "要删除值为" << v << "的节点删除成功！";
			PrintList(L);//打印单链表
			return true;
		}
		p = p->next;
		x--;
	}
	cout << "要删除值为" << v << "的节点在单链表中不存在！";
	return false;
}
//11.按位修改循环单链表的节点
bool ReviseBit(LinkList& L) {
	int n,v;
	LNode* p = L;
	cout << "请输入你要修改的节点的位数;";
	cin >> n;
	if (n<1 || n>Length(L)) {
		cout << "你要修改的节点的位数不存在或无意义！"<<endl;
		return false;
	}
	cout << "请输入你要修改的节点的值;";
	cin >> v;
	while (n)
	{
		p = p->next;
		n--;
	}
	p->data = v;
	PrintList(L);//打印单链表
	return true;
}
//12.按值修改循环单链表的节点
bool ReviseValue(LinkList& L) {
	int n=Length(L),q,h;
	LNode* p = L;
	cout << "请输入你要修改的前的值和修改后的值;";
	cin >> q;
	cin >> h;
	while (n)
	{
		if (p->next->data == q) {
			p->next->data = h;
			PrintList(L);//打印单链表
			return true;
		}
		p = p->next;
		n--;
	}
	cout << "该单链表中不存在值为"<<q<<"的节点！" << endl;
	return false;
}
int main() {
	LinkList(L);
	InitList(L);//初始化
	HeadCirculateList(L);//使用头插法
	cout << endl;//换行，为了美观
	TailCirculateList(L);//使用尾插法
	GetValueElem(L);//按值查找
	GetBitElem(L);//按位查找
	Insert(L);//插入节点
	DeleteBit(L);//按位删除节点
	DeleteValue(L);//按值删除节点
	ReviseBit(L);//按位修改值
	ReviseValue(L);//按值修改
}

5. 运行结果及截图

在windows11操作系统的Visual Studio 2019编译器中运行的结果如下图所示！

孤城寻欢
关注
RESTful简介与C/C++实现
笔者从事电信媒体开发多年，愿意将多年的开发经验分享给同行
12-21 3082
RESTful，全称为Representational State Transfer，是一种软件架构风格和设计理念，而不是一种标准。它主要用于Web服务的设计和开发，强调资源的状态表示和状态转移。RESTful风格的设计使得Web服务更加简洁、清晰和易于理解。本文结合RESTful、HTTP及C++进行了简单介绍。
C/C++学习路线总结与分享
热门推荐
dvlinker的技术专栏
10-07 9万+
C/C++学习路线总结与分享
单向循环链表C++实现
weixin_70343234的博客
02-05 562
实现了单项循环链表的头插，尾插，指定位置插入元素的方法；实现了头删，尾删，指定位置删除元素的方法；实现了获取某个位置的元素的方法。实现了获取链表是否为空的方法；实现了获取链表长度方法；
c++实现的循环链表
04-09
使用c++实现的循环链表程序，供大家学习数据结构参考使用
C++ 单链表、双链表和循环链表
最新发布
qq_50373827的博客
09-29 987
单链表是一种线性数据结构，由一系列节点构成。每个节点包含数据部分和指向下一个节点的指针，最后一个节点的指针指向nullptr。双链表是一种线性数据结构，每个节点包含数据、指向下一个节点的指针和指向前一个节点的指针。循环链表是一种特殊的链表，最后一个节点的指针指向头节点，形成一个循环结构。
C++实现单循环链表
m0_55614270的博客
08-31 1110
C++实现单循环链表
循环链表（C++实现）
st66688的博客
09-22 3446
循环链表内容整理
C++循环链表
King逍灬遥
11-24 3599
C++循环链表 单向循环链表和单向链表的区别： （1）单向链表为头指针，循环链表为尾指针，头指针指向头结点，尾指针指向终端结点； （2）为统一方便操作，单向链表设置头结点，单向循环链表设置头结点和尾结点； （3）设置尾结点后，尾指针指向尾结点，插入，删除等操作不用移动尾指针。 在单向链表中，链表最后一个结点的next指针指向NULL，而所谓的循环链表就是将最后一个结点本来指向空的改变其指...
C++实现mqtt协议
09-03
在C++中实现MQTT协议可以为开发者提供灵活且高效的解决方案，尤其对于资源受限的嵌入式系统。本文将深入探讨如何利用C++来实现MQTT协议，以及涉及的主要概念和技术。 首先，我们需要了解MQTT协议的基本原理。它基于...
C++代码实现栈基本操作
m0_67500944的博客
09-02 6137
C++代码实现栈基本操作，可以实现的，点进不亏
五子棋大作业（C++实现）
03-04
2、采用黑屏字符输入输出实现UI 3、采用打分方法实现AI 4、棋盘大小为15*15，棋盘将显示相应的行列号（A-O） 5、棋子有两种颜色黑和白，代表着对弈的双方，棋子放在棋盘行列交叉处，惯例黑棋先下。 6、黑白任一方先...
用C++实现的循环链表
04-15
这是一个单循环链表，具备基本的操作，在普通链表的基础上，实现了定长循环链表的循环输入，判断链表是否有环等较为特殊的操作。增删改查自然也有。
循环链表c++
06-10
使用c++语言实现的循环链表，功能齐全，包括插入、删除、寻找等功能
C++循环链表的实现
05-23
C++循环链表的实现，内含.h和.cpp文件各一个，导入IDE自动生成解决方案即可
循环链表c++实现
u012967763的专栏
12-19 1144
#ifndef _CIRCLELINK_H_ #define _CIRCLELINK_H_ #include #include "CircleLink.hpp" using namespace std; template struct Node {     DataType data;     Node *next; }; template class CircleLink
c++实现循环单链表
weixin_45548868的博客
04-01 908
#include <iostream> using namespace std; #define MAXSIZE 20 #define TRUE 1 #define FALSE 0 typedef bool Status; /* Status是函数的类型,其值是函f数结果状态代码*/ typedef char ElemType; /* ElemType...
单向循环链表（C++实现）
qq_40159978的博客
10-26 324
#include<stdio.h> #include<stdlib.h> #define ERROR 0 #define OK 1 typedef int ElemType; typedef int Status; typedef struct LNode { ElemType data; struct LNode *next; }LNode,*Li...
数据结构之——单向循环链表完备版（C++实现）
GaoXiaoYuan0728的博客
09-23 840
#pragma once #pragma once #include <iostream> using namespace std; template<class E> class Node { public: E element; //元素值 Node<E>* next; //指向下一个节点 Node() {}; //不含参数的构造函数 Node(E element, Node<E>* next) //含参数的构造函数 { th
C++实现循环单链表
w1277256813的博客
08-03 510
C++实现循环单链表
C++实现链表操作：创建、插入、删除
这个程序定义了一个`Node`类，用于表示链表中的单个节点，以及一个`List`类，用于实现链表的各种操作。 `Node`类包含两个成员变量： 1. `int data`：存储节点的数据，这里使用了int类型，但在实际应用中可以根据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值