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

最新推荐文章于 2022-12-23 22:12:08 发布
最新推荐文章于 2022-12-23 22:12:08 发布
阅读量326 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41836269/article/details/88431985
版权

　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
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构 模板化的链表类 包括对链表基本操作 链表游标的使用实例
12-21
数据结构 模板化的链表类 包括对链表基本操作 链表游标的使用实例
深入解析C++的循环链表与双向链表设计的API实现
09-02
在C++编程中，循环链表和双向链表是两种重要的数据结构，它们在处理动态数据集合时提供了灵活且高效的方式。...循环链表的游标操作尤其有助于简化遍历和操作过程，使其成为约瑟夫问题等算法问题的理想选择。
C++模板类实现带有游标的双向链表
qq_41836269的博客
03-13 314
链表只能从头结点开始访问链表中的数据元素，如果需要逆序访问单链表中的数据元素将极其低效。双链表是链表的一种，由节点组成，每个数据结点中都有两个指针，分别指向直接后继和直接前驱，带有游标的双向链表可以应用在某些特殊的场景。 详细讲解参照https://www.bilibili.com/video/av27904891/?p=1 本次使用工具为vs2017，作者水平有限，若有问题请指出。 链表模板...
动态游标for循环_数据结构系列循环链表
weixin_39928844的博客
12-06 216
前面留的一个问题,后文更跟新回答单链表可以表示任意的线性关系，有些线性关系是循环的，既没有队尾元素。将单链表中的终端结点指针端由空指针改为指向头结点，这时的单链表形成国恒一个环，改为循环链表。插入与删除与单链表的原理甚至一模一样，工程CircleListPro，将单链表改成循环链表。CircleList.h文件ifndef _CIRCLELIST_H_#defin...
循环链表
Keep coding
08-26 424
单链表的局限 单链表可以用于表示任意的线性关系 有些线性关系是循环的，即没有队尾元素 循环链表的定义将单链表中最后一个数据元素的next指针指向第一个元素循环链表拥有单链表的所有操作 创建链表 销毁链表 获取链表长度 清空链表 获取第pos个元素操作 插入元素到位置pos 删除位置pos处的元素 游标的定义在循环链表中可以定义一个“当前”指针，这个指针通常称为游标，可以通过这个游标（slider）来
C/C++ 单链表的游标实现（完整代码）
ylh的博客
12-23 285
不使用任何指针类型，利用游标实现单链表的基本操作，增删改查等各种基本操作
C++ 实现静态链表的简单实例
08-30
C++ 实现静态链表的简单实例 静态链表是一种特殊的链表，它使用数组来存储节点，而不是使用指针。静态链表的每个节点都包含数据域和游标，游标用于指示当前节点的下一个元素的下标。静态链表具有链式存储结构的主要...
C++链表倒序实现方法
09-04
本篇文章将详细介绍如何在C++中实现链表的倒序操作，这是一个常见的链表操作，对于理解和掌握C++的数据结构及算法具有重要意义。 链表的倒序操作主要是改变链表中每个节点的指针方向，使得原本指向后续节点的指针...
Oracle显示游标的使用及游标for循环
09-10
游标分为隐式游标和显式游标，它们各自有不同的应用场景。 1. **隐式游标**：Oracle在每次SQL语句执行时都会自动使用隐式游标。当查询返回单行记录时，隐式游标默认处理这些记录。例如，如果你在一个PL/SQL块中执行...
游标实现链表
lancelot0902的博客
06-11 317
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 688
代码的主体来自于《Data Structures and Algorithm Analysis in C (Second Edition)》，我在书中代码的基础上进行了一些修改与补充。修改 补充 说明：1.  添加了Last变量，代表链表的最后一个元素的下标，使IsEmpty( )等函数的实现更为直观，快捷。2.  增加了FindPrevious,Print,Out三个函数，使API更为完善。3....
算法学习 - 链表的游标实现~ C++
累了就歇一会
07-27 3553
链表的游标实现，就是用另外一种方法来访问链表，模拟游标。 在我学习的理解中，就是创建一个节点数组，模拟内存的排列，然后从其中来申请内存和释放内存。但是实际的内存没有被释放~
第十课，循环链表
wuyadeCS的专栏
06-21 404
专题三：渐入佳境。包括以下章节： 无招胜有招-静态链表 气宗门道-循环链表 剑宗门道-双向链表 课后练习 单链表的局限 单链表可以用于表示任意的线性关系 有些线性关系是循环的，即没有队尾元素 单链表的改进循环链表的定义 将单链表中最后一个数据元素的next指针指向第一个元素 循环链表的操作循环链表拥有单链表的所有操作 创建链表 销毁链表 获取链表长度 清空链表 获取第pos个元素操作 插入元素到位置
数据结构-循环链表（学习笔记）
maweisky531的专栏
08-12 376
定义： 将单链表中最后一个数据元素的next指针指向第一个元素 游标： 在循环链表中可以定义一个“当前”指针，这个指针通常称为游标，可以通过这个游标来遍历链表中的所有元素。 一些新的操作： 1.获取当前游标指向的数据元素 2.将游标重置指向链表中的第一个数据元素 3.将游标移动指向到链表中的下一个数据元素 4.直接指定删除链表中的某个数据元素 头文件: #ifn
Proc *C/C++入门之游标访问数据库
lzjsqn的专栏
01-11 1630
数据类型转换 Oracle外部数据类型中的string是以零结尾的字符串，类似于varchar2类型！ char在数据不满的时候，后面部分会被填充为空格 在SQL语句中的宿主数据类型可以人为的转换为Oracle的外部数据类型，所以我们可以把char [20]转换为string类型，避免产生多余的空格虽然varchar也可以避免空格，但是varchar还要引用里卖弄具体的成员，所以不是很方便，最方便的
数据结构之循环链表
CCDreamOldBoys的专栏
07-28 721
一、循环链表的定义 将单链表中最后一个数据元素的next指针指向第一个元素 二、循环链表的功能和操作方法 创建链表销毁链表获取链表长度清空链表获取第pos个元素操作插入元素到位置pos删除位置pos处的元素 相对于单项链表来说，增加了一个控制部分游标进行控制节点，其主要操作是控制循环链表的初始化；可以通过游标指针来进行遍历； 注意说明： 1.
单链表类模板的实现190918
ShenHang_的博客
09-18 362
#include<iostream> using namespace std; template<class T> class Node { private: Node<T> * next; public: T data; ...
数据结构之线性表——循环链表（C语言描述）
ds_kuen的博客
05-11 851
1 循环链表的定义 将单链表中最后一个数据元素的next指针指向第一个元素,如下图所示：                              2 循环链表的游标定义： 在循环链表中可以定义一个“当前指针”，这个指针通常称为游标，可以通过游标来遍历链表中所有元素。如下图所示：                               3 循环链表的
pro*c/c++学习三：数据类型-宿主变量-游标-context变量
zishuijing_dd的博客
03-31 467
数据类型和宿主变量 Oracle Datatypes 内部类型，描述数据库表中字段。 外部数据类型 宿主变量声明 可以用来声明宿主变量的类型 指示变量 格式如下： :host_variable INDICATOR :indicator_variable 或者 :host_variable:indicator_variable 变量的值以及含义如下： oracle限制 如果DBMS=V7 or V8，使用SELECT或者FETCH 空的数据到宿主变量但是不使用指示变量，oracle报错如下：
pgsql中如何实现两层游标循环
最新发布
07-15
在 PostgreSQL (pgsql) 中，你可以使用嵌套循环和游标来实现两层游标循环。下面是一个示例代码，演示了如何实现两层游标循环： ```sql -- 创建外部游标 DECLARE outer_cur CURSOR FOR SELECT * FROM outer_table; ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值