自己的底层代码库（二）——双链表

最新推荐文章于 2019-07-22 11:23:37 发布
最新推荐文章于 2019-07-22 11:23:37 发布
阅读量1.1k 收藏 1
点赞数
分类专栏： C++ 文章标签： 容器 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zilaishuichina/article/details/8480831
版权

今天放上双链表的实现


PS：

2013.6.5修改了容器的实现：继承了后面提到的TContainer，实现相关接口。


链表的定义TBDLinkList.h：

#ifndef _TBDLinkList_h_
#define _TBDLinkList_h_

#include <windows.h>

#include "TContainer.h"

template <class T>
class TBDLinkList;

//双向链表结点
template <class T>
struct TBDLinker
{
	TBDLinker<T> *m_pLast;	//上一个结点
	TBDLinker<T> *m_pNext;	//下一个结点
	TBDLinkList<T> *m_pLinkList;//该结点当前从属的链表
	T m_Value;			//值域

	void Init()
	{
		m_pLast = NULL;
		m_pNext = NULL;
		m_pLinkList = NULL;
	}
};

//双向链表
//该类自己不申请TBDLinker，只是负责管理外部申请的TBDLinker结点
//将其链表化，提供插入、删除功能
template <class T>
class TBDLinkList : public TContainer<T>
{
public:
	TBDLinkList();
	~TBDLinkList();

	//将pLinker加入到链表尾
	//放入结点时将对pLinker的m_pLinkList赋值this
	//成功返回true
	//参数不合法，返回false
	//pLinker本身已经有从属链表（m_pLinkList不为NULL）返回false
	bool PushTail(TBDLinker<T> *pLinker);

	//将pLinker接在pLaster的后面
	//放入结点时将对pLinker的m_pLinkList赋值this
	//成功返回true
	//参数不合法，返回false
	//pLaster不属于当前链表返回false
	//pLinker本身已经有从属链表（m_pLinkList不为NULL）返回false
	bool InsertAsNext(TBDLinker<T> *pLaster, TBDLinker<T> *pLinker);

	//将pLinker接在pNexter的前面
	//放入结点时将对pLinker的m_pLinkList赋值this
	//成功返回true
	//参数不合法，返回false
	//pNexter不属于当前链表返回false
	//pLinker本身已经有从属链表（m_pLinkList不为NULL）返回false
	bool InsertAsLast(TBDLinker<T> *pLinker, TBDLinker<T> *pNexter);

	//从链表头拿一个pLinker出来，链表中删除pLinker
	//取出结点时pLinker的m_pLinkList将被置空
	//成功返回pLinker
	//链表本身没有结点了返回NULL
	TBDLinker<T> *PopHead();

	//在链表中断开pLinker
	//断开结点时pLinker的m_pLinkList将被置空
	//成功返回true
	//参数不合法，返回false
	//结点不属于当前链表返回false
	bool Remove(TBDLinker<T> *pLinker);

	//初始化\清空链表
	void Init(ContainerFlag dwLock = enum_EnableLock);

	//获取链表头对象
	//若m_pHead为空则返回空
	T *GetHead();

	//获取链表头
	//若m_pHead为空则返回空
	TBDLinker<T> *GetHeadNode();

	//获取链表中curr的下一个对象
	//若curr为空则返回空
	//若curr不属于当前链表则返回空
	//若curr没有下一个对象则返回空
	T *GetNext(T *curr);

	//获取链表中curr对应的结点对象
	//若curr为空则返回空
	//PS：该函数不区分curr是否属于当前链表
	void *GetNode(T *curr);

private:
	TBDLinker<T> *m_pHead;//头指针
	TBDLinker<T> *m_pTail;//尾指针
};

#include "TBDLinkList.hpp"

#endif


该类设计思路与之前的单链表大致相同，需要再说明的两点：

1、增加了一个 “结点当前从属的链表”字段m_pLinkList，（1）是用来对插入链表的结点的合法性做检查，当你要插入的结点实际上已经在该链表上的时候，通过该字段的验证可以排除这种情况。（2）是当逻辑中存在多个链表对象来管理结点的情况下，比如有3个链表list1，list2，list3分别表示3种不同状态的队列，结点node会在这3个队列中（也就是在3种状态间）切换的时候，m_pLinkList可以明确的指出node当前属于哪一个队列上，或者不属于任何一个队列，不需要为了确定该结点在什么地方而做遍历。

2、结点中T m_Value的设计，当出现T需要由不用容器同时来管理的时候，比如T，在T的对象池中，空闲对象的队列希望由单链表来管理（插入删除方便），使用中对象的队列希望由AVL树来管理（查找快一点），该怎么办。这时采用的就是模版的嵌套来解决，比如 TLinker<TreeNode<T>>。


实现TBDLinkList.hpp

#ifndef _TBDLinkList_hpp_
#define _TBDLinkList_hpp_

template <class T>
TBDLinkList<T>::TBDLinkList()
{
	Init();
}

template <class T>
TBDLinkList<T>::~TBDLinkList()
{
	Init();
}

template <class T>
void TBDLinkList<T>::Init(ContainerFlag dwLock)
{
	m_pHead = NULL;
	m_pTail = NULL;
	m_dwLen = 0;
	m_dwLock = dwLock;
}

template <class T>
bool TBDLinkList<T>::PushTail(TBDLinker<T> *pLinker)
{
	bool bRes = false;

	if (NULL != pLinker)
	{
		//此处需要在下面if的外面加锁
		//因为pLinker->m_pLinkList在多线程环境下可能会变
		if (enum_EnableLock == m_dwLock)
		{
			m_csLock.Lock();
		}

		if (NULL == pLinker->m_pLinkList)
		{
			pLinker->m_pLast = m_pTail;
			pLinker->m_pNext = NULL;
			pLinker->m_pLinkList = this;

			if (NULL != m_pTail)
			{
				m_pTail->m_pNext = pLinker;
			}
			m_pTail = pLinker;

			if (NULL == m_pHead)
			{
				m_pHead = pLinker;
			}

			m_dwLen++;

			bRes = true;
		}

		if (enum_EnableLock == m_dwLock)
		{
			m_csLock.UnLock();
		}
	}

	return bRes;
}

template <class T>
bool TBDLinkList<T>::InsertAsNext(TBDLinker<T> *pLaster, TBDLinker<T> *pLinker)
{
	bool bRes = false;

	if (NULL != pLinker && NULL != pLinker)
	{
		if (enum_EnableLock == m_dwLock)
		{
			m_csLock.Lock();
		}

		if (this == pLaster->m_pLinkList && NULL == pLinker->m_pLinkList)
		{
			pLinker->m_pLast = pLaster;
			pLinker->m_pNext = pLaster->m_pNext;
			pLaster->m_pNext = pLinker;
			if (NULL != pLinker->m_pNext)
			{
				pLinker->m_pNext->m_pLast = pLinker;
			}
			pLinker->m_pLinkList = this;

			if (pLaster == m_pTail)
			{
				m_pTail = pLinker;
			}

			m_dwLen++;

			bRes = true;
		}

		if (enum_EnableLock == m_dwLock)
		{
			m_csLock.UnLock();
		}
	}

	return bRes;
}

template <class T>
bool TBDLinkList<T>::InsertAsLast(TBDLinker<T> *pLinker, TBDLinker<T> *pNexter)
{
	bool bRes = false;

	if (NULL != pLinker && NULL != pLinker)
	{
		if (enum_EnableLock == m_dwLock)
		{
			m_csLock.Lock();
		}

		if (this == pNexter->m_pLinkList && NULL == pLinker->m_pLinkList)
		{
			pLinker->m_pNext = pNexter;
			pLinker->m_pLast = pNexter->m_pLast;
			pNexter->m_pLast = pLinker;
			if (NULL != pLinker->m_pLast)
			{
				pLinker->m_pLast->m_pNext = pLinker;
			}
			pLinker->m_pLinkList = this;

			if (pNexter == m_pHead)
			{
				m_pHead = pLinker;
			}

			m_dwLen++;

			bRes = true;
		}

		if (enum_EnableLock == m_dwLock)
		{
			m_csLock.UnLock();
		}
	}

	return bRes;
}

template <class T>
TBDLinker<T> *TBDLinkList<T>::PopHead()
{
	TBDLinker<T> *pLinker = NULL;

	if (enum_EnableLock == m_dwLock)
	{
		m_csLock.Lock();
	}

	if (NULL != m_pHead)
	{
		pLinker = m_pHead;

		ResetNext(&(pLinker->m_Value));

		m_pHead = m_pHead->m_pNext;

		pLinker->m_pNext = NULL;
		pLinker->m_pLast = NULL;
		pLinker->m_pLinkList = NULL;

		if (m_pTail == pLinker)
		{
			m_pTail = NULL;
		}

		if (NULL != m_pHead)
		{
			m_pHead->m_pLast = NULL;
		}

		m_dwLen--;
	}

	if (enum_EnableLock == m_dwLock)
	{
		m_csLock.UnLock();
	}

	return pLinker;
}

template <class T>
bool TBDLinkList<T>::Remove(TBDLinker<T> *pLinker)
{
	bool bRes = false;

	if (NULL != pLinker)
	{
		if (enum_EnableLock == m_dwLock)
		{
			m_csLock.Lock();
		}

		if (this == pLinker->m_pLinkList)
		{
			ResetNext(&(pLinker->m_Value));

			if (m_pHead == pLinker)
			{
				m_pHead = pLinker->m_pNext;
			}
			if (m_pTail == pLinker)
			{
				m_pTail = pLinker->m_pLast;
			}
			if (NULL != pLinker->m_pNext)
			{
				pLinker->m_pNext->m_pLast = pLinker->m_pLast;
			}
			if (NULL != pLinker->m_pLast)
			{
				pLinker->m_pLast->m_pNext = pLinker->m_pNext;
			}
			pLinker->m_pNext = NULL;
			pLinker->m_pLast = NULL;
			pLinker->m_pLinkList = NULL;

			m_dwLen--;

			bRes = true;
		}

		if (enum_EnableLock == m_dwLock)
		{
			m_csLock.UnLock();
		}
	}

	return bRes;
}

template <class T>
T *TBDLinkList<T>::GetHead()
{
	T *pRes = NULL;

	if (enum_EnableLock == m_dwLock)
	{
		m_csLock.Lock();
	}

	if (NULL != m_pHead)
	{
		pRes = &(m_pHead->m_Value);
	}

	if (enum_EnableLock == m_dwLock)
	{
		m_csLock.UnLock();
	}

	return pRes;
}


template <class T>
TBDLinker<T> *TBDLinkList<T>::GetHeadNode()
{
	return m_pHead;
}

template <class T>
T *TBDLinkList<T>::GetNext(T *curr)
{
	T *pRes = NULL;

	if (NULL != curr)
	{
		if (enum_EnableLock == m_dwLock)
		{
			m_csLock.Lock();
		}

		TBDLinker<T> *pCurrLinker = (TBDLinker<T> *)GetNode(curr);
		if (this == pCurrLinker->m_pLinkList)
		{
			if (NULL != pCurrLinker->m_pNext)
			{
				pRes = &(pCurrLinker->m_pNext->m_Value);
			}
		}

		if (enum_EnableLock == m_dwLock)
		{
			m_csLock.UnLock();
		}
	}

	return pRes;
}

template <class T>
void *TBDLinkList<T>::GetNode(T *curr)
{
	TBDLinker<T> *pRes = NULL;

	if (NULL != curr)
	{
		pRes = ContainerOf(curr, TBDLinker<T>, m_Value);
	}

	return pRes;
}

#endif



zilaishuichina
关注
专栏目录
细说 单链表、双向链表 、LinkedList类（附 add 源码解读）和 ArrayList 和 LinkedList 的区别 —— 数据结构
honglan297的博客
07-25 735
本篇文章将从链表的相关概念入手，对单向、双线链表进行模拟实现，再回到 LinkedList 集合内当中进行简单分析，最后结合上一篇文章，阐述四点 LinkedList 和 ArrayLIst 区别。
史上最全的C++/游戏开发面试问题总结（二）——虚函数，内存，STL
Jerish的博客
08-10 4520
笔者毕业两年，最近通过猎头拿到了腾讯游戏以及网易游戏的两个客户端研发offer（UE4/C++）。在面试前夕，笔者对C++进行了较为全面的复习和总结，乐观估计可以涵盖80%左右的面试基础问题。 这个系列的文章预计有《C++基础》、《内存、STL、虚函数相关》、《数据结构与算法》、《操作系统与网络》四篇（当前是第二篇），每篇都是以问答的形式分享并给出了参考资料的链接地址。大部分问题回答的比较简洁，需...
通用双向链表的设计（参考Linux系统中的实现）
weixin_34377065的博客
03-10 148
通常我们设计设计链表都是将数据域放在里面，这样每次需要使用链表的时候都需要实现一个链表，然后重新实现它的相关操作，这里参考Linux系统中的设计实现了一个通用的双向链表，只需要在你的结构里面有一个这个链表的域，就可以使用链表的相关操作了。 注意：这个通用的双向链表是参考Linux系统中的实现，它使用了typeof这个功能，所以有些编译器可能不支持。我是再...
自己的底层代码库（四）——计时模块，以及效率测试
zilaishuichina的专栏
01-31 1750
测试效率需要计时的模块 所以首先发一下计时模块的代码，用的是QueryPerformanceFrequency跟QueryPerformanceCounter CPerformance.h头文件 #ifndef _CPerformance_h_ #define _CPerformance_h_ #include class CPerformance { public: CPerf
链表的底层实现方式
xu404741377的博客
06-21 7681
链表在我们日常的开发过程中应该说是非常常见，做移动开发的更可以说是每天都在接触。比如MessageQueue，底层就是单链链表，各种网络框架用到的队列，底层用到的都是链表。而说到链表，就不得不提到另外一种数据结——集合。相信有一句话大家都听书过：集合更适合查询操作，链表更适合频繁的插入，删除操作。这究竟是为什么呢？今天我就从理论和代码的角度分析一下其中的原因。 首先，集合的底层是数组，数组会为每
LinkedList底层原理（双向链表）
各种西瓜的博客
05-16 1485
public class LinkedList<E> { private Node<E> first; private Node<E> last; private int size; private class Node<E> { private Node<E> prev; private Node<E> next; E
自己的底层代码库（九）——插入式的双链表
zilaishuichina的专栏
04-18 833
之前发过一个 非插入式的 这里之所以再发一个插入式的，是为了后面实现一个迭代器准备的 将迭代器注册给容器的时候，容器里面单独用了这样一个双链表来管理所有在该容器上注册的迭代器 又因为双链表本身就是容器的一种，出现了容器里面有容器的情况 又不想用指针，指针意味着需要另行分配内存 所以另外再实现了一个双链表，只用来管理容器上所有注册的迭代器 至于链表的插入删除这种操作，跟之
C语言标准代码库存档(C库、STL库、Glibc库).zip
09-04
这个压缩包"**C语言标准代码库存档(C库、STL库、Glibc库)**"包含了C语言标准库的重要组成部分，以及两个重要的扩展库——STL库和Glibc库。 C标准库，也被称为ISO C99或C11标准库，是C语言的标准实现，包括了如、、...
Python中线性表的秘密：栈、队列、双链表和循环链表的实用技巧
[Python中线性表的秘密：栈、队列、双链表和循环链表的实用技巧](https://programmathically.com/wp-content/uploads/2021/06/queue-1024x598.png) # 1. 线性表在Python中的实现原理 线性表是最基本、最简单的一种...
《基础知识——编译与底层》
安徒生木槿
07-22 230
一个C++源文件从文本到可执行文件经历的过程？ 对于C++源文件，从文本到可执行文件一般需要四个过程： 1、预处理阶段：对源代码文件中文件包含关系（头文件）、预编译语句（宏定义）进行分析和替换，生成预编译文件。 2、编译阶段：将经过预处理后的预编译文件转换成特定汇编代码，生成汇编文件 3、汇编阶段：将编译阶段生成的汇编文件转化成机器码，生成可重定位目标文件 4、链接阶段：将多个目...
两个链表的第一个公共结点
Gunther的博客
12-06 100
1.蛮力法。O(m*n) 两层for循环遍历两个链表一个个匹配。 2.空间换时间。牛客网签到。 分析：先遍历一个链表存放在hash表中，在顺序遍历另一个链表同时查看hash表中是否存在，存在就是公共节点，直接返回。 c++ code: class Solution { public: ListNode* FindFirstCommonNode(ListNode* pHead1, ListNode...
好用的链表操作库。
积水成渊
08-25 1604
好用的C链表操作库
双层循环遍历链表删除重复元素
二哈
11-29 1361
1.删除链表中的重复元素，要求是不能够使用缓冲区 由于题目要求了不能够使用额外的空间来进行辅助我们找出重复的元素，即不能够使用额外的数据结构来保存元素，所以我们不能够使用哈希表（HashSet）来辅助我们找出重复的元素了，但是我们可以普遍的做法：使用双重循环来找出重复的元素 在链表中一般是使用while循环而不使用for循环来遍历元素 其中要使用到四个指针，第一个指针first指向的是第一...
自己的底层代码库（七）——对象索引（修改）
zilaishuichina的专栏
03-07 1111
之前想把索引功能集成到对象池中 但是主要因为涉及到TTree的结点申请，结点申请用到内存池又涉及到多线程加锁的问题，而最理想的是一个线程一个内存池，不用加锁 仔细考虑了下发现集成进去反而不是很灵活 那么这里有多种实现方案 1、直接用stl的map，之前map怎么用现在还是怎么用 2、用TTree替代map（我不知道map里面是不是做了其他的维护操作，目前测下来TTree的查找
自己的底层代码库（八）——获取函数调用堆栈
zilaishuichina的专栏
04-03 6368
今天放上一个工具类，用来获取当前线程/所有线程的当前函数调用堆栈 主要是为了方便用于在打log时，可以将调用堆栈一起输出到文件当中 PS：想打出正确的log是依赖于PDB文件的 类似于VS的向output窗口输出$CALLSTACK 主要用了dbghelp的一些API 参考了： http://www.cnblogs.com/zplutor/archive/2011/04/2
自己的底层代码库（五）——内存池，附加效率测试
zilaishuichina的专栏
02-06 2342
明天回家了~~~~ 今天放上一个内存池的实现，该内存池基于之前发的单链表和双链表。并且参考了Apache内存池的实现。 PS 2013.2.21修改： 将之前的单链表管理的分配子改为AVL树管理 2013.3.1修改： 因为AVL树的结点结构有做修改 内存池也做了相关功能的修改。 主要是内存池分配子的查找操作，bool operator 增加了
自己的底层代码库（十七）——随机数池
zilaishuichina的专栏
07-09 1666
实际开发过程中，可能会遇到这样的需求：在0到x范围内，生成n（n 这里给出一个简单的实现，其实就是以空间换时间的。 定义长x的数组，对这个数组采用洗牌法打乱顺序，然后顺序的取前n个。 Rand()一下则为重新洗牌。 TRandPool.h #ifndef _TRandPool_h_ #define _TRandPool_h_ #include #incl
C语言实现与操作双向链表
"C语言实现双向链表的代码分享，包括插入、删除、修改节点操作" 在计算机科学中，数据结构是编程的基础，其中链表是一种非常重要的非线性数据结构。双向链表作为链表的一种变体，允许我们在每个节点中存储到前一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值