数据结构之——双向循环链表完备版（C++实现）

最新推荐文章于 2023-08-22 16:54:16 发布
最新推荐文章于 2023-08-22 16:54:16 发布
阅读量397 收藏 2
点赞数 1
分类专栏： 数据结构 文章标签： c++ 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/GaoXiaoYuan0728/article/details/108792438
版权

双向循环链表

⚪介绍

双向循环链表只是在双向链表的基础上增加了头尾节点的互相指向双向循环链表

⚪难点讲解

双向循环链表，只需要引用之前的双向链表代码的基础上部分功能进行修改
因为只对头尾节点进行了相互指向，因此只有添加、删除的函数的头尾部分需要进行修改

添加

先观察原来的双向链表

void DouLinkList<E>::add(int index, E element)		//在某节点添加元素
{
	if (index == size)		//在尾节点添加元素
	{
		Node<E> *Old_last = last;
		last = new Node<E>(Old_last, element, NULL);
		if (Old_last == NULL)		//如果是链表添加的第一个元素
		{
			first = last;
		}
		else
		{
			Old_last->next = last;
		}
	}
	else
	{
		Node<E>* next = find_node(index);
		Node<E>* prev = next->prev;
		Node<E>* p = new Node<E>(prev, element, next);
		if (prev == NULL)		//如果index==0
		{
			first = p;
		}
		else
		{
			prev->next = p;
		}
		next->prev = p;
	}

	size++;
}

以往最后添加元素的情况为例，首先要将last指针指向新添加的元素，再将新添加元素的prev指针指向原先的最后一个节点，再将原先最后一个节点的next指针指向新添加的元素 …其实这些线在双向链表中已接好，我们只需要在原有的基础上再添加部分的线即可。

1、尾

尾部添加
在尾节点添加元素要增加头节点的prev指针指向新添加节点和新添加节点的next指针指向头节点
因此要将last = new Node<E>(Old_last, element, NULL);此句代码改为last = new Node<E>(Old_last, element, first);，将新添加节点的next指针指向头节点； else{prev->next = p;}在此处增加一句first->prev=last头节点的prev指针指向新添加节点。
只有一个元素
当是链表添加的第一个元素，那么就要增加自己的prev指针和next的指针都要指向自己

if (Old_last == NULL)		//如果是链表添加的第一个元素
		{
			first = last;
		}

就将此处的代码修改为

if (Old_last == NULL)		//如果是链表添加的第一个元素
		{
			first = last;
			first->next = first;
			first->prev = first;
		}
2、头

在之前的双向链表中的除尾节点添加情况中的因头节点的prev指针为NULL而增加了头节点的讨论，而双向循环链表不存在头节点的prev指针为空的情况，因此next.prev = node这句代码是一定要执行的，所以把它放到 if()语句的前面。而对于first = node这句代码是将first头指针指向头节点是一定存在的，因此我们把if的判断语句改为next == first(index == 0也可以)

3、总代码
template<class E>
void Circle_DouLinkList<E>::add(int index, E element)//在任意位置添加元素
{
	if (index == size)
	{
		Node<E>* Old_last = last;
		last = new Node<E>(Old_last, element, first);
		if (Old_last == NULL)		//如果是链表添加的第一个元素
		{
			first = last;
			first->next = first;
			first->prev = first;
		}
		else
		{
			Old_last->next = last;
			first->prev = last;
		}
	}
	else
	{
		Node<E>* next = find_node(index);
		Node<E>* prev = next->prev;
		Node<E>* p = new Node<E>(prev, element, next);
		next->prev = p;
		prev->next = p;
		if (index==0)		
		{
			first = p;
		}	
	}

	size++;
}

删除

先观察原来的双向链表删除的代码

template<class E>
E DouLinkList<E>::remove(int index)			//删除某节点的元素
{
	Node<E>* p = find_node(index);
	Node<E>* prev = p->prev;
	Node<E>* next = p->next;
	if (prev == NULL)		//index==0
	{
		first = next;
	}
	else
	{
		prev->next = next;
	}
	if (next == NULL)		//index==size-1
	{
		last = prev;
	}
	else
	{
		next->prev = prev;
	}
	E x = p->element;
	delete p;
	return x;
}

对于尾节点的讨论和头节点都是因为增加了循环的机构而对于头尾节点讨论的代码进行了变动，无太多的差别，因此就不多赘述了。

特殊情况

而在删除节点有一种特殊情况是删除的元素为链表中的唯一元素，利用已有的讨论无法达到我们所需要的删除目的，因此要增加对于size==1这种特殊情况的讨论。
在这种情况中只需要将first和last指针全部置空即可。即增加first = NULL和last = NULL的代码。

总代码
template<class E>
E Circle_DouLinkList<E>::remove(int index)//删除某个节点并返回被删除节点的值
{
	Node<E>* p = NULL;
	if (size == 1)
	{		
		p = first;
		first = NULL;
		last = NULL;
	}
	else
	{
		p = find_node(index);
		Node<E>* prev = p->prev;
		Node<E>* next = p->next;
		prev->next = next;
		next->prev = prev;
		if (index == 0)
		{
			first = next;
		}

		if (index == size - 1)
		{
			last = prev;
		}

	}
	E x = p->element;
	delete p;
	return x;
}

⚪总代码

Circle_Double_Link_List.h

#pragma once
#pragma once
#include <iostream>
using namespace std;


template<class E>
class Node
{
public:
	E element;
	Node<E>* next;
	Node<E>* prev;
	Node(Node<E>* prev, E element, Node<E>* next)
	{
		this->element = element;
		this->next = next;
		this->prev = prev;
	}
	~Node() {}
};

template<class E>
class Circle_DouLinkList
{
private:
	int size;
	Node<E>* first = NULL;
	Node<E>* last = NULL;

	static const int ELEMENT_NOT_FOUND = -1;

	Node<E>* find_node(int index);			//获得某位置节点
public:
	void clear();							//清除所有元素
	void add(E element);						//在尾部添加元素
	void add(int index, E element);			//在任意位置添加元素
	int Size();								//求链表的长度
	int indexOf(E element);					//获取某元素所对应节点，若无则返回ELEMENT_NOT_FOUND = -1
	bool isEmpty();							//判断链表是否为空
	bool contains(E element);				//判断是否包含某个元素
	E get(int index);						//获得某个节点对应元素
	E set(int index, E element);				//修改某个节点对应元素，返回原元素值
	E remove(int index);						//删除某个节点并返回被删除节点的值
	void print();							//输出所有节点

	~Circle_DouLinkList(){}
};

Circle_Double_Link_List.cpp

#include "Circle_Double_Link_List.h"

template<class E>
void Circle_DouLinkList<E>::clear()//清除所有元素
{
	Node* q;
	Node<E>* p = first->next;
	while (p != NULL)
	{
		q = p;
		p = p->next;
		delete q;
	}
	p = NULL;
	q = NULL;
}

template<class E>
int Circle_DouLinkList<E>::Size()//求链表的长度
{
	return size;
}

template<class E>
bool Circle_DouLinkList<E>::isEmpty()//判断链表是否为空
{
	return size == 0;
}

template<class E>
bool Circle_DouLinkList<E>::contains(E element)//判断是否包含某个元素
{
	return indexOf(element) != -ELEMENT_NOT_FOUND;
}

template<class E>
void Circle_DouLinkList<E>::add(E element)//在尾部添加元素
{
	add(size, element);
}

template<class E>
int Circle_DouLinkList<E>::indexOf(E element)//获取某元素所对应节点，若无则返回ELEMENT_NOT_FOUND = -1
{
	if (element == NULL)						//讨论当传入元素本身为NULL的情况
	{
		Node<E>* node = first;
		for (int i = 0; i < size; i++)
		{
			if (node->element == NULL)
			{
				return i;
			}
			node = node->next;
		}
	}
	else
	{
		Node<E>* node = first;
		for (int i = 0; i < size; i++)
		{
			if (node->element == element)
			{
				return i;
			}
			node = node->next;
		}
	}
	return ELEMENT_NOT_FOUND;
}

template<class E>
E Circle_DouLinkList<E>::get(int index)//获得某个节点对应元素
{
	return find_node(index).element;
}

template<class E>
E Circle_DouLinkList<E>::set(int index, E element)//修改某个节点对应元素，返回原元素值
{
	Node<E>* node = find_node(index);
	E old = node->element;
	node->element = element;
	return old;
}

template<class E>
void Circle_DouLinkList<E>::add(int index, E element)//在任意位置添加元素
{
	if (index == size)
	{
		Node<E>* Old_last = last;
		last = new Node<E>(Old_last, element, first);
		if (Old_last == NULL)		//如果是链表添加的第一个元素
		{
			first = last;
			first->next = first;
			first->prev = first;
		}
		else
		{
			Old_last->next = last;
			first->prev = last;
		}
	}
	else
	{
		Node<E>* next = find_node(index);
		Node<E>* prev = next->prev;
		Node<E>* p = new Node<E>(prev, element, next);
		next->prev = p;
		prev->next = p;
		if (index==0)		
		{
			first = p;
		}	
	}

	size++;
}

template<class E>
E Circle_DouLinkList<E>::remove(int index)//删除某个节点并返回被删除节点的值
{
	Node<E>* p = NULL;
	if (size == 1)
	{		
		p = first;
		first = NULL;
		last = NULL;
	}
	else
	{
		p = find_node(index);
		Node<E>* prev = p->prev;
		Node<E>* next = p->next;
		prev->next = next;
		next->prev = prev;
		if (index == 0)
		{
			first = next;
		}

		if (index == size - 1)
		{
			last = prev;
		}

	}
	E x = p->element;
	delete p;
	return x;
}


template<class E>
void Circle_DouLinkList<E>::print()//输出所有节点
{
	Node<E>* p = first;
	while (p != NULL)
	{
		cout << p->element << "->";
		p = p->next;
	}
}

template<class E>
Node<E>* Circle_DouLinkList<E>::find_node(int index)//获得某位置节点
{
	if (index < 0 || index >= size)
	{
		throw "index不符合规范";
	}

	if (index < (size >> 1))
	{
		Node<E>* node = first;
		for (int i = 0; i < index; i++)
		{
			node = node->next;
		}
		return node;
	}
	else
	{
		Node<E>* node = last;
		for (int i = size - 1; i > index; i--)
		{
			node = node->prev;
		}
		return node;
	}
}

main.cpp

#include "Circle_Double_Link_List.h"
#include "Circle_Double_Link_List.cpp"
#include <iostream>

int main()
{
    Circle_Dou_LinkList <int>list;
    int* X;
    int n;
    cin >> n;
    X = new int[n];
    for (int i = 0; i < n; i++)
    {
        cin >> X[i];
        list.add(X[i]);
    }
    list.print();
    return 0;
}

附：
1.本博客是由学习小码哥视频所总结文章
2.代码都通过合格检测，请放心食用~

GXM.
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
双向循环链表C++实现
12-11
数据结构课程设计实现双向循环链表，我这有详细的课程设计说明书以及答辩ppt，有需要的可以留言哈 ，仅供参考 嘿嘿
数据结构之双向循环链表（C++实现）
complety的专栏
04-11 1万+
下午上机的时候大概地实现了链表的基本功能。写的时候也不是光是脑袋想， 就在word里面画了个粗糙的图形，边看边写。刚刚开始的时候功能可以不要 太多。把最基本的功能先实现，也就是数据定义,default constructor和destructor的功能 。然后测试，再增加功能，这样后来写的时候出错的时候就会很明朗，至少不会是前面写的 function出错了。g++和vc下调试通过。main
C++链表 在forward_list首尾处添加元素
小鸟在飞想的专栏
07-14 1063
#include<iostream> #include<forward_list> using namespace std; int main() { forward_list<int> a{ 1,2,3,4,5,6,7,8 }; a.insert_after(a.before_begin(), 0); auto prec = a.before_begi...
C/C++数据结构（三） —— 双向带头循环链表
热门推荐
Edison's 小宇宙
08-16 1万+
【数据结构系列】链表之双向带头循环链表的基本操作
C++数据结构学习——双向循环链表
qq_40231851的博客
08-22 235
*双向链接：**每个节点都包含两个指针，一个指向前一个节点（前驱节点），另一个指向后一个节点（后继节点）。这种双向连接使得在链表中可以轻松地在两个方向上遍历节点。**循环性质：**最后一个节点的后继节点指向第一个节点，形成一个环状结构。这意味着可以无限循环遍历链表，因为没有真正的末尾。**灵活性：**由于双向链接，可以方便地在链表中插入、删除和移动节点，而不需要像单链表那样需要迭代查找前一个节点。**前向和后向遍历：**可以从任何节点开始，向前或向后遍历整个链表。
双向循环链表（C++实现）
st66688的博客
09-22 2712
双向循环链表内容整理
双向循环链表C++实现（完整版）
YYC的专栏
03-29 8258
#include using namespace std; /* *节点类 */ struct DCNode { int data; DCNode * prior; DCNode * next; }; /* *链表类 */ struct DCList { DCList() { size = 0; } size_t size;//记录节点数的个数 DCNode * hea
C++ 双向循环链表（简称：双链表）
ChanJose的博客
01-04 1100
一、概念     1.在双链表中的每个结点应有两个链接指针：               lLink -&gt; 指向前驱结点  （前驱指针或者左链指针）               rLink-&gt;指向后继结点（后驱指针或者右链指针）       2.双链表常采用带附加头结点的循环链表方式：        first：头指针，不存放数据，或者存放特殊要求的数据。它的lLink指向...
双向循环链表C++
Worthwhile_DUT的博客
11-23 1362
双向循环链表是在循环链表（不定义头指针，而是定义尾指针）的基础上，增加一个指针域，注意头节点的前驱是指向最后一个元素，链表中存在两个环。
C++实现双向循环链表
BeiXi's Blog
02-07 1543
本次博文是关于利用C++模板的方式实现的双向循环链表以及双向循环链表的基本操作，在之前的博文C++语言实现双向链表中，已经给大家分析了双向循环链表的结构，并以图示的方式给大家解释了双向循环链表的基本操作。本篇文章利用C++实现了双向循环链表的基本操作，其中包括： 双向循环链表 实现的功能 头部插入结点建立链表 尾部插入结点建立链表 实现指定位置插入结点 查找给定数值是否存在 ...
如何用C++实现双向循环链表
12-31
双向循环链表，即每个节点都拥有一前一后两个指针且头尾互链的链表。各种链表的简单区别如下：单向链表：基本链表；单向循环链表：不同于单向链表以 NULL 判断链表的尾部，单向循环链表的尾部链接到表头，因此当迭代操作到表头前即是尾部；双向链表：比单向链表多出指向前一个节点的指针，但实际上使用双向链表时很少使用不循环的；双向循环链表：相对于单向循环链表，双向循环链表可从头部反向迭代，这在链表长度很大且需要获取、插入或删除靠近链表尾部元素的时候十分高效。单向循环列表只能从表头正向迭代，执行的时间大于从反向迭代。node.h 代码如下:/** 节点类型。三个成员分别是：指向前一个节点的指针，元素本身，指向
谭浩强C语言程序设计，C++程序设计，严蔚敏数据结构，高一凡数据结构算法分析与实现.rar
06-13
*5.6 C＋＋处理字符串的方法——字符串类与字符串变量 5.6.1 字符串变量的定义和引用 5.6.2 字符串变量的运算 5.6.3 字符串数组 5.6.4 字符串运算举例 习题 第6章 指针 6.1 指针的概念 6.2 变量与指针 6.2.1 定义...
数据结构C++描述
03-15
数据结构C++描述 目 录 译者序 前言 第一部分 预备知识 第1章 C++程序设计 1 1.1 引言 1 1.2 函数与参数 2 1.2.1 传值参数 2 1.2.2 模板函数 3 1.2.3 引用参数 3 1.2.4 常量引用参数 4 1.2.5 返回值 4 1.2.6 递归...
数据结构算法与应用-C++语言描述
10-20
讲述了c++的各种使用的数据结构和算法，对于初学者和已经入门的都很有帮助，里面的内容有 目 录 译者序 前言 第一部分 预备知识 第1章 C++程序设计 1 1.1 引言 1 1.2 函数与参数 2 1.2.1 传值参数 2 1.2.2 模板函数 ...
数据结构与算法：C++描述
11-10
本书是关于计算机科学与工程领域的基础性研究科目之一——数据结构与算法的专著。 本书在简要回顾了基本的C++ 程序设计概念的基础上，全面系统地介绍了队列、堆栈、树、图等基本数据结构，以及贪婪算法、分而治之...
数据结构之——单向循环队列完备版（C++实现）
GaoXiaoYuan0728的博客
08-05 780
数据结构——单向循环队列完备版（C++实现） 我看了一下网上C++实现的队列大都是用之前所学的链表来实现，因为不用考虑内存溢出问题，其实单向的队列主要功能是队尾入队和队头出队，是在头和尾实现，若是没有循环在队头这一块的处理动态数组的复杂度为O(n)，而链表是O(1)，当然选用链表来实现。但是当将动态数组优化使其循环，可做到几乎所有功能的平均复杂度都可以做到O(1)。 其实单向循环队列比较好的地方主要是可以最大化的使用动态数组的空间，不必像之前的动态数组一样删除头部元素后方所有元素都要跟着移动，只需要将头节点
数据结构之——单向循环链表完备版（C++实现）
GaoXiaoYuan0728的博客
09-23 761
#pragma once #pragma once #include <iostream> using namespace std; template<class E> class Node { public: E element; //元素值 Node<E>* next; //指向下一个节点 Node() {}; //不含参数的构造函数 Node(E element, Node<E>* next) //含参数的构造函数 { th
数据结构之——双向循环队列完备版（C++实现）
GaoXiaoYuan0728的博客
08-09 757
循环双端队列实际上就是是在之前单向的循环队列的基础上可以进行两端添加、删除操作的循环队列，因此我们在函数中增加了头部入队和尾部删除。 而对于队尾元素没必要再设置一个变量，因为尾部的变量直接可以用front+size 下面是 Circle_Double_Queue.h的代码。 #pragma once #include <iostream> using namespace std; template <class E> class Circle_Double_Queue { pri
数据结构——二叉搜索树完备版（C++）
GaoXiaoYuan0728的博客
08-07 612
二叉搜索树C++实现 细致讲解了添加、遍历、求高度、判断是否为完全二叉树、删除节点的方法 对二叉搜索树进行了完备的代码实现
数据结构-双向循环链表
最新发布
10-23
双向循环链表的节点结构包含三个部分：数据域、前驱指针和后继指针。其中，前驱指针指向前一个节点，后继指针指向后一个节点。在双向循环链表中，头节点的前驱指针指向尾节点，尾节点的后继指针指向头节点。 双向...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

GXM.

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

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

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

打赏作者

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

抵扣说明：

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

余额充值