线性表—双链表、循环链表

于 2022-03-19 15:10:08 发布
阅读量873 收藏
点赞数
分类专栏： C++数据结构 文章标签： c++ 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39172845/article/details/123594589
版权

双链表

双链表：在单链表基础上，增加了前驱指针的链表称为双链表。

    //双链表中每个节点的定义
	template <typename T> //T代表数据元素类型
	struct DblNode
	{
		T data; //数据域，用来存放数据元素
		DblNode<T>* prior; //前趋指针，指向前一个同类型（和本节点类型相同）的节点
		DblNode<T>* next; //后继指针，指向下一个同类型（和本节点类型相同）的节点
	};

    //双链表的定义
    template <typename T>
	class DblLinkList
	{
	public:
		DblLinkList(); //构造函数
		~DblLinkList(); //析构函数

	public:
		bool ListInsert(int i, const T& e);  //在第i个位置插入指定元素e
		bool ListDelete(int i);              //删除第i个位置的元素


		bool GetElem(int i, T& e);           //获得第i个位置的元素值
		int  LocateElem(const T& e);         //按元素值查找其在双链表中第一次出现的位置

		void DispList();                     //输出双链表中的所有元素
		int  ListLength();                   //获取双链表的长度
		bool Empty();                        //判断双链表是否为空

		bool InsertPriorNode(DblNode<T>* pcurr, DblNode<T>* pnewnode)
		{
			//在节点pcurr之前插入新节点pnewnode，请自行添加代码......
          
			if(nullptr==pcurr || nullptr==pnewnode)
				return false;
			pnewnode->next=pcurr;	//（1）让新节点next指向pcurr
			pnewnode->prior=pcurr->prior;	//（2）让新节点的prior指向pcurr的prior
			pcurr->prior->next=pnewnode;	//（3）让pcurr的前一个节点的next指向新节点
			pcurr->prior=pnewnode;	//（4）改变pcurr的prior，使其指向新节点
			return true;
		}

		bool DeleteNode(DblNode<T>* pdel)
		{
			//删除pdel所指向的节点，请自行添加相关代码
            if(!pdel)
				return false;
			pdel->prior->next=pdel->next;
			pdel->next->prior=pdel->prior;
			delete pdel;
		}


	private:
		DblNode<T>* m_head; //头指针（指向链表第一个节点的指针，如果链表有头结点则指向头结点）
		int m_length;    //双链表当前长度（当前有几个元素），为编写程序更加方便和提高程序运行效率而引入，但不是必须引入
	};

    //通过构造函数对双链表进行初始化
	template <typename T>
	DblLinkList<T>::DblLinkList()
	{
		m_head = new DblNode<T>; //先创建一个头结点
		m_head->next = nullptr; //该值暂时为nullptr，因为还没有后继节点
		m_head->prior = nullptr; //该值一直为nullptr
		m_length = 0;  //头结点不计入双链表的长度		
	}

    //通过析构函数对双链表进行资源释放
	template <typename T>
	DblLinkList<T>::~DblLinkList()
	{
		DblNode<T>* pnode = m_head->next;
		DblNode<T>* ptmp;
		while (pnode != nullptr) //该循环负责释放数据节点
		{
			ptmp = pnode;
			pnode = pnode->next;

			delete ptmp;
		}
		delete m_head;    //释放头结点
		m_head = nullptr; //非必须
		m_length = 0;     //非必须
	}

    
    //在第i个位置（位置编号从1开始）插入指定元素e
	template <typename T>
	bool DblLinkList<T>::ListInsert(int i, const T& e)
	{
		//判断插入位置i是否合法，i的合法值应该是1到length+1之间
		if (i < 1 || i >(m_length + 1))
		{
			cout << "元素" << e << "插入的位置" << i << "不合法，合法的位置是1到" << m_length + 1 << "之间!" << endl;
			return false;
		}

		DblNode<T>* p_curr = m_head;

		//整个for循环用于找到第i-1个节点
		for (int j = 0; j < (i - 1); ++j)//j从0开始，表示p_curr刚开始指向的是第0个节点（头结点）
		{
			p_curr = p_curr->next; //pcurr会找到当前要插入的位置，比如要在第2个位置插入，pcurr会指向第1个位置(节点)
		}

		DblNode<T>* node = new DblNode<T>;
		node->data = e;
		node->next = p_curr->next;//让新节点链上后续链表，因为pcurr->next指向后续的链表节点

		node->prior = p_curr;
		if (p_curr->next != nullptr)
			p_curr->next->prior = node;

		p_curr->next = node;//让当前位置链上新节点，因为node指向新节点

		cout << "成功在位置为" << i << "处插入元素" << e << "!" << endl;
		m_length++;	        //实际表长+1
		return true;
	}

    //输出双链表中的所有元素，时间复杂度为O(n)
	template<class T>
	void DblLinkList<T>::DispList()
	{
		DblNode<T>* p = m_head->next;
		while (p != nullptr) //这里采用while循环或者for循环书写都可以
		{
			cout << p->data << " ";  //每个数据之间以空格分隔
			p = p->next;
		}
		cout << endl; //换行
	}

    //删除第i个位置的元素
	template < typename T>
	bool DblLinkList<T>::ListDelete(int i)
	{
		if (m_length < 1)
		{
			cout << "当前双链表为空，不能删除任何数据!" << endl;
			return false;
		}
		if (i < 1 || i > m_length)
		{
			cout << "删除的位置" << i << "不合法，合法的位置是1到" << m_length << "之间!" << endl;
			return false;
		}

		DblNode<T>* p_curr = m_head;

		//整个for循环用于找到第i-1个节点
		for (int j = 0; j < (i - 1); ++j)//j从0开始，表示p_curr刚开始指向的是第0个节点（头结点）
		{
			p_curr = p_curr->next; //pcurr会找到当前要删除的位置所代表的节点的前一个节点的位置，比如要删除第2个位置的节点，pcurr会指向第1个位置(节点)
		}

		DblNode<T>* p_willdel = p_curr->next; //p_willdel指向待删除的节点
		DblNode<T>* p_willdelNext = p_willdel->next; //p_willdelNext指向待删除节点的下一个节点
		p_curr->next = p_willdel->next; //第i-1个节点的next指针指向第i+1个节点
		if (p_willdelNext != nullptr)
			p_willdelNext->prior = p_curr;//第i+1个节点的prior指针指向第i-1个节点

		cout << "成功删除位置为" << i << "的元素，该元素的值为" << p_willdel->data << "!" << endl;
		m_length--;       //实际表长-1
		delete p_willdel;
		return true;
	}

 循环单链表

传统的循环单链表，把链表的头指针修改为尾指针  不再使用m_head， 引入一个尾指针m_tail,那么m_tail->next指向头节点。

 

如果需要频繁的在链表头或者链表尾进行数据操作的话，可以考虑引入m_tail表尾指针。

引入尾指针的另外一个好处就是可以迅速的将两个单循环链表连接起来形成一个更大的单循环链表。

p1_head = m_tail1->next;  //先把单循环链表1的头节点暂存起来
m_tail1->next = m_tail2->next->next; //让单循环链表1的尾节点指向单循环链表2的头节点之后的节点（第一个数据节点，也就是a11)。
p2_head = m_tail2->next; //再把单循环链表2的头节点暂存起来
m_tail2->next = p1head; //让单循环链表2的为节点的next域指向单循环链表1的头结点。
//其他代码略：包括重新设置单循环链表2的长度，让单循环链表2的头指针的next指向自己。
//而对于单循环链表2的头结点的释放，其实是在CirLinlist类的析构函数中进行的。

 

    //单循环链表中每个节点的定义
	template <typename T> //T代表数据元素的类型
	struct Node
	{
		T        data;  //数据域，存放数据元素
		Node<T>* next;  //指针域，指向下一个同类型（和本节点类型相同）节点
	};


    //单循环链表的定义
	template <typename T>
	class CirLinkList
	{
	public:
		CirLinkList();      //构造函数，参数可以有默认值
		~CirLinkList();     //析构函数

	public:
		bool ListInsert(int i, const T& e);  //在第i个位置插入指定元素e
		bool ListDelete(int i);              //删除第i个位置的元素

		bool GetElem(int i, T& e);           //获得第i个位置的元素值
		int  LocateElem(const T& e);         //按元素值查找其在单循环链表中第一次出现的位置

		void DispList();                     //输出单循环链表中的所有元素
		int  ListLength();                   //获取单循环链表的长度
		bool Empty();                        //判断单循环链表是否为空		


	private:
		Node<T>* m_head; //头指针（指向链表第一个节点的指针，如果链表有头结点则指向头结点）
		int m_length;    //单循环链表当前长度（当前有几个元素），为编写程序更加方便和提高程序运行效率而引入，但不是必须引入
	};


    //通过构造函数对单循环链表进行初始化
	template <typename T>
	CirLinkList<T>::CirLinkList()
	{
		m_head = new Node<T>; //先创建一个头结点
		//m_head->next = nullptr;
		m_head->next = m_head;
		m_length = 0;  //头结点不计入单循环链表的长度		
	}


    //在第i个位置（位置编号从1开始）插入指定元素e
	template <typename T>
	bool CirLinkList<T>::ListInsert(int i, const T& e)
	{
		//判断插入位置i是否合法，i的合法值应该是1到length+1之间
		if (i < 1 || i >(m_length + 1))
		{
			cout << "元素" << e << "插入的位置" << i << "不合法，合法的位置是1到" << m_length + 1 << "之间!" << endl;
			return false;
		}

		Node<T>* p_curr = m_head;

		//整个for循环用于找到第i-1个节点
		for (int j = 0; j < (i - 1); ++j)//j从0开始，表示p_curr刚开始指向的是第0个节点（头结点）
		{
			p_curr = p_curr->next; //pcurr会找到当前要插入的位置，比如要在第2个位置插入，pcurr会指向第1个位置(节点)
		}

		Node<T>* node = new Node<T>;
		node->data = e;
		node->next = p_curr->next;//让新节点链上后续链表，因为pcurr->next指向后续的链表节点
		p_curr->next = node;//让当前位置链上新节点，因为node指向新节点

		cout << "成功在位置为" << i << "处插入元素" << e << "!" << endl;
		m_length++;	        //实际表长+1
		return true;
	}

    //删除第i个位置的元素
	template < typename T>
	bool CirLinkList<T>::ListDelete(int i)
	{
		if (m_length < 1)
		{
			cout << "当前单循环链表为空，不能删除任何数据!" << endl;
			return false;
		}
		if (i < 1 || i > m_length)
		{
			cout << "删除的位置" << i << "不合法，合法的位置是1到" << m_length << "之间!" << endl;
			return false;
		}

		Node<T>* p_curr = m_head;

		//整个for循环用于找到第i-1个节点
		for (int j = 0; j < (i - 1); ++j)//j从0开始，表示p_curr刚开始指向的是第0个节点（头结点）
		{
			p_curr = p_curr->next; //pcurr会找到当前要删除的位置所代表的节点的前一个节点的位置，比如要删除第2个位置的节点，pcurr会指向第1个位置(节点)
		}

		Node<T>* p_willdel = p_curr->next; //p_willdel指向待删除的节点
		p_curr->next = p_willdel->next; //第i-1个节点的next指针指向第i+1个节点
		cout << "成功删除位置为" << i << "的元素，该元素的值为" << p_willdel->data << "!" << endl;
		m_length--;       //实际表长-1
		delete p_willdel;
		return true;
	}


    //获得第i个位置的元素值
	template<class T>
	bool CirLinkList<T>::GetElem(int i, T& e)
	{
		if (m_length < 1)
		{
			cout << "当前单循环链表为空，不能获取任何数据!" << endl;
			return false;
		}

		if (i < 1 || i > m_length)
		{
			cout << "获取元素的位置" << i << "不合法，合法的位置是1到" << m_length << "之间!" << endl;
			return false;
		}

		Node<T>* p_curr = m_head;
		for (int j = 0; j < i; ++j)
		{
			p_curr = p_curr->next;
		}
		e = p_curr->data;
		cout << "成功获取位置为" << i << "的元素，该元素的值为" << e << "!" << endl;
		return true;
	}

    //按元素值查找其在单循环链表中第一次出现的位置
	template<class T>
	int CirLinkList<T>::LocateElem(const T& e)
	{
		Node<T>* p_curr = m_head;
		for (int i = 1; i <= m_length; ++i)
		{
			if (p_curr->next->data == e)
			{
				cout << "值为" << e << "的元素在单循环链表中第一次出现的位置为" << i << "!" << endl;
				return i;
			}
			p_curr = p_curr->next;
		}
		cout << "值为" << e << "的元素在单循环链表中没有找到!" << endl;
		return -1;  //返回-1表示查找失败
	}

    //输出单循环链表中的所有元素，时间复杂度为O(n)
	template<class T>
	void CirLinkList<T>::DispList()
	{
		Node<T>* p = m_head->next;
		while (p != m_head) //这里采用while循环或者for循环书写都可以
		{
			cout << p->data << " ";  //每个数据之间以空格分隔
			p = p->next;
		}
		cout << endl; //换行
	}

    //获取单循环链表的长度，时间复杂度为O(1)
	template<class T>
	int  CirLinkList<T>::ListLength()
	{
		return m_length;
	}

	//判断单循环链表是否为空，时间复杂度为O(1)
	template<class T>
	bool CirLinkList<T>::Empty()
	{
		if (m_head->next == m_head) //单循环链表为空
		{
			return true;
		}
		return false;
	}


	//通过析构函数对单循环链表进行资源释放
	template <typename T>
	CirLinkList<T>::~CirLinkList()
	{
		Node<T>* pnode = m_head->next;
		Node<T>* ptmp;
		while (pnode != m_head) //该循环负责释放数据节点
		{
			ptmp = pnode;
			pnode = pnode->next;

			delete ptmp;
		}
		delete m_head;    //释放头结点
		m_head = nullptr; //非必须
		m_length = 0;     //非必须
	}

 双向循环链表

 

 

    //双循环链表中每个节点的定义
	template <typename T> //T代表数据元素的类型
	struct DblNode
	{
		T        data;  //数据域，存放数据元素
		DblNode<T>* prior; //前趋指针，指向前一个同类型（和本节点类型相同）节点
		DblNode<T>* next;  //后继指针，指向下一个同类型（和本节点类型相同）节点
	};

    //双循环链表的定义
	template <typename T>
	class DblCirLinkList
	{
	public:
		DblCirLinkList();      //构造函数，参数可以有默认值
		~DblCirLinkList();     //析构函数

	public:
		bool ListInsert(int i, const T& e);  //在第i个位置插入指定元素e
		bool ListDelete(int i);              //删除第i个位置的元素
				

		bool GetElem(int i, T& e);           //获得第i个位置的元素值
		int  LocateElem(const T& e);         //按元素值查找其在双循环链表中第一次出现的位置
		
		void DispList();                     //输出双循环链表中的所有元素
		int  ListLength();                   //获取双循环链表的长度
		bool Empty();                        //判断双循环链表是否为空

	private:
		DblNode<T>* m_head; //头指针（指向链表第一个节点的指针，如果链表有头结点则指向头结点）
		int m_length;    //双循环链表当前长度（当前有几个元素），为编写程序更加方便和提高程序运行效率而引入，但不是必须引入
	};

    

    //通过构造函数对双循环链表进行初始化
	template <typename T>
	DblCirLinkList<T>::DblCirLinkList()
	{		
		m_head = new DblNode<T>; //先创建一个头结点
		m_head->next = m_head; 
		m_head->prior = m_head; 
		m_length = 0;  //头结点不计入双循环链表的长度		
	}

    //在第i个位置（位置编号从1开始）插入指定元素e
	template <typename T>
	bool DblCirLinkList<T>::ListInsert(int i, const T& e)
	{
		//判断插入位置i是否合法，i的合法值应该是1到length+1之间
		if (i < 1 || i > (m_length + 1))
		{
			cout << "元素" << e << "插入的位置" << i << "不合法，合法的位置是1到" << m_length + 1 << "之间!" << endl;
			return false;
		}
		
		DblNode<T>* p_curr = m_head;

		//整个for循环用于找到第i-1个节点
		for (int j = 0; j < (i-1); ++j)//j从0开始，表示p_curr刚开始指向的是第0个节点（头结点）
		{
			p_curr = p_curr->next; //pcurr会找到当前要插入的位置，比如要在第2个位置插入，pcurr会指向第1个位置(节点)
		}

		DblNode<T>* node = new DblNode<T>;
		node->data = e;	
		node->next = p_curr->next;//让新节点链上后续链表，因为pcurr->next指向后续的链表节点

		node->prior = p_curr;
		if(p_curr->next != nullptr)
			p_curr->next->prior = node; 

		p_curr->next = node;//让当前位置链上新节点，因为node指向新节点

		cout << "成功在位置为" << i << "处插入元素" << e << "!" << endl;
		m_length++;	        //实际表长+1
		return true;
	}

    //删除第i个位置的元素
	template < typename T>
	bool DblCirLinkList<T>::ListDelete(int i)
	{
		if (m_length < 1)
		{
			cout << "当前双循环链表为空，不能删除任何数据!" << endl;
			return false;
		}
		if (i < 1 || i > m_length)
		{
			cout << "删除的位置" << i << "不合法，合法的位置是1到" << m_length << "之间!" << endl;
			return false;
		}

		DblNode<T>* p_curr = m_head;

		//整个for循环用于找到第i-1个节点
		for (int j = 0; j < (i - 1); ++j)//j从0开始，表示p_curr刚开始指向的是第0个节点（头结点）
		{
			p_curr = p_curr->next; //pcurr会找到当前要删除的位置所代表的节点的前一个节点的位置，比如要删除第2个位置的节点，pcurr会指向第1个位置(节点)
		}

		DblNode<T>* p_willdel = p_curr->next; //p_willdel指向待删除的节点
		DblNode<T>* p_willdelNext = p_willdel->next; //p_willdelNext指向待删除节点的下一个节点
		p_curr->next = p_willdel->next; //第i-1个节点的next指针指向第i+1个节点
		if (p_willdelNext != nullptr)
			p_willdelNext->prior = p_curr;//第i+1个节点的prior指针指向第i-1个节点
		
		cout << "成功删除位置为" << i << "的元素，该元素的值为" << p_willdel->data << "!" << endl;
		m_length--;       //实际表长-1
		delete p_willdel;
		return true;
	}

    //获得第i个位置的元素值
	template<class T>
	bool DblCirLinkList<T>::GetElem(int i, T& e)
	{
		if (m_length < 1)
		{
			cout << "当前双循环链表为空，不能获取任何数据!" << endl;
			return false;
		}

		if (i < 1 || i > m_length)
		{
			cout << "获取元素的位置" << i << "不合法，合法的位置是1到" << m_length << "之间!" << endl;
			return false;
		}

		DblNode<T>* p_curr = m_head;
		for (int j = 0; j < i; ++j)
		{
			p_curr = p_curr->next; 
		}
		e = p_curr->data;
		cout << "成功获取位置为" << i << "的元素，该元素的值为" << e << "!" << endl;
		return true;
	}

	//按元素值查找其在双循环链表中第一次出现的位置
	template<class T>
	int DblCirLinkList<T>::LocateElem(const T& e)
	{
		DblNode<T>* p_curr = m_head;
		for (int i = 1; i <= m_length; ++i)
		{
			if (p_curr->next->data == e)
			{
				cout << "值为" << e << "的元素在双循环链表中第一次出现的位置为" << i<< "!" << endl;
				return i; 
			}
			p_curr = p_curr->next;
		}
		cout << "值为" << e << "的元素在双循环链表中没有找到!" << endl;
		return -1;  //返回-1表示查找失败
	}

	//输出双循环链表中的所有元素，时间复杂度为O(n)
	template<class T>
	void DblCirLinkList<T>::DispList()
	{
		DblNode<T>* p = m_head->next;
		while (p != m_head) //这里采用while循环或者for循环书写都可以
		{
			cout << p->data << " ";  //每个数据之间以空格分隔
			p = p->next;
		}
		cout << endl; //换行
	}

	//获取双循环链表的长度，时间复杂度为O(1)
	template<class T>
	int  DblCirLinkList<T>::ListLength()
	{
		return m_length;
	}

	//判断双循环链表是否为空，时间复杂度为O(1)
	template<class T>
	bool DblCirLinkList<T>::Empty()
	{
		if (m_head->next == m_head) //双循环链表为空
		{ 
			return true;
		}
		return false;
	}

	//通过析构函数对双循环链表进行资源释放
	template <typename T>
	DblCirLinkList<T>::~DblCirLinkList()
	{		
		DblNode<T>* pnode = m_head->next; 
		DblNode<T>* ptmp;
		while (pnode != m_head) //该循环负责释放数据节点
		{
			ptmp = pnode;			
			pnode = pnode->next;

			delete ptmp;
		}
		delete m_head;    //释放头结点
		m_head = nullptr; //非必须
		m_length = 0;     //非必须
	}

心之所向便是光v
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构（6）线性表之双循环链表
小姚的博客
10-15 265
同单链表一样，双向链表也可以是循环表。链表最后一个结点的next指针指向头结点，头结点的Prior指针指向最后一个结点，形成循环，称为双循环链表
线性表文档之循环双链表
二木成林
04-05 1430
线性表文档之循环双链表
双链循环线性表
04-23 1587
结点类型： typedef struct DulNode { ElemType data; DulNode *prior; DulNode *next; }DulNode, *DuLinkList; 初始化： //产生空的双向循环链表L，注意这里传入的是二级指针 static Status InitList(DulNode **L) { *L = (DulNode *)
数据结构：链表-笔记
世上再无张显宗
06-16 2362
1、链表都是线性数据结构；链表包括：单链表 双向链表 循环链表等。 2、在下列链表中不能从当前结点出发访问到其余各结点的是（ ）。 正确答案: C 你的答案: C (正确) 双向链表 单循环链表 单链表 双向循环链表 解析：只有单链表，是单向的。 3、在一个具有n个结点的有序单链表中插入一个新结点并保持该表有序的时间复杂度是_______。 正确答案: B 你的答案: B (正确) O(1) O(n) O(n2) O(log2n) 解析：需要先找到插入位置，也就是需要进行遍历一次O（n
双链循环线性表的实现（第二章 P35-37 算法2.18,2.19）
但行好事，莫问前程
03-18 251
双链循环线性表 双向链表每个结点有两个指针，一个指向结点的前驱，另一个指向结点的后继。所以，从链表的每一个结点出发，都可以到达任意一个结点，有利于链表的查找。 线性表的双向链表存储结构： eg: 带有头结点且具有 2 个结点的双链循环线性表 eg: 空的双向循环链表 在双向链表中，有些操作如：ListLength , GetElem , LocateElem 等...
C++语言实现线性表之链表实例
09-03
在C++编程中，线性表是一种常见的数据结构，它由有限个相同类型元素组成，按照线性顺序排列。线性表的实现方式有...在实际项目中，根据具体需求，还可以扩展链表的功能，例如支持双向链表、循环链表等更复杂的结构。
带头结点双链循环线性表.rar_循环双链表
09-14
循环双链表是一种高效的数据结构，它在单链表的基础上扩展了双向链接的功能，并形成了一个首尾相连的环形结构。这种数据结构在程序设计中非常常见，特别是在处理线性序列的问题时，如动态内存分配、文件系统管理等...
简单介绍线性表以及如何实现双链表
09-03
双向链表通常构建为循环链表，即最后一个节点的后继节点是第一个节点，这样可以从任意节点开始遍历整个链表。删除和添加节点的操作与单链表类似，但需要同时更新前驱和后继节点的指针。 在C、C++和Java中实现双向...
循环链表和双向链表.ppt
最新发布
09-20
带头结点的链表、循环链表和双向链表的特征，基本运算。 对于循环链表要突出掌握判断链表空满的条件； 双向链表要强调插入和删除算法的实现。 最后通过多项式加法的示例，介绍线性表的应用。 预期目标： 我希望大家...
线性表和链表的基本算法
04-30
单向链表的节点只能向前遍历，双向链表支持前后遍历，循环链表的最后一个节点指向第一个节点，形成一个环。 线性表与链表的主要操作包括插入、删除、查找等。在线性表中，插入操作通常需要移动后续元素，以空出位置...
std::list（双向循环链表）的使用？
清新的世界
01-09 4239
本篇介绍C++11 STL（Standard Template Library）标准模板库中 的 STL是一些“容器”的集合，包括如：list，vector，set，map等。 STL也是算法和一些组件的集合。 STL的目的：标准化组件，不用重发开发，可以使用现成的组件！ STL是C++的一部分，它的版本很多，我们只说标准C++中的STL。 C++标准中，STL被组织成为17个头文件。
线性表——双向循环链表
橘猫吃不胖的博客
11-25 111
双向循环链表结点的结构体定义如下： typedef struct Node { DataType data; struct Node *next; struct Node *prior; }DLNode; （1）初始化ListInitiate(DLNode **head) void ListInitiate(DLNode **head) { *head =(DLNode *)malloc(sizeof(DLNode)); (*head)->prior=*head;//构成前驱指针循环链表
B03-数据结构-线性结构-线性表循环链表&双向链表&双向循环链表
Y_winter_w的专栏
10-17 334
数据结构-线性结构-线性表循环链表&双向链表&双向循环链表 文章目录数据结构-线性结构-线性表循环链表&双向链表&双向循环链表一、循环链表1.1、定义1.2、结构示例1.3、使用说明二、双向链表2.1、定义2.2、结构示例2.3、使用2.3.1、构建初始化2.3.2、插入操作步骤2.3.3、删除操作步骤2.4、Python代码实现三、双向循环链表3.1、定义3.2、...
线性表-双链表&循环链表(Ⅳ)
Miss Z的博客
07-30 917
双链表 循环链表
双向链表与循环链表
热门推荐
wyqwilliam的博客
09-16 1万+
双向链表 单链表的一个优点是结构简单，但是它也有一个缺点，即在单链表中只能通过一个结点的引用访问其后续结点，而无法直接访问其前驱结点， 要在单链表中找到某个结点的前驱结点，必须从链表的首结点出发依次向后寻找，但是需要Ο(n)时间。 为此我们可以扩展单链表的结点结构，使得通过一个结点的引用，不但能够访问其后续结点，也可以方便的访问其前驱结点。 扩展单链表结点结构的方法是，在单链表结点结构中新增加一...
循环链表和双向链表
DLaugust的博客
08-13 610
一、循环链表 1、特点：从任意一个结点出发，可以访问到全部结点。 2、与单链表的区别：单链表最后一个结点指针域的指针指向空，循环链表则是最后一个结点指针域的指针指向头结点，当然如果该链表无头结点，指针就指向第一个结点。 下图为带有头结点的循环链表： 二、循环链表的操作 1、循环链表操作跟单链表操作类似，只是判断循环条件时，单链表是p->next是否为空，而循环链表则是p->next是否为头指针L。 2、两循环链表合并 ...
数据结构(严蔚敏)------双链循环线性表
lovey_carolin的专栏
03-08 1118
精辟：：在进行链表的插入和删除操作过程中，将前置指针、结点、后置指针三个部分看作一个整体，当进行指向操作时，指针指向的是整个结构体，而不是指向其中的前置或是后置。
c语言查找算法LocateElem,关于LocateElem算法
weixin_33182798的博客
05-23 6001
满意答案1、LocateElem(L,e,compare())函数：初始条件：线性表存在，compare()是数据元素判定函数；操作结果：返回第一个与e满足关系compare()的数据元素的位序。若不存在，返回0.由定义的结构体知：typedef struct{char Name[100]; //学生姓名char Number[100]; //学生的学号} StudentRacord;如何...
数据结构-02-链表数据结构之双链表和循环链表
CycloneKid的博客
11-07 291
上篇博客分析了单链表：数据结构-01-链表数据结构之单链表，这篇博客将分析链表的其他几种常见形式 本文中的所有代码均在github上的项目中：List_DataStructure 双链表双链表也叫双向链表，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。 双链表是最常用的一种链表形式，实际应用中双链表一般

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

心之所向便是光v

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值