C++模板类实现带有游标的双向链表

最新推荐文章于 2023-03-16 13:14:56 发布
最新推荐文章于 2023-03-16 13:14:56 发布
阅读量310 收藏
点赞数
分类专栏： C/C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41836269/article/details/88536280
版权

链表只能从头结点开始访问链表中的数据元素，如果需要逆序访问单链表中的数据元素将极其低效。双链表是链表的一种，由节点组成，每个数据结点中都有两个指针，分别指向直接后继和直接前驱，带有游标的双向链表可以应用在某些特殊的场景。
详细讲解参照https://www.bilibili.com/video/av27904891/?p=1

本次使用工具为vs2017，作者水平有限，若有问题请指出。

链表模板类头文件：Twoway_List_Cplus.h

#pragma once
template<typename T>
struct ListNode
{
	struct ListNode<T> *Next;   //后继
	struct ListNode<T> *Pre;    //前驱
	T	data;
};

template<typename T>
class Twoway_List_Cplus
{
public:
	Twoway_List_Cplus();
	~Twoway_List_Cplus();

	//头部插入数据节点
	int InsertListFront(T data);

	//尾部插入链表
	int InsertListBack(T data);

	//任意位置插入链表
	int InsertList(T data, int index);

	//删除指定位置的链表元素
	int DeleteNode(int index);

	//获取链表指定位置的元素
	int GetListNode(int index, T &redata);

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

	//游标复位
	void CursorReset();

	//游标下移动
	void CursorMoveNext();

	//游标上移动
	void CursorMovePre();

	//获取当前游标的元素
	int GetCurrentCursor(T &redata);

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

public:
	ListNode<T> Head;
	ListNode<T> Cursor;
	int		 ListLen;
};

链表模板类源文件：Twoway_List_Cplus.cpp

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

template<typename T>
Twoway_List_Cplus<T>::Twoway_List_Cplus()
{
	//链表的头指针，游标，初始化链表的长度
	this->ListLen	= 0;
	this->Head.Next	= NULL;
	this->Head.Pre		= NULL;
	this->Cursor.Next	= NULL;
	this->Cursor.Pre	= NULL;
}

template<typename T>
Twoway_List_Cplus<T>::~Twoway_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->Cursor.Pre  = NULL;
	this->ListLen = 0;
	this->Head.Next = NULL;
	this->Head.Pre  = NULL;
}

//头部插入数据节点
template<typename T>
int Twoway_List_Cplus<T>::InsertListFront(T data)
{
	int ret = 0;
	ListNode<T> *LNode = new ListNode<T>;   //创建节点，把数据拷贝进来
	if (LNode == NULL)
	{
		cout << "New ListNode Error ：InsertListFront()" << endl;
		ret = -1;
		return ret;
	}

	//拷贝数据
	LNode->data = data;         //对于复杂数据类型，要重载=操作符
		
	if (this->ListLen == 0)			    //链表中还没有数据
	{
		this->Head.Next = LNode;
		LNode->Next = NULL;         //后继指向NULL
		LNode->Pre = NULL;          //前驱指向NULL
		this->ListLen++;
	}
	else
	{
		this->Head.Next->Pre = LNode;      //0号位置前驱指向待插入节点
		LNode->Next = this->Head.Next;	   //待插入节点的后继指向0号结点
		LNode->Pre = NULL;			   //前驱指向NULL
		this->Head.Next = LNode;           //头节点的指向待插入节点
		this->ListLen++;
	}
	return ret;
}

template<typename T>
//尾部插入链表
int Twoway_List_Cplus<T>::InsertListBack(T data)
{
	int ret = 0;
	ListNode<T> *LNode = new ListNode<T>;   //创建节点，把数据拷贝进来
	if (LNode == NULL)
	{
		cout << "New ListNode Error ：InsertListBack()" << endl;
		ret = -1;
		return ret;
	}
	//拷贝数据
	LNode->data = data;						 //对于复杂数据类型，要重载=操作符
	ListNode<T> *current = this->Head.Next;  //current指向0号几点
	if (this->ListLen == 0)			         //链表中还没有数据
	{
		this->Head.Next = LNode;
		LNode->Next = NULL;				     //后继指向NULL
		LNode->Pre = NULL;				     //前驱指向NULL
		this->ListLen++;
	}
	else
	{
		for (int i = 0; i < this->ListLen - 1; i++) //移动完之后current指向末尾元素
		{
			current = current->Next;
		}
		LNode->Pre = current;	 //待插入节点指向末尾节点
		current->Next = LNode;   //末尾节点指向待插入节点
		LNode->Next = NULL;
		this->ListLen++;
	}
	return ret;
}

template<typename T>
//任意位置插入链表
int Twoway_List_Cplus<T>::InsertList(T data, int index)
{
	int ret = 0;
	ListNode<T> *LNode = new ListNode<T>;   //创建节点，把数据拷贝进来
	if (LNode == NULL)
	{
		cout << "New ListNode Error ：InsertList()" << endl;
		ret = -1;
		return ret;
	}
	//拷贝数据
	LNode->data = data;						   //对于复杂数据类型，要重载=操作符
	ListNode<T> *current = this->Head.Next;    //current指向0号几点
	ListNode<T> *temp = NULL;                  //临时指针变量
	if (index < 0 || index > this->ListLen)
	{
		cout << "Insert Index Error ：InsertList() " << endl;
		ret = -1;
		return ret;
	}
	if (this->ListLen == 0)			     //链表中还没有数据
	{
		this->Head.Next = LNode;
		LNode->Next = NULL;				 //后继指向NULL
		LNode->Pre = NULL;				 //前驱指向NULL
		this->ListLen++;
	}
	else
	{
		for (int i = 0; i < index - 1; i++)		//移动完之后current指向带插入节点的前一个
		{
			current = current->Next;
		}

		if (index == 0)   //插在0号位置
		{
			this->Head.Next->Pre = LNode;    //0号位置前驱指向待插入节点
			LNode->Next = this->Head.Next;	  //待插入节点的后继指向0号结点
			this->Head.Next = LNode;         //头节点的指向待插入节点
			LNode->Pre = NULL;
			this->ListLen++;
		}

		else if (index == this->ListLen)       //插在最后一个节点
		{
			LNode->Pre = current;	        //待插入节点指向末尾节点
			current->Next = LNode;           //末尾节点指向待插入节点
			LNode->Next = NULL;
			this->ListLen++;
		}
		else
		{
			temp = current->Next;				//temp指向待插入元素的下一个
			temp->Pre = LNode;
			LNode->Next = temp;
			current->Next = LNode;
			LNode->Pre = current;
			this->ListLen++;
		}
	}

	return ret;
}

template<typename T>
//删除指定位置的链表元素
int Twoway_List_Cplus<T>::DeleteNode(int index)
{
	int ret = 0;
	ListNode<T> *current = this->Head.Next;       //current指向0号几点
	ListNode<T> *temp = NULL;                       //临时指针变量
	if (index < 0 || index >= this->ListLen)
	{
		cout << "Insert Index Error ：DeleteNode() " << endl;
		ret = -1;
		return ret;
	}
	if (this->ListLen == 0)			     //链表中还没有数据
	{
		cout << "List is empty ：DeleteNode() " << endl;
		ret = -1;
		return ret;
	}
	else
	{
		for (int i = 0; i < index - 1; i++)		//移动完之后current指向带插入节点的前一个
		{
			current = current->Next;
		}

		if (index == 0)   //删除的是首节点
		{
			temp = this->Head.Next->Next;     //temp指向1号元素
			temp->Pre = NULL;
			this->Head.Next = temp;           //头节点指向1号位置
			this->Cursor.Next = temp;
			this->Cursor.Pre = NULL;			//游标前驱指向null
			this->ListLen--;
		}

		else if (index == this->ListLen - 1)    //删除的是最后一个节点
		{
			current->Next = NULL;
			this->ListLen--;
			this->Cursor.Next = current;
			this->Cursor.Pre = current->Pre;
		}
		else  //删除的节点非头尾节点
		{
			temp = current->Next->Next;   //temp指向待删除节点的后一个节点
			current->Next = temp;
			temp->Pre = current;
			//设置游标
			this->Cursor.Next = temp;
			this->Cursor.Pre = current;
			this->ListLen--;
		}
	}
	return ret;
}

template<typename T>
//获取链表指定位置的元素
int Twoway_List_Cplus<T>::GetListNode(int index, T &redata)
{
	int ret = 0;
	ListNode<T> *current = this->Head.Next;       //current指向0号几点
	ListNode<T> *temp = NULL;                     //临时指针变量

	if (index < 0 || index > this->ListLen)
	{
		cout << "Index Error ：GetListNode() " << endl;
		ret = -1;
		return ret;
	}
	else
	{
		if (this->ListLen == 0)			     //链表中还没有数据
		{
			cout << "List is empty ：GetListNode() " << endl;
		}
		else
		{
			if (index == 0)
			{
				redata = current->data;
			}
			else
			{
				for (int i = 0; i < index - 1; i++)			 //移动到待获取位置的前面
				{
					current = current->Next;
				}
				redata = current->Next->data;
			}
		}
	}
	return ret;
}

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

template<typename T>
//游标复位
void Twoway_List_Cplus<T>::CursorReset()
{
	this->Cursor.Next = this->Head.Next;
	this->Cursor.Pre = NULL;
}

template<typename T>
//游标下移动
void Twoway_List_Cplus<T>::CursorMoveNext()
{
	ListNode<T> *current = this->Head.Next;         //current指向0号几点
	ListNode<T> *temp = NULL;                         //临时指针变量

	if (this->Cursor.Next->Next == NULL)   //当前节点是最后一个节点
	{
		printf("\n Cursor is in the end point \n");
	}
	else
	{
		temp = this->Cursor.Next;          //temp=当前游标节点位置
		this->Cursor.Pre = temp;           //游标的上一个节点 = 当前游标节点位置
		this->Cursor.Next = temp->Next;    //游标的下一个节点 = 当前游标节点的下一个位置 
	}
}

template<typename T>
//游标上移动
void Twoway_List_Cplus<T>::CursorMovePre()
{
	ListNode<T> *current = this->Head.Next;         //current指向0号几点
	ListNode<T> *temp = NULL;                         //临时指针变量

	if (this->Cursor.Pre == NULL)
	{
		cout << "\n Cursor is in the start point \n" << endl;
	}
	else
	{
		temp = this->Cursor.Next;          //temp=当前游标节点位置
		this->Cursor.Next = temp->Pre;
		this->Cursor.Pre = temp->Pre->Pre;
	}
}

template<typename T>
//获取当前游标的元素
int Twoway_List_Cplus<T>::GetCurrentCursor(T &redata)
{
	int ret = 0;
	if (this->Head.Next == 0)
	{
		cout << "List is empty" << endl;
		ret = -1;
		return ret;
	}
	redata = this->Cursor.Next->data;
	return ret;
}

template<typename T>
//根据传来的节点数据删除节点
int Twoway_List_Cplus<T>::Delete_From_Node(T data)
{
	int tag = 0;
	int i = 0;
	int ret = 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 << "\n can't find element to delete " << endl;
		ret = -1;
		return ret;
	}	

	return ret;
}

测试链表功能源文件：Twoway_List_Cplus_Frame.cpp

# include"pch.h"
# include"Twoway_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 == this->age)
		{
			return true;
		}
		else
		{
			return false;
		}
	
	}

	~person()
	{
	}

public:
	string name;
	int    age;
};

//打印链表的信息
void printf_person(Twoway_List_Cplus<person> &obj)
{
	cout << "\n--------------开始打印数据---------------" << endl;
	person data;
	int ret = 0;
	int tag = 0;
	for (int i = 0; i < obj.ListLen; i++)
	{
		ret = obj.GetListNode(i,data);
		cout << data.name << "    " << data.age << endl;
	}
	cout << "\n --------------结束打印数据---------------" << endl;
}

//打印游标上下移，获取游标
void Printf_Cursor_Move(Twoway_List_Cplus<person> &obj)
{
	person pp;
	int ret = 0;

	cout << "测试游标下移功能 \n" << endl;
	ret = obj.GetCurrentCursor(pp);
	cout << pp.name << "   " << pp.age << endl;

	obj.CursorMoveNext();
	ret = obj.GetCurrentCursor(pp);
	cout << pp.name << "   " << pp.age << endl;

	obj.CursorMoveNext();
	ret = obj.GetCurrentCursor(pp);
	cout << pp.name << "   " << pp.age << endl;

	obj.CursorMoveNext();
	ret = obj.GetCurrentCursor(pp);
	cout << pp.name << "   " << pp.age << endl;

	obj.CursorMoveNext();
	ret = obj.GetCurrentCursor(pp);
	cout << pp.name << "   " << pp.age << endl;

	cout << "\n 测试游标上移功能 \n" << endl;
	ret = obj.GetCurrentCursor(pp);
	cout << pp.name << "   " << pp.age << endl;

	obj.CursorMovePre();
	ret = obj.GetCurrentCursor(pp);
	cout << pp.name << "   " << pp.age << endl;

	obj.CursorMovePre();
	ret = obj.GetCurrentCursor(pp);
	cout << pp.name << "   " << pp.age << endl;

	obj.CursorMovePre();
	ret = obj.GetCurrentCursor(pp);
	cout << pp.name << "   " << pp.age << endl;

	obj.CursorMovePre();
	ret = obj.GetCurrentCursor(pp);
	cout << pp.name << "   " << pp.age << endl;

}

void test()
{
	int ret = 0;
	person p1("pxzz", 21), p2("wxxx", 22), p3("iut", 23), p4("dft", 24), p5("hji", 25), p6("kij", 26), p7("kio", 27);
	Twoway_List_Cplus<person> TLC;
	person dd;

	//测试插入数据
	cout << "测试链表插入功能 \n" << endl;
	ret = TLC.InsertListFront(p1);
	ret = TLC.InsertListFront(p2);
	ret = TLC.InsertListBack(p3);
	ret = TLC.InsertListBack(p4);
	ret = TLC.InsertList(p5, 0);
	ret = TLC.InsertList(p6, 5);
	printf_person(TLC);

	//测试删除数据
	cout << "测试链表删除功能 \n" <<endl;
	ret = TLC.DeleteNode(0);
	printf_person(TLC);

	ret = TLC.DeleteNode(1);
	printf_person(TLC);

	ret = TLC.DeleteNode(4);
	printf_person(TLC);

	ret = TLC.DeleteNode(3);
	printf_person(TLC);

	//测试游标上下移，获取当前游标，游标复位功能
 	TLC.CursorReset();			   //游标复位
	Printf_Cursor_Move(TLC);

	//测试删除给定节点
	ret = TLC.Delete_From_Node(p2);
	printf_person(TLC);
}


int main()
{
	test();
	system("pause");
	return 0;
}

 

pxz_wxx
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
双向链表（用模板实现）
09-16
C++ 双向链表（用模板实现） 大家可以看看，参考一下。
带有游标的双向线性链表(C版本)
qq_41836269的博客
03-13 176
单链表只能从头结点开始访问链表中的数据元素，如果需要逆序访问单链表中的数据元素将极其低效。双链表是链表的一种，由节点组成，每个数据结点中都有两个指针，分别指向直接后继和直接前驱，带有游标的双向链表可以应用在某些特殊的场景。 本次例子中带有游标的双向线性链表类似Linux内核链表，利用地址重叠的特性，它可以轻松的被不同的业务节点包围，业务节点可大可小，突破了传统节点业务单一的局限。详细讲解参照ht...
C++模板类实现带有游标的单向循环链表
qq_41836269的博客
03-13 314
　1，循环链表基于单向链表而生，单向链表的首尾相连，组成一个环状单。循环链表比单向链表多了游标这个概念，游标可以快速的访问当前结点和下一个结点。 2，循环链表在插入第一个元素的时候，需要我们将第一元素的指针域指向其自身，也就构成了循环链表。 3，循环链表在删除链表节点的时候，要注意游标，否则游标容易断开。 4，修改循环链表时候，可以将头部，尾部，非头尾三部分分开考虑。 C...
C/C++ 单链表的游标实现（完整代码）
ylh的博客
12-23 270
不使用任何指针类型，利用游标实现单链表的基本操作，增删改查等各种基本操作
双向链表的C++类模板实现
weixin_33910137的博客
04-08 132
2019独角兽企业重金招聘Python工程师标准>>> ...
深入解析C++的循环链表与双向链表设计的API实现
01-01
循环链表设计与API实现 基本概念 循环链表的定义：将单链表中最后一个数据元素的next指针指向第一个元素 循环链表拥有单链表的所有操作 创建链表 销毁链表 获取链表长度 清空链表 获取第pos个元素操作 插入...
LinkLink_curd_Python双向链表_游标排序_
09-29
Python双向链表
双向链表API及C语言实现
03-29
包含了双向链表的结点结构体、表头结构体、创建双向链表、销毁双向链表、获取链表长度、清空双向链表、插入一个节点元素（包含异常分析）、按位置删除链表结点（包含异常分析）、按元素删除链表结点、返回一个结点...
双向链表C实现
02-04
产品级代码，安全可靠，包含如下功能： ...9.将游标重置指向链表中的第一个数据元素 10.将游标移动指向到链表中的下一个数据元素 11.将游标移动指向到链表中的上一个数据元素 12.直接指定删除链表中的某个数据元素
C++ 实现静态链表的简单实例
01-20
C++ 实现静态链表的简单实例 用数组描述的链表，即称为静态链表。 在C语言中，静态链表的表现形式即为结构体数组，结构体变量包括数据域data和游标cur。 这种存储结构，仍需要预先分配一个较大的空间，但在作为...
双向链表模板类的实现
07-06
数据结构——双向链表模板类的实现 //数据结构——双向链表模板类的实现2007年06月16日 星期六 10:14 ////////////////////////////////////////////////////////////////////// // 模块名： 双向链表模板类 // 代码编写： 子丰 // 最后更新时间： 2006/06/13 ////////////////////////////////////////////////////////////////////
双向链表模板类简单实现
12-12
用模板类实现了一个简单的双向链表domo。
C++模板类——双链表
05-31
使用C++做的双链表模板类 具有头插法，尾插法，左向插入，右向插入，删除结点，获取结点值，设置结点值，复制构造函数，还重载了输出操作符、赋值操作符、相等操作符和不等操作符，还具有倒置链表的功能。还有结点类的重载的输出操作符，具有很好的封装性。
C++实现循环双向链表
痴心不改的博客
12-02 739
typedef int DataType; struct Node { struct Node* _pNext; struct Node* _pPre; DataType _data; Node(const DataType& data = DataType()) : _pNext(NULL) , _pPre(NULL)
c++实现双向链表，类模板双向链表
热门推荐
hugang的博客
09-06 1万+
c++实现双向链表的思想和c很类似，不同的是c++是将实现的函数放在类中，这样就可以由类实例化出对象再调用类中的函数进行添加、删除、查找、插入元素等功能。类模板实现双向链表在最后进行说明和实现，方法依然类似。 c++实现双向链表 #include #include using namespace std; typedef int Datatype; typedef
C++ 类 类模板 结构模板 实现双向链表 一段代码搞懂
专注金融量化投资交易 策略开发
03-16 141
一段代码搞懂 C++ 类 类模板 结构模板 实现双向链表。
双向循环链表 ---- C++使用类模板实现
Zhoujy1996的博客
06-20 424
//双向循环链表类模板 template &lt;typename T&gt; class DLinkList { public: DLinkList(); DLinkList(T elem); DLinkList(int n, T elem); ~DLinkList(); void ClearList() const; bool Empty() c...
C++ 模板实现—双向链表： doubly linked list
学习-记录-分享创造价值
08-27 390
C++模板类实现双向链表
C++模板实现双向循环链表（有带头结点）
he_shuai20的博客
02-18 966
带头结点的双向循环链表，头结点不存储有效数据，有效数据从头结点的下一个节点存储，代码中既实现了完整版的过程，又完成了简单优化。代码如下： #include #include using namespace std; template struct ListNode { T _data; ListNode* _next; ListNode* _prev; ListNode(const
c++builder DBGrid1 不使用游标也能获取行的信息
最新发布
05-26
是的，您可以使用DBGrid的行索引来获取行的信息，而不必使用游标。以下是一个示例代码： ``` int rowIndex = DBGrid1->Row; // 获取当前选中行的索引 TDataSet* dataSet = DBGrid1->DataSource->DataSet; // 获取...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值