C++模板类实现带有游标的单向循环链表

最新推荐文章于 2024-09-20 21:20:45 发布
原创 最新推荐文章于 2024-09-20 21:20:45 发布 · 400 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文详细介绍了一种基于C++的单向循环链表实现，包括链表的基本操作如插入、删除、查找等，以及游标功能的实现，通过具体代码示例展示了如何构建和操作循环链表。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

　1，循环链表基于单向链表而生，单向链表的首尾相连，组成一个环状单。循环链表比单向链表多了游标这个概念，游标可以快速的访问当前结点和下一个结点。

   2，循环链表在插入第一个元素的时候，需要我们将第一元素的指针域指向其自身，也就构成了循环链表。

   3，循环链表在删除链表节点的时候，要注意游标，否则游标容易断开。

   4，修改循环链表时候，可以将头部，尾部，非头尾三部分分开考虑。

C++模板类实现带有游标得到单向循环链表代码如下（本次使用工具为vs2017，作者水平有限，如有bug还请指出）：

 1.模板类的头文件  Circle_List_Cplus.h

#pragma once

//定义链表结点
template<typename T>
struct ListNode
{
	struct ListNode<T> *Next;
	T data;
};

//定义循环链表模板类
template<typename T>
class Circle_List_Cplus
{
public:

	//默认构造函数，生成一个循环链表
	Circle_List_Cplus();

	//从头部插入节点
	int InsertNodeFront(T data);

	//从尾部插入节点
	int InsertNodeBack(T data);

	//从链表的任意位置插入节点
	int InsertNode(T data, int index);

	//获取任意位置节点
	T &GetListNode(int index);

	//删除任意位置节点
	int DeleteNode(int index);

	//获取链表的长度
	int GetListLen();

	//游标复位,让游标重新指向0号元素的位置
	void CursorReset();

	//根据传来的节点数据删除节点
	int Delete_From_Node(T data);

	//获取游标指向的节点位置
	T &GetCursorNode();

	//返回当前游标的节点数据，并且在游标下移动
	T &CursorNext();

	//析构函数，释放开辟的资源
	~Circle_List_Cplus();

public:
	ListNode<T> Head;		//循环链表头
	ListNode<T> Cursor;     //循环链表游标
	int         ListLen;    //循环链表长度
};

2.模板类的实现文件  Circle_List_Cplus.cpp

#include "pch.h"
#include "Circle_List_Cplus.h"
#include "iostream"
using namespace std;

//默认构造函数，生成一个循环链表
template<typename T>
Circle_List_Cplus<T>::Circle_List_Cplus()
{
	this->ListLen		= 0;
	this->Cursor.Next	= NULL;
	this->Head.Next		= NULL;
}

//从头部插入节点
template<typename T>
int Circle_List_Cplus<T>::InsertNodeFront(T data)
{
	int ret = 0;
	//创建新结点
	ListNode<T> *LNode = new ListNode<T>;

	if (LNode == NULL)
	{
		cout << " New LNode Error ：InsertNodeFront() \n" << endl;
		ret = -1;
		return ret;
	}
	if (this->ListLen == 0)				//链表表里还没有数据
	{

		LNode->data		= data;         //对于复杂数据类型，要重载=操作符
		this->Head.Next = LNode;
		LNode->Next		= LNode;
		this->ListLen++;
	}
	else
	{
		LNode->data = data;				 //对于复杂数据类型，要重载=操作符
		LNode->Next = this->Head.Next;
		this->Head.Next = LNode;
		this->ListLen++;
	}

	return ret;
}

//从尾部插入节点
template<typename T>
int Circle_List_Cplus<T>::InsertNodeBack(T data)
{
	int ret = 0;
	//创建新结点
	ListNode<T> *LNode = new ListNode<T>;
	if (LNode == NULL)
	{
		cout << " New LNode Error ：InsertNodeFront() \n" << endl;
		ret = -1;
		return ret;
	}

	if (this->ListLen == 0)  //链表表里还没有数据
	{
		LNode->data = data;         //对于复杂数据类型，要重载=操作符
		this->Head.Next = LNode;
		LNode->Next = LNode;
		this->ListLen++;
	}
	else
	{
		ListNode<T> *current = this->Head.Next;		  //current指向0号位置
		for (int i = 0; i < this->ListLen - 1; i++)   //移动到待插入位置的前面
		{
			current = current->Next;
		}
	
		LNode->data			= data;				 //对于复杂数据类型，要重载=操作符
		current->Next		= LNode;
		LNode->Next			= this->Head.Next;   //指向0号节点数据
		this->ListLen++;

	}

	return ret;
}

//从链表的任意位置插入节点
template<typename T>
int Circle_List_Cplus<T>::InsertNode(T data, int index)
{
	int ret = 0;
	//防止越界
	if (index < 0 || index > this->ListLen)
	{
		printf("Insert index error ：InsertNode() \n");
		ret = -1;
		return ret;
	}
	//创建新结点
	ListNode<T> *LNode = new ListNode<T>;
	LNode->data = data;							 //对于复杂数据类型，要重载=操作符
	ListNode<T> *current = this->Head.Next;		 //current指向0号位置

	if (this->ListLen == 0)  //链表表里还没有数据
	{
		this->Head.Next = LNode;
		LNode->Next = LNode;
		this->ListLen++;
	}
	else
	{
		if (index == 0)  //头部插入元素
		{
			LNode->Next = this->Head.Next;
			this->Head.Next = LNode;
			this->ListLen++;
		}

		else if (index == this->ListLen)			  //在尾部插入元素
		{
			for (int i = 0; i < index - 1; i++)		  //移动到待插入位置的前面
			{
				current = current->Next;
			}
			current->Next = LNode;
			LNode->Next   = this->Head.Next;
			this->ListLen++;
		}

		else
		{
			for (int i = 0; i < index - 1; i++)      //移动到待插入位置的前面
			{
				current = current->Next;
			}
			//地址链接
			LNode->Next = current->Next;
			current->Next = LNode;
			this->ListLen++;
		}
	}

	return ret;
}


//获取任意位置节点
template<typename T>
T &Circle_List_Cplus<T>::GetListNode(int index)
{
	if (index < 0 || index > this->ListLen - 1)
	{
		printf("List index error ：GetListNode() \n");
	}

	ListNode<T> *current = this->Head.Next;		    //current指向0号位置
	if (index == 0)								    //当查找的是第0号数据
	{
		return current->data;
	}
	else
	{
		for (int i = 0; i < index - 1; i++)			 //移动到待获取位置的前面
		{
			current = current->Next;
		}
		return current->Next->data;
	}

}

//删除任意位置节点
template<typename T>
int  Circle_List_Cplus<T>::DeleteNode(int index)
{
	int ret = 0;
	if (index < 0 || index > this->ListLen - 1)
	{
		printf("List index error ：DeleteNode() \n");
		ret = -1;
		return ret;
	}
	if (this->ListLen == 0)
	{
		printf("List is not exist DeleteNode() \n");
		ret = -1;
		return ret;
	}

	ListNode<T> *current = this->Head.Next;		 //current指向0号位置
	ListNode<T> *tempnode = NULL;
	if (index == 0)
	{   												 //删除了第一个位置的元素，此时要找到最后一个元素的位置
		this->Head.Next   = current->Next;				 //头节点指向1号节点
		tempnode = current;								 //记录待删除元素的位置
		this->Cursor.Next = current->Next;				 //游标指向1号节点
		for (int i = 0; i < this->ListLen - 1; i++)		 //current刚好指向最后一个元素
		{
			current = current->Next;
		}
		current->Next = this->Head.Next;
		this->ListLen--;
		//释放内存
		if (tempnode != NULL)
		{
			delete tempnode;
		}

	}
	else if (index == this->ListLen - 1)		 //删除的是最后一个节点数据
	{
		for (int i = 0; i < index - 1; i++)		 //current刚好指向最后一个元素的前面一个
		{
			current = current->Next;
		}

		tempnode = current->Next;				//缓存最后一个元素的地址，然后释放地址
		current->Next = this->Head.Next;
		this->Cursor.Next = this->Head.Next;
		this->ListLen--;
		//释放内存
		if (tempnode != NULL)
		{
			delete tempnode;
		}
	}
	else
	{
		ListNode<T> *tempnode = NULL;
		for (int i = 0; i < index - 1; i++)      //移动到待删除位置的前面
		{
			current = current->Next;
		}
		tempnode = current->Next;				 //tempnode指向待删除的位置
		current->Next = tempnode->Next;
		this->Cursor.Next = tempnode->Next;
		this->ListLen--;
		//释放内存
		if (tempnode != NULL)
		{
			delete tempnode;
		}
	}

	return ret;
}

//获取链表的长度
template<typename T>
int  Circle_List_Cplus<T>::GetListLen()
{
	return this->ListLen;
}

//游标复位,让游标重新指向0号元素的位置
template<typename T>
void  Circle_List_Cplus<T>::CursorReset()
{
	this->Cursor.Next = this->Head.Next;
}


//根据传来的节点数据删除节点
template<typename T>
int Circle_List_Cplus<T>::Delete_From_Node(T data)
{
	int ret = 0;
	int tag = 0;
	int i   = 0;
	ListNode<T> *current = this->Head.Next;		 //current指向0号位置
	for (i = 0; i < this->ListLen; i++)		     //循环玩之后在cuurrent在最后一个位置
	{
		if (current->data == data)				//注意对于复杂数据类型，这里要重载==操作符
		{
			tag = 1;
			break;
		}
		current = current->Next;
	}
	if (tag == 1)
	{
		DeleteNode(i);    //删除元素
	}
	else
	{
		cout << "Not find data to delete" << endl;
		ret = -1;
		return ret;
	}

	return ret;
}

//获取游标指向的节点位置
template<typename T>
T& Circle_List_Cplus<T>::GetCursorNode()
{
	//链表为空
	if (this->Head.Next == 0)
	{
		cout << "List is empty" << endl;
	}

	return this->Cursor.Next->data;
}

//返回当前游标的节点数据，并且在游标下移动
template<typename T>
T& Circle_List_Cplus<T>::CursorNext()
{
	//链表为空
	if (this->Head.Next == 0)
	{
		cout << "List is empty" << endl;
	}

	ListNode<T> *temp = this->Cursor.Next;		 //获取当前的游标，在最后一个位置
	this->Cursor.Next = temp->Next;			     //游标指向
	return temp->data;
}

//释放资源
template<typename T>
Circle_List_Cplus<T>::~Circle_List_Cplus()
{
	ListNode<T> *current = this->Head.Next;      //current指向0号位置
	ListNode<T> *temp	 = current->Next;	     //temp指向1号位置

	for (int i=0; i<this->ListLen-1; i++)
	{
		if (current != NULL)
		{
			delete current;
		}
		current = temp;
		temp = current->Next;
	}

	this->Cursor.Next = NULL;
	this->ListLen   = 0;
	this->Head.Next   = NULL;
}

3.循环链表的测试文件 _Circle_List_Cplus_Framecpp.cpp

#include "pch.h"
#include "Circle_List_Cplus.cpp"
#include "iostream"
#include "string"
using namespace std;

//自定义人类
class person
{
public:
	person()
	{
	
	}

	person(string name,int age)
	{
		this->name = name;
		this->age = age;
	}

	person(const person &obj)
	{
		this->name = obj.name;
		this->age = obj.age;
	}

	//重载=
	person & operator=(person &obj)
	{
		this->name = obj.name;
		this->age = obj.age;
		return *this;
	}
	//重载==
	bool operator==(person &obj)
	{
		if (this->name == obj.name && this->age == obj.age)
		{
			return true;
		}
		else
		{
			return false;
		}
	}

	~person()
	{
	
	
	}

public:
	int age;
	string name;
};

//打印链表的信息
void printf_person(Circle_List_Cplus<person> &obj)
{
	cout << "--------------开始打印数据---------------" << endl;
	person data;
	int tag = 0;
	for (int i = 0; i < 2 * obj.ListLen; i++)
	{
		if (i == obj.ListLen)
		{
			printf("----第%d次打印数据---- \n", tag + 1);
			i = 0;
			tag++;
		}
		if (tag == 2)
		{
			break;
		}
		data = obj.GetListNode(i);
		cout << data.name << "    " << data.age << endl;
		printf("\n");
	}
	cout << "--------------结束打印数据---------------" << endl;
}
//测试链表的增删改查，以及游标功能
void test2()
{
	person p1("pxzz", 21), p2("wxxx", 22), p3("iut", 23), p4("dft", 24), p5("hji", 25), p6("kij", 26), p7("kio", 27);
	Circle_List_Cplus<person> CLC;
	person dd;
	
	//测试插入节点
	CLC.InsertNodeFront(p1);
	CLC.InsertNodeFront(p2);
	CLC.InsertNodeBack(p3);
	CLC.InsertNodeBack(p4);
	CLC.InsertNode(p5, 0);
	CLC.InsertNode(p6, 5);
	printf_person(CLC);

	//测试删除节点
	CLC.DeleteNode(5);
	CLC.DeleteNode(0);
	CLC.DeleteNode(1);
	printf_person(CLC);

	//测试游标移动和获取功能
	CLC.CursorReset();

	dd = CLC.GetCursorNode();

	cout << dd.name << "      "<< dd.age << endl;

	dd = CLC.CursorNext();
	cout << dd.name << "      " << dd.age << endl;

	dd = CLC.CursorNext();
	cout << dd.name << "      " << dd.age << endl;

	dd = CLC.CursorNext();
	cout << dd.name << "      " << dd.age << endl;

	dd = CLC.CursorNext();
	cout << dd.name << "      " << dd.age << endl;

	dd = CLC.CursorNext();
	cout << dd.name << "      " << dd.age << endl;

	dd = CLC.CursorNext();
	cout << dd.name << "      " << dd.age << endl;

	dd = CLC.CursorNext();
	cout << dd.name << "      " << dd.age << endl;

	dd = CLC.CursorNext();
	cout << dd.name << "      " << dd.age << endl;

	printf_person(CLC);
	//测试给定数据删除数据
	CLC.Delete_From_Node(p2);
	printf_person(CLC);


	//测试游标移动和获取功能
	CLC.CursorReset();

	dd = CLC.CursorNext();
	cout << dd.name << "      " << dd.age << endl;

	dd = CLC.CursorNext();
	cout << dd.name << "      " << dd.age << endl;

	dd = CLC.CursorNext();
	cout << dd.name << "      " << dd.age << endl;

	dd = CLC.CursorNext();
	cout << dd.name << "      " << dd.age << endl;

}
//主函数
int main()
{
	test2();
	system("pause");
	return 0;
}

 

pxz_wxx
关注
VIVO C++开发面试题及参考答案
大模型大数据攻城狮的专栏
12-24 7534
运算符重载是 C++ 的一个重要特性，它允许我们重新定义运算符对于自定义类型的操作方式。运算符重载的定义是对已有的运算符赋予新的含义，使其能够操作自定义的数据类型。例如，对于一个复数类，我们可以重载加法运算符。
C++中STL用法超详细总结
热门推荐
一只大笨猫的博客
08-21 20万+
目录 1 什么是STL？ 2 STL内容介绍 2.1 容器 2.2 STL迭代器 2.3 算法 2.4 仿函数 2.4.1 概述 2.4.2 仿函数(functor)在编程语言中的应用  2.4.3 仿函数在STL中的定义 2.5 容器适配器 2.5.1 stack 2.5.2 queue &amp; priority_queue 3 常用容器用法介绍  3.1 vec...
数据结构 模板化的链表类 包括对链表基本操作 链表游标的使用实例
12-21
数据结构 模板化的链表类 包括对链表基本操作 链表游标的使用实例
C++模板类实现带有游标的双向链表
qq_41836269的博客
03-13 359
链表只能从头结点开始访问链表中的数据元素，如果需要逆序访问单链表中的数据元素将极其低效。双链表是链表的一种，由节点组成，每个数据结点中都有两个指针，分别指向直接后继和直接前驱，带有游标的双向链表可以应用在某些特殊的场景。 详细讲解参照https://www.bilibili.com/video/av27904891/?p=1 本次使用工具为vs2017，作者水平有限，若有问题请指出。 链表模板...
动态游标for循环_数据结构系列循环链表
weixin_39928844的博客
12-06 269
前面留的一个问题,后文更跟新回答单链表可以表示任意的线性关系，有些线性关系是循环的，既没有队尾元素。将单链表中的终端结点指针端由空指针改为指向头结点，这时的单链表形成国恒一个环，改为循环链表。插入与删除与单链表的原理甚至一模一样，工程CircleListPro，将单链表改成循环链表。CircleList.h文件ifndef _CIRCLELIST_H_#defin...
循环链表
Keep coding
08-26 468
单链表的局限 单链表可以用于表示任意的线性关系 有些线性关系是循环的，即没有队尾元素 循环链表的定义将单链表中最后一个数据元素的next指针指向第一个元素循环链表拥有单链表的所有操作 创建链表 销毁链表 获取链表长度 清空链表 获取第pos个元素操作 插入元素到位置pos 删除位置pos处的元素 游标的定义在循环链表中可以定义一个“当前”指针，这个指针通常称为游标，可以通过这个游标（slider）来
C/C++ 单链表的游标实现（完整代码）
ylh的博客
12-23 376
不使用任何指针类型，利用游标实现单链表的基本操作，增删改查等各种基本操作
模板链表类实现与游标使用教程
模板化链表类允许我们创建单向链表、双向链表或循环链表等，这些链表可以用来存储任意类型的数据，比如整数、浮点数、字符串或甚至是复杂的对象。 2. **链表基本操作**：链表的基本操作通常包括创建链表、插入节点...
C/C++面试宝典2024版(最新版)
学无止尽，谨言慎行！
04-02 3万+
面试基础前言new、delete、malloc、free关系delete与 delete []区别C和C++ 的共同点？不同之处？继承的优缺点C++有哪些性质（面向对象特点）子类析构时要调用父类的析构函数吗？多态，虚函数，纯虚函数求下面函数的返回值（微软）什么是“引用”？申明和使用“引用”要注意哪些问题？将“引用”作为函数参数有哪些特点？在什么时候需要使用“常引用”？将“引用”作为函数返回值类型的...
数据结构（从概念到C++实现）
m0_54285007的博客
09-05 7172
目录 第2章 线性表 2.1 引言 2.2 线性表的逻辑结构 2.2.1 线性表的定义 2.2.2 线性表的抽象数据类型定义 第2章 线性表 2.1 引言 线性表是描述单一的前驱和后继的关系 2.2 线性表的逻辑结构 2.2.1 线性表的定义 线性表是一个有限的序列，每个元素有且只有一个前驱和一个 后继，表头和表尾元素分别无前驱和后继。 线性表数据元素的个数称为线性表的长度，长度为0的线性表称为空表 线性表的常用表达方式为：L=(a1,a2,a3,a4....an) 2.2.
游标实现链表
lancelot0902的博客
06-11 374
List_cursor.h #ifndef LIST_CURSOR_H #define LIST_CURSOR_H constexpr auto MAX_SPACE = 10;; #include <iostream> using namespace std; struct Node { int data; int next; }; class List { public: Li...
链表的游标实现（最全面）
GaoJieVery6
03-08 737
代码的主体来自于《Data Structures and Algorithm Analysis in C (Second Edition)》，我在书中代码的基础上进行了一些修改与补充。修改 补充 说明：1.  添加了Last变量，代表链表的最后一个元素的下标，使IsEmpty( )等函数的实现更为直观，快捷。2.  增加了FindPrevious,Print,Out三个函数，使API更为完善。3....
算法学习 - 链表的游标实现~ C++
累了就歇一会
07-27 3644
链表的游标实现，就是用另外一种方法来访问链表，模拟游标。 在我学习的理解中，就是创建一个节点数组，模拟内存的排列，然后从其中来申请内存和释放内存。但是实际的内存没有被释放~
第十课，循环链表
wuyadeCS的专栏
06-21 498
专题三：渐入佳境。包括以下章节： 无招胜有招-静态链表 气宗门道-循环链表 剑宗门道-双向链表 课后练习 单链表的局限 单链表可以用于表示任意的线性关系 有些线性关系是循环的，即没有队尾元素 单链表的改进循环链表的定义 将单链表中最后一个数据元素的next指针指向第一个元素 循环链表的操作循环链表拥有单链表的所有操作 创建链表 销毁链表 获取链表长度 清空链表 获取第pos个元素操作 插入元素到位置
数据结构-循环链表（学习笔记）
maweisky531的专栏
08-12 429
定义： 将单链表中最后一个数据元素的next指针指向第一个元素 游标： 在循环链表中可以定义一个“当前”指针，这个指针通常称为游标，可以通过这个游标来遍历链表中的所有元素。 一些新的操作： 1.获取当前游标指向的数据元素 2.将游标重置指向链表中的第一个数据元素 3.将游标移动指向到链表中的下一个数据元素 4.直接指定删除链表中的某个数据元素 头文件: #ifn
Proc *C/C++入门之游标访问数据库
lzjsqn的专栏
01-11 1754
数据类型转换 Oracle外部数据类型中的string是以零结尾的字符串，类似于varchar2类型！ char在数据不满的时候，后面部分会被填充为空格 在SQL语句中的宿主数据类型可以人为的转换为Oracle的外部数据类型，所以我们可以把char [20]转换为string类型，避免产生多余的空格虽然varchar也可以避免空格，但是varchar还要引用里卖弄具体的成员，所以不是很方便，最方便的
数据结构之循环链表
CCDreamOldBoys的专栏
07-28 785
一、循环链表的定义 将单链表中最后一个数据元素的next指针指向第一个元素 二、循环链表的功能和操作方法 创建链表销毁链表获取链表长度清空链表获取第pos个元素操作插入元素到位置pos删除位置pos处的元素 相对于单项链表来说，增加了一个控制部分游标进行控制节点，其主要操作是控制循环链表的初始化；可以通过游标指针来进行遍历； 注意说明： 1.
单链表类模板的实现190918
ShenHang_的博客
09-18 444
#include<iostream> using namespace std; template<class T> class Node { private: Node<T> * next; public: T data; ...
c++ 防坑！获取控制台光标（游标）坐标
最新发布
我是Python虫！！！
09-20 374
c++ 避坑：GetConsoleCursorPosition获取游标坐标是假的！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值