链表（下） DualLinkList、DualCircleList

最新推荐文章于 2020-09-22 17:58:57 发布
最新推荐文章于 2020-09-22 17:58:57 发布
阅读量196 收藏
点赞数
分类专栏： C++数据结构 文章标签： 单链表 c++ 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Es_Study_Yu/article/details/104772758
版权

目录

DualLinkList

  双向链表的由来：单链表只可以向后访问，如果要逆序访问，效率将会很低

  双向链表的特点：
　　　　比单链表多了前驱，可以逆序访问
　　　　提供游标与步长，使用方式与单链表相同
　　　　
DualLinkList.h

#ifndef _DualLinkList_H_
#define _DualLinkList_H_
#include "include/LinuxList.h"
#include "include/Exception.h"

namespace JYlib
{

/*				双向链表
功能：
*/
template < typename T >
class DualLinkList:public List<T>
{
protected:
#pragma pack(4)
	struct Node : public Object
	{
		T value;
		Node* next;
		Node* pre;
	};
	/*
		不直接使用Node*声明(使用sizeof)，是为了避开泛指类型T的构造，因为T的构造可能会发生异常
		都继承自顶层父类，保证内存布局与node相同，就可以通过retinterpret_cast强制转换来使用
		mutable的声明是因为const成员函数中会取m_header的地址
	*/
	mutable struct : public Object
	{
		char reserved[sizeof(T)];
		Node* next;
		Node* pre;
	}m_header; 
#pragma pack()
	
	int m_length;


	Node* m_current;//游标当前位置
	int m_step;//游标步进的长度

	//定位对象的前一个位置
	Node* position(int i)const
	{
		Node* ret = reinterpret_cast<Node*>(&m_header);

		for(int j = 0;j < i;j++)
		{
			ret = ret->next;
		}
		return ret;
	}

	//封装申请与删除 增强拓展性
	virtual Node* create()
	{
		return new Node();
	}

	virtual void destroy(Node* pn)
	{
		delete pn;
	}
public:
	DualLinkList()
	{
		m_header.pre = NULL;
		m_header.next = NULL;
		m_current = NULL;
		m_step = 1;
		m_length = 0;
	}

    DualLinkList(const List<T>& t);

    DualLinkList& operator =(const List<T>& e);

	bool insert(const T& e)
	{
		return insert(m_length,e);
	}

	bool insert(int i,const T& e)
	{
		bool ret = (0 <= i)&&(i <= m_length);//小于等于是为了可以在末尾插入
		if(ret)
		{
			Node* new_Node = create();

			if(new_Node != NULL)
			{
				Node* current = position(i);
				Node* next = current->next;

				new_Node->value = e;
				
				current->next = new_Node;
				new_Node->next = next;

				if(current != reinterpret_cast<Node*>(&m_header))//如果不是首结点
				{
					new_Node->pre = current;
				}
				else
				{
					new_Node->pre = NULL;
				}
				if(next != NULL)//下一个节点是否使用
				{
					next->pre = new_Node;
				}

				m_length++;
			}
			else
			{
				THROW_EXCEPTION(NoEnoughMemoryException,"No memory to create DynamicList object ...");
			}
		}
		return ret;
	}

	bool remove(int i)
	{
		bool ret = ((0 <= i)&&(i < m_length));
		if(ret)
		{
			Node* current = position(i);
			Node* remove = current->next;
			Node* next = remove->next;

			if(m_current == remove)//如果当前游标在此，则游标指向下一个位置
			{
				m_current = next;
			}
			current->next = next;
			if(next != NULL)
			{
				if(current == reinterpret_cast<Node*>(&m_header))//如果是首结点,前一个节点为空
				{
					next->pre = NULL;
				}
				else
				{
					next->pre = current;
				}
			}
			
			m_length--;
			destroy(remove);//先改数据，后析构，即使析构出问题，其仍然已经不是单链表一员
		}
		return ret;
	}

	bool set(int i,const T& e)
	{
		bool ret = (0 <= i)&&(i < m_length);
		if(ret)
		{
			position(i)->next->value = e;
		}
		else
		{
			THROW_EXCEPTION(IndexOutOfBoundsException,"Parameter i is invalid ...");//抛出数组越界异常
		}
		return ret;
	}

	bool get(int i,T& e)const
	{
		bool ret = (0 <= i)&&(i < m_length);
		if(ret)
		{
			e = position(i)->next->value;
		}
		else
		{
			THROW_EXCEPTION(IndexOutOfBoundsException,"Parameter i is invalid ...");//抛出数组越界异常
		}
		return ret;
	}
	
	virtual T get(int i)const
	{
		T ret;

		get(i,ret);

		return ret;
	}

	int find(const T& e)const
	{
		int ret = -1;
		int i = 0;
		Node* node = m_header.next;
		
		while(node != NULL)
		{
			if(node->value == e)
			{
				ret = i;
				break;
			}
			else
			{
				node = node->next;
				i++;
			}
		}
		return ret;
	}

	int length(void)const
	{
		return m_length;
	}

	//游标移动到目的地址，并重设置步进值
	virtual bool move(int i,int step = 1)
	{
		bool ret = (0 <= i)&&(i < m_length)&&(step > 0);
		if(ret)
		{
			m_current = position(i)->next;
			m_step = step;
		}
		else
		{
			THROW_EXCEPTION(IndexOutOfBoundsException,"Parameter i is invalid ...");//抛出数组越界异常
		}

		return ret;
	}

	//游标是否到末尾
	virtual bool end()
	{
		return (m_current == NULL);
	}

	//当前游标的值
	virtual T current()
	{
		if(!end())
		{
			return m_current->value;
		}
		else
		{
			THROW_EXCEPTION(IndexOutOfBoundsException,"Parameter i is invalid ...");//抛出数组越界异常
		}
	}
	
	//步进至一个游标
	virtual bool next()
	{
		int i = 0;
		while((i < m_step)&&(!end()))
		{
			m_current = m_current->next;
			i++;
		}
		return (i == m_step);
	}

	virtual bool pre()
	{
		int i = 0;
		while((i < m_step)&&!end())
		{
			m_current = m_current->pre;
			i++;
		}
		return (i == m_step);
	}

	void clear()
	{
		while(m_length > 0)
		{
			remove(0);
		}
	}

	~DualLinkList()
	{
		clear();
	}
};

}


#endif

DualCircleList


  通过Linux内核链表实现：

DualCircleList_Linux.h

#ifndef _DualCircleLinkList_Linux_H_
#define _DualCircleLinkList_Linux_H_
#include "include/DualLinkList.h"
#include "include/LinuxList.h"

namespace JYlib
{

/*				双向循环链表
功能：增删查改  前序与后序遍历
*/
template < typename T>
class DualCircleList_Linux:public DualLinkList<T>
{
protected:
	struct Node:public Object
	{
		list_head head;//双指针结构体
		T value;
	};

	list_head m_header;
	list_head* m_current;

	list_head* position(int i)const
	{
		list_head* ret = const_cast<list_head*>(&m_header);

		for(int p=0;p<i;p++)
		{
			ret = ret->next;
		}
		return ret;
	}

	int mod(int i)const
	{
		return (this->m_length == 0 ? 0 : i%(this->m_length));
	}
public:
    DualCircleList_Linux():DualLinkList<T>()
	{
		m_current = NULL;
		INIT_LIST_HEAD(&m_header);
	}

	bool insert(const T& e)
	{
		return insert(this->m_length,e);
	}

	bool insert(int i,const T& e)
	{
		bool ret = true;
		i = i % (this->m_length + 1);

		Node* new_node = new Node();
		if(new_node != NULL)
		{
			new_node->value = e;

			list_add_tail(&new_node->head,position(i)->next);
			this->m_length++;
		}
		else
		{
			THROW_EXCEPTION(NoEnoughMemoryException,"No memory to insert new element ...");
		}
		return ret;
	}

	bool remove(int i)
	{
		i = mod(i);
		bool ret =(0 <= i)&&(i < this->m_length);

		if(ret)
		{
			list_head* remove = position(i)->next;
			if(m_current == remove)
			{
				m_current = m_current->next;
			}
		
			list_del(remove);

			this->m_length--;

			delete list_entry(remove,Node,head);
		}
		
		return ret;
	}

	T get(int i)const
	{
		T ret;

		get(i,ret);

		return ret;
	}

	bool get(int i,T& e)const
	{
		i = mod(i);
		bool ret = ( (0 <= i)&&(i < this->m_length) );

		if(ret)
		{
			e = list_entry(position(i)->next,Node,head)->value;
		}

		return ret;
	}

	bool set(int i,const T& e)
	{
		i = mod(i);
		bool ret = ( (0 <= i)&&(i < this->m_length) );

		if(ret)
		{
			list_entry(position(i)->next,Node,head)->value = e;
		}

		return ret;
	}

	int find(const T& e)const
	{
		int ret = -1;

		int i = 0;

		list_head* silder = NULL;

		list_for_each(silder,&m_header)
		{
			if(list_entry(silder,Node,head)->value == e)
			{
				ret = i;
				break;
			}
			i++;
		}
		return ret;
	}

	bool move(int i,int step = 1)
	{
		bool ret = (step > 0);

		i = mod(i);

		ret = ret && (0 <= i) && (i < this->m_length);

		if(ret)
		{
			m_current = position(i)->next;

			this->m_step = step;
		}
		return ret;
	}

	bool end()
	{
        return (m_current == NULL || this->m_length == 0);
	}

	//当前游标的值
	T current()
	{
		if(!end())
		{
			return list_entry(m_current,Node,head)->value;
		}
		else
		{
			THROW_EXCEPTION(IndexOutOfBoundsException,"Parameter i is invalid ...");//抛出数组越界异常
		}
	}
	
	//步进至一个游标
	bool next()
	{
		int i = 0;
		while((i < this->m_step)&&!end())
		{
			if(m_current != &m_header)
			{
				m_current = m_current->next;
				i++;
			}
			else
			{
				m_current = m_current->next;
			}
		}
		if(m_current == &m_header)
		{
			m_current = m_current->next;
			i++;
		}
		return (i == this->m_step);
	}

	bool pre()
	{
		int i = 0;
		while((i < this->m_step)&&!end())
		{
			if(m_current != &m_header)
			{
				m_current = m_current->prev;
				i++;
			}
			else
			{
				m_current = m_current->prev;
			}
		}
		if(m_current == &m_header)
		{
			m_current = m_current->prev;
			i++;
		}

		return (i == this->m_step);
	}

	void clear()
	{
		while(this->m_length > 0)
		{
			remove(0);
		}
	}

	~DualCircleList_Linux()
	{
		clear();
	}
};

}


#endif

  通过双向链表以及循环链表实现：
DualCircleList.h

#ifndef _DualCircleLinkList_H_
#define _DualCircleLinkList_H_
#include "include/DualLinkList.h"

namespace JYlib
{

template < typename T>
class DualCircleList:public DualLinkList<T>
{
protected:
    typedef typename DualCircleList<T>::Node Node;

	int mod(int i)const
	{
		return (this->m_length == 0 ? 0 : i%(this->m_length));
	}

	Node* last()
	{
		return (this->position(this->m_length));
	}

	void last_to_first()
	{
		Node* m_last = last();
		this->m_header.next->pre = m_last;
		m_last->next = this->m_header.next;
	}
    
public:
    DualCircleList():DualLinkList<T>()
	{

	}

	bool insert(const T& e)
	{
        return insert(this->m_length,e);
	}

	bool insert(int i,const T& e)
	{
		bool ret = DualLinkList<T>::insert(i,e);
		i = i % (this->m_length + 1);

		if(ret && (i == 0))
		{
			last_to_first();
		}
		
		return ret;
	}

	bool remove(int i)
	{
		bool ret = false;
		i = mod(i);
		
		if(i == 0)//删除的是头结点
		{
			Node* remove = this->m_header.next;
			Node* next = remove->next;
			if(remove == NULL)
			{
				return false;
			}
			else
			{
				this->m_length--;
				this->m_header.next	= next;

				if(next == NULL)//除首结点外无节点
				{
					this->m_header.next = NULL;
					this->m_header.pre = NULL;
					this->m_current = NULL;
				}
				else//除首结点外有节点
				{
					if(this->m_current == remove)
					{
						this->m_current = this->m_current->next;
					}
					last_to_first();
				}
				this->destroy(remove);
				ret = true;
			}
		}
		else//删除非头结点
		{
			ret = DualLinkList<T>::remove(i);
		}
		return ret;
	}

	T get(int i)const
	{
		return DualLinkList<T>::get(mod(i));
	}

	bool get(int i,const T& e)const
	{
		return DualLinkList<T>::get(mod(i),e);
	}

	bool set(int i,const T& e)
	{
		return DualLinkList<T>::set(mod(i),e);
	}

	int find(const T& e)const
	{
		int ret = -1;

		Node* silder = this->m_header.next;

		for(int i=0;i<this->m_length;i++)
		{
			if(silder->value == e)
			{
				ret = i;
				break;
			}
			silder = silder->next;
		}

		return ret;
	}

	void clear()
	{
		if(this->m_length > 0)
		{
			while(this->m_length > 1)
			{
				remove(1);
			}
			if(this->m_length == 1)
			{
				Node* remove = this->m_header.next;

				this->m_header.next = NULL;
				this->m_header.pre = NULL;
				this->m_current = NULL;
				this->m_length = 0;

				this->destroy(remove);
			}
		}
	}

	bool move(int i,int step = 1)
	{
		return DualLinkList<T>::move(mod(i),step);
	}

	bool end()
	{
		return (this->m_length == 0)||(this->m_current == NULL); 
	}

	~DualCircleList()
	{
		clear();
	}
};

}


#endif
Programmer-YU
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LinkedList（链表）
m0_50744075的博客
09-14 468
链表
SingleLinkedList（单链表）
Joeo8
01-22 678
SingleLinkedList（单链表） SingleLinkedList 单链表结构中，将数据存放在各个节点中。如下图所示，在每个节点内部，有两部组成。（data+next）即数据和指针。所谓单链表无疑是链式存储方式，节点中的next指针指向下一个节点，存储空间不是连续的。 单链表结构中有两种形式（下文以带头结点的单链表为例） 带头结点的单链表 头节点起标记作用，节点中不存放具体数据。 next指向第一个有具体数据的节点 不带头结点的单链表 Operation
双向循环链表DualCircleList的实现（利用Linux内核链表）
独行Freedom的博客
03-22 219
目标   使用Linux内核链表实现双向循环链表DualCircleList。 设计思路   数据结点之间在逻辑上构成双向循环链表，头结点仅用于结点的定位。 实现思路 （1）通过模板定义 DualCirclelist 类，继承自 DualLinkList类； （2）在 DualCircleList 内部使用 Linux 内核链表进行实现； （3）使用 struct lis...
DualLinkList
木子皿--啥都不会的菜鸟
09-22 292
文章目录1 单链表的缺陷![在这里插入图片描述](https://img-blog.csdnimg.cn/2019030510214774.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1Nsb3dJc0Zhc3RMZW1vbg==,siz...
CircleLinkList(循环链表)
ding7530的博客
08-06 270
　　尾插法和循环链表。 #include <stdio.h> #include <stdlib.h> typedef struct CircleLinkList { int data; struct CircleLinkList * next; }circleLinkList; int main() { ...
C++数据结构-单链表创建
年少轻狂，幸福时光
08-22 8161
    前边我们创建了顺序存储结构的线性表，简称顺序表，顺序表最大的问题是：插入和删除需要移动大量的元素。为了解决 这个问题， 我们引入链式存储结构的线性表，简称链表，链表与顺序表不同，链表的每个结点在内存中是分开存放的，每个结点都包含数据域和指针域：     - 数据域 ：存储数据元素本身     - 指针域 ：存储相邻结点的地址 链式存储结构的线性表有     - 单链表：每个结点只包含...
双向链表DualLinkList的实现
独行Freedom的博客
03-22 530
单链表的缺陷 在前文中实现了单链表LinkList（点击这里），但是单链表存在一定的缺陷： 只能从头结点开始高效访问链表中的数据元素（单向性）； 如果需要逆向访问单链表中的数据元素将极其低效； 数据插如操作和取数据元素操作时间复杂度不一样。 双向链表 因此需要设计一种新的线性表，设计思路：   在“单链表”的结点中增加一个指针pre，用于指向当前结点的前驱结点。 特点： ...
C语言实现静态链表
08-18
游标域用来存储当前结点的下一个结点的索引。静态链表的初始化时，只有最后一个结点的游标域是0，表示头指针，并没有任何分配的空间。备用链表的头指针是空间的第一个位置，最后一个指针的游标域也是0。 静态链表的...
07丨链表（下）：如何轻松写出正确的链表代码？1
08-03
链表的每个节点包含数据和指向下一个节点的指针，这种结构使得链表在插入和删除操作上相比数组更具优势，但同时也增加了编写链表操作代码的复杂性。 【链表操作】如链表反转和有序链表合并是常见的面试题目，也是...
Leetcode 反转链表.js
最新发布
02-21
在JavaScript中，链表通常通过构建一个ListNode类来表示，其中包含val和next两个属性，分别表示节点的值和指向下一个节点的指针。反转链表的基本思路是遍历原链表，逐个节点地更改它们的next指针，将它们指向前一个...
链表的相关知识PPTX
08-06
链表的每个元素都包含两个信息：元素的值和指向下一个元素的指针。链表可以分为单链表、双链表和循环链表等多种类型。 原理1：链表的基本结构 链表的基本结构由节点组成，每个节点包括两个部分：数据域和指针域。...
基本链表1
08-08
链表是一种数据结构，它由一系列节点组成，每个节点包含数据以及指向下一个节点的指针。在这里，我们主要关注单向链表的操作。 首先，链表的插入操作： 1. `insert_link_head` 函数用于在链表的头部插入新的节点。...
通用树抽象父类——Tree、TreeNode
Es_Study_Yu的博客
04-02 5868
目录树的基本概念TreeTreeNode 树的基本概念   树的定义： 　　　　树是一种非线性的数据结构 　　　　树是由 n(n >= 0)个结点组成的有限集合，若 n = 0，则称之为空树 　　　　树中(n > 0)的首结点，称为根节点，根节点只有直接后继，没有直接前驱 　　　　除根以外的其它结点划分为m (m >= 0)个互不相交的有限集合T0 , T1, …，Tm-1, 每...
二叉树结构——BTree、BTreeNode
Es_Study_Yu的博客
04-05 1720
目录二叉树引言二叉树的性质二叉树的存储结构设计二叉树的结点查找操作二叉树中的插入操作 二叉树引言   通用树的结构过于复杂，工程中很少会用到这么复杂的树，该如何简化呢？→减少孩子结点数量→二叉树   通用树结构回顾 　　　　双亲孩子表示法： 　　　　　　每个结点都有一个指向其双亲的指针 　　　　　　每个结点都有若干个指向其孩子的指针   二叉树树结构引进 　　　　孩子兄弟表示法： 　　　　　...
通用树结构——GTree、GTreeNode
Es_Study_Yu的博客
04-03 1561
  通用树结构工程量比较大，我没时间把每一个点扩展开，详细的附上说明与过程。我浓缩了下步骤，过程全部体现在代码与注释里了。所以希望阅读的小伙伴可以按一个目录为一章的心态，根据目录的顺序与讲解，对照代码一点点的去理解。   其中因为继承，也涉及了Tree与TreeNode中的成员变量，所以对照抽象父类来阅读会更加方便。（https://blog.csdn.net/Es_Study_Yu/articl...
Sort 排序类-1 基本排序
Es_Study_Yu的博客
03-26 583
目录排序的一些概念选择排序插入排序冒泡排序 排序的一些概念   排序的稳定性： 　　　　如果在序列中有两个数据元素 r[i] 和 r[j]，它们的关键字 k[i]== k[j]，且在排序之前，对象 r[i] 排在 r[j] 前面； 　　　　如果在排序之后，对象 r[i]仍在对象 r[j] 的前面，则称这个排序方法是稳定的，否则称这个排序方法是不稳定的。 稳定性排序示例   排序的重要指标： ...
Stack 与 Queue互相转换
Es_Study_Yu的博客
03-12 526
文章目录Stack、QueueStack->QueueQueue->Stack Stack、Queue   栈：后进先出，只可插入或取出栈顶元素 　　队列：先进先出，只可取出队首元素，插入队尾元素   栈和队列的实现很相似，两种数据结构是否可以互相转换？ 　　　　答案是肯定的，栈与队列相互转换可以加深栈与队列的理解 Stack->Queue   用栈实现队列—>用后进先...
String类的实现与KMP算法简述
Es_Study_Yu的博客
03-14 369
目录String的概念String.hString.cppKMP算法原理KMP.h String的概念   String： 　　　　因为C++兼容C，所以我们的字符串类也要，不仅String可以使用，还要兼容Char* 　　　　通过C语言中的函数实现String类，这样才可以实现兼容不同版本的C++编译器 　　　　实现String类时，需要考虑字符串的const属性，函数参数是否为const  ...
Array、StaticArray、DynamicArray
Es_Study_Yu的博客
03-09 368
目录Array类的特点Array的实现StaticArray的实现DynamicArray的实现 Array类的特点   Array类的特点： 　　　　-数组类包含数组长度信息，能够发现参数是否越界（扔异常） 　　　　-重载[]，使得可以像原生数组一样使用 　　　　-定义为抽象父类，使用指针完成数组的基本功能 　　　　-指针指向的存储空间的大小与位置由子类提供 数组类的继承结构 Array的实...
链表在什么情况下使用
07-29
链表在以下情况下使用较为常见： 1. 需要频繁地进行插入和删除操作：链表的特点是插入和删除操作的时间复杂度为 O(1)，因为只需要修改相邻节点的指针，不需要移动其他节点。相比之下，数组的插入和删除操作可能需要...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值