双向循环链表的基本操作

已于 2023-05-13 00:08:48 修改
阅读量277 收藏 7
点赞数 4
分类专栏： 数据结构 文章标签： 链表 数据结构 c++ c语言
于 2023-05-13 00:06:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_72982923/article/details/130632461
版权

文章目录

双向循环链表的基本操作

双向循环链表介绍

双向链表的结点：指针域1+数据域+指针域2

指针域1：指向该结点前面一个结点

指针域2：指向该结点后面一个结点
在这里插入图片描述

头文件

#include<iostream>
#include<assert.h>
using std::cin;
using std::cout;
using std::endl;

双向链表的基本结构

typedef int Datatype;  //声明数据类型

typedef struct ListNode
{
	Datatype data;      //存储数据
	struct ListNode* next;   //指向下一个节点
	struct ListNode* prev;   //指向上一个节点
}ListNode, * pListNode;

首先声明数据类型为Datatype,在接下来双链表的基本操作中，将用Datatype代表int。
如果后续存储的数据类型需要改变为其他的（如: float,double等）
只需要修改：typedef int Datatype；大大减少了工作量

next记录后继节点，prev记录前驱节点

将结构体重命名为ListNode和 * pListNode,后续声明该结构体指针时，无需用 struct ListNode * p,可以直接pListNode p,
p就为该结构体的指针
(本文后续将采用此中方法)

初始化双链表

在这里插入图片描述
初始化链表,即malloc一个哨兵节点，该节点的next指向自己，prev也指向自己，且哨兵节点中不存储值

ListNode* Init_List()
{
	pListNode s = (pListNode)malloc(sizeof(ListNode));
	if (!s) //判断malloc是否成功，若失败，判断成立，返回NULL
	{
		perror("Init_List_malloc_error!");
		return NULL;
	}
	s->next = s;
	s->prev = s;
	return s;
}

这里初始化哨兵节点，将哨兵节点的next和prev都指向自身，此时链表为空
顺便提一句: malloc可能会分配失败(但这种情况为少数)，若分配失败则会返回NULL；这时 !s 的结果为 1，也就是malloc失败，执行报错提示,并返回NULL；

双链表判空

int Empty_List(pListNode L)
{
	if (!L)
	{
		perror("ListNode*_is_NULL");
		return -1;
	}
	return L->next == L;
}

若传入节点的next等于该节点本身，说明该双链表为空
L->next==L成立，返回1，否则不为空，返回0；

下图为只有一个哨兵位的双链表，即空表，判空条件有如下两种
在这里插入图片描述

双链表尾插

在这里插入图片描述

void Insert_End(ListNode* L, Datatype x)  
{
	if (!L)
	{
		perror("Inser_End_L_NULL");
		return;
	}
	pListNode NewNode = (ListNode*)malloc(sizeof(ListNode));
	if (!NewNode)
	{
		perror("Insert_End_malloc");
		return;
	}
	NewNode->data = x;
	NewNode->next = L;
	NewNode->prev = L->prev;
	L->prev->next = NewNode;
	L->prev = NewNode;
}

同样先检查传入的链表，以及malloc的节点是否为空，若没有问题，再将节点的值赋值为x，以及新节点前后指针的修改。

双链表头插

在这里插入图片描述

void Insert_Head(ListNode* L, Datatype x)   
{
	if (!L)
	{
		perror("Inser_Head_L_NULL");
		return;
	}
	pListNode NewNode  = (ListNode*)malloc(sizeof(ListNode));
	if (!NewNode)
	{
		perror("Insert_End_malloc");
		return;
	}
	NewNode->data = x;
	NewNode->next = L->next;
	NewNode->prev = L;
	L->next->prev = NewNode;
	L->next = NewNode;
}

创建一个新节点

pListNode Buy_newNode(Datatype x)
{
	pListNode newnode = (pListNode)malloc(sizeof(ListNode));
	if (!newnode)
	{
		perror("malloc_error!");
		return NULL;
	}
	newnode->data = x;
	newnode->prev = NULL;
	newnode->next = NULL;
	return newnode;
}

这个Buy_newNode函数用来动态分配一个新的ListNode节点，并检查是否创建成功。

有了这个函数，可以减少我们的工作量

比如:
之前在头插和尾插中，我们都是先malloc一个新节点，检查是否分配成功，并为这个NewNode赋值。

pListNode NewNode  = (ListNode*)malloc(sizeof(ListNode));
	if (!NewNode)
	{
		perror("Insert_End_malloc");
		return;
	}
	NewNode->data = x;

现在我们只需要

pListNode NewNode = Buy_newNode(x);

也就是说，我们的头插和尾插可以做如下优化：

//尾插
void Insert_End(ListNode* L, Datatype x)  
{
	if (!L)
	{
		perror("Inser_End_L_NULL");
		return;
	}
	
	pListNode NewNode = Buy_newNode(x);
	
	/*
	pListNode NewNode = (ListNode*)malloc(sizeof(ListNode));
	if (!NewNode)
	{
		perror("Insert_End_malloc");
		return;
	}
	*/
	
	NewNode->data = x;
	NewNode->next = L;
	NewNode->prev = L->prev;
	L->prev->next = NewNode;
	L->prev = NewNode;
}


//头插
void Insert_Head(ListNode* L, Datatype x)   
{
	if (!L)
	{
		perror("Inser_Head_L_NULL");
		return;
	}
	
	pListNode NewNode = Buy_newNode(x);
	
	/*pListNode NewNode  = (ListNode*)malloc(sizeof(ListNode));
	if (!NewNode)
	{
		perror("Insert_End_malloc");
		return;
	}
	NewNode->data = x;
	*/
	NewNode->next = L->next;
	NewNode->prev = L;
	L->next->prev = NewNode;
	L->next = NewNode;
}

如此，不仅减少了工作量，也减轻了代码的冗余。

在某一节点前插入一个新节点

在这里插入图片描述

void Insert_List(pListNode pos, Datatype x)
{
	assert(pos);
	pListNode pos_prev = pos->prev;

	pListNode newNode = Buy_newNode(x);

	//pos_prev newNode pos
	pos_prev->next = newNode;
	newNode->prev = pos_prev;
	newNode->next = pos;
	pos->prev = newNode;
}

Insert_List函数能够创建一个新的节点，并为该节点赋值为x，同时将新创建的节点插入至节点L之前。

这个代码十分强劲，能够同时完成创建并插入。

看到这里的小伙伴不知有没有想到，之前的头插和尾插也是创建节点并赋值，再将新节点进行插入。

这两者的模式十分相同，那么我们是否又可以对之前的代码进行优化？

答案是肯定的。

看代码：

//尾插
void Insert_End(ListNode* L, Datatype x)  
{
	if (!L)
	{
		perror("Inser_End_L_NULL");
		return;
	}
	Insert_List ( L->prev,x );
}


//头插
void Insert_Head(ListNode* L, Datatype x)   
{
	if (!L)
	{
		perror("Inser_Head_L_NULL");
		return;
	}
	Insert_List ( L->next,x );
}

之前的两个庞然大物，现在直接变得精小细致。

删除当前节点

在这里插入图片描述

int Delete_(pListNode s) 
{
	if (!s)
	{
		perror("Delete_L_NULL");
		return 0;
	}
	s->prev->next = s->next;
	s->next->prev = s->prev;
	free(s);
	s = NULL;
	return 1;

该函数能够删除当前传入的指针所指向的节点。

双链表头删

void Delete_Head(pListNode L)
{
	assert(L);//判断当前指针是否为空指针
	assert(!Empty_List(L));  //判断链表是否为空
	Delete_(L->next);
}

assert排除完异常情况后，就可以用删除节点函数Delete_(s)

因为头删就是删除哨兵节点的下一个节点，只要调用Delete函数并传入L->next即可

双链表尾删

void Delete_End(pListNode L)
{
	assert(L);
	assert(!Empty_List(L));
	Delete_(L->prev);  //删除某一位置的元素
}

同理，尾删就是删除哨兵节点的前一个节点，传入L->prev即可

双链表打印

打印双链表中的元素

void Printf_List(pListNode L)   
{
	if (!L)
	{
		perror("Printf_L_NULL");
		return;
	}
	pListNode s = L->next;
	cout << "表中元素为:";
	while (s != L)
	{
		cout << s->data << " ";
		s = s->next;
	}
	cout << endl << "打印完毕!" << endl;
}

注意：循环停止的条件为当前节点的next节点如果等于哨兵节点，则说明链表已经全部遍历完，这里的等于指的是指针值相等，而不是节点中存储的数据值相等

查找

pListNode Find_List(pListNode L, Datatype x)   //按值查找
{
	if (!L)
	{
		perror("Find_L_NULL");
		return NULL;
	}
	pListNode s = L->next;
	while (s != L)
	{
		if (s->data == x)
		{
			return s;
		}
		else
		{
			s = s->next;
		}
	}
	if (s = L)
	{
		cout << "Can't find " << x << " in List!" << endl;
	}
	return NULL;
}

按值查找，若在链表中找到匹配的值，则返回该节点的地址，否则返回NULL；

销毁双链表

int Destory_List(pListNode L)  
{
	if (!L)
	{
		perror("Destory_L_NULL");
		return 0;
	}
	pListNode s = L->next, r = s;
	while (s != L)
	{
		s = s->next;
		free(r);
		r = s;
	}
	free(L);
	L = NULL;
	return 1;
}

先令指针s指向哨兵节点的后一个节点，依次释放节点，直至指针s与哨兵节点相等，最后别忘了释放头节点。
注意: 这里不能先释放哨兵节点再依次循环删除其他节点，即s必须指向哨兵节点的下一个节点，因为删除了哨兵节点，再循环，等到运行到链表最后一个节点时，s->next指向的空间已经释放了，运行会异常

代码总览

typedef int Datatype;  //声明数据类型

typedef struct ListNode
{
	Datatype data;      //存储数据
	struct ListNode* next;   //指向下一个节点
	struct ListNode* prev;   //指向上一个节点
}ListNode, * pListNode;

ListNode* Init_List()
{
	pListNode s = (pListNode)malloc(sizeof(ListNode));
	if (!s) //判断malloc是否成功，若失败，判断成立，返回NULL
	{
		perror("Init_List_malloc_error!");
		return NULL;
	}
	s->next = s;
	s->prev = s;
	return s;
}

int Empty_List(pListNode L)
{
	if (!L)
	{
		perror("ListNode*_is_NULL");
		return -1;
	}
	return L->next == L;
}

void Insert_End(ListNode* L, Datatype x)  
{
	if (!L)
	{
		perror("Inser_End_L_NULL");
		return;
	}
	pListNode NewNode = (ListNode*)malloc(sizeof(ListNode));
	if (!NewNode)
	{
		perror("Insert_End_malloc");
		return;
	}
	NewNode->data = x;
	NewNode->next = L;
	NewNode->prev = L->prev;
	L->prev->next = NewNode;
	L->prev = NewNode;
}

void Insert_Head(ListNode* L, Datatype x)   
{
	if (!L)
	{
		perror("Inser_Head_L_NULL");
		return;
	}
	pListNode NewNode  = (ListNode*)malloc(sizeof(ListNode));
	if (!NewNode)
	{
		perror("Insert_End_malloc");
		return;
	}
	NewNode->data = x;
	NewNode->next = L->next;
	NewNode->prev = L;
	L->next->prev = NewNode;
	L->next = NewNode;
}


//创建一个新节点
pListNode Buy_newNode(Datatype x)
{
	pListNode newnode = (pListNode)malloc(sizeof(ListNode));
	if (!newnode)
	{
		perror("malloc_error!");
		return NULL;
	}
	newnode->data = x;
	newnode->prev = NULL;
	newnode->next = NULL;
	return newnode;
}

void Insert_List(pListNode pos, Datatype x)
{
	assert(pos);
	pListNode pos_prev = pos->prev;

	pListNode newNode = Buy_newNode(x);

	//pos_prev newNode pos
	pos_prev->next = newNode;
	newNode->prev = pos_prev;
	newNode->next = pos;
	pos->prev = newNode;
}

int Delete_(pListNode s) 
{
	if (!s)
	{
		perror("Delete_L_NULL");
		return 0;
	}
	s->prev->next = s->next;
	s->next->prev = s->prev;
	free(s);
	s = NULL;
	return 1;
}

//双链表头删
void Delete_Head(pListNode L)
{
	assert(L);//判断当前指针是否为空指针
	assert(!Empty_List(L));  //判断链表是否为空
	Delete_(L->next);
}

//双链表尾删
void Delete_End(pListNode L)
{
	assert(L);
	assert(!Empty_List(L));
	Delete_(L->prev);  //删除某一位置的元素
}


void Printf_List(pListNode L)   
{
	if (!L)
	{
		perror("Printf_L_NULL");
		return;
	}
	pListNode s = L->next;
	cout << "表中元素为:";
	while (s != L)
	{
		cout << s->data << " ";
		s = s->next;
	}
	cout << endl << "打印完毕!" << endl;
}

//查找
pListNode Find_List(pListNode L, Datatype x)   //按值查找
{
	if (!L)
	{
		perror("Find_L_NULL");
		return NULL;
	}
	pListNode s = L->next;
	while (s != L)
	{
		if (s->data == x)
		{
			return s;
		}
		else
		{
			s = s->next;
		}
	}
	if (s = L)
	{
		cout << "Can't find " << x << " in List!" << endl;
	}
	return NULL;
}
//销毁双链表
int Destory_List(pListNode L)  
{
	if (!L)
	{
		perror("Destory_L_NULL");
		return 0;
	}
	pListNode s = L->next, r = s;
	while (s != L)
	{
		s = s->next;
		free(r);
		r = s;
	}
	free(L);
	L = NULL;
	return 1;
}
Ryan.Alaskan Malamute
关注
  • 4
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
C++双向循环链表的基本操作
05-14
这是使用VC6.0实现的双向循环链表操作的程序，实现了查找元素，查找前驱后继等功能，并在MFC界面下实现了链表操作的具体过程。
详解Linux内核之双向循环链表
shuyong1999的专栏
01-04 1348
详解Linux内核之双向循环链表 本文详解了内核中面向对象的list结构的原理，以及如何以list为内嵌对象来构造自己的链表结构，如何从内嵌list对象获得自定义的对象指针；探讨了各种宏或者函数的详细使用方法及怎样以通用list结构来操作自定义对象。 【关键字】双向循环链表，list，list_entry，typeof，containerof，list_for_each,list_for_ea
C语言详解双向链表的基本操作
weixin_73961973的博客
03-05 1246
双链表的定义与接口函数 定义双链表 接口函数 详解接口函数的实现 创建新节点（BuyLTNode） 初始化双链表（ListInit） 双向链表打印（ListPrint） 双链表查找（ListFind） 双链表销毁（ListDestory） 1、双链表pos位置之前插入（ListInsert） 2、双链表删除pos位置（ListEarse） 3、双向链表尾插（ListPushBack） 4、双向链表头插（ListPu
[数据结构] 双向循环链表的基础操作
weixin_43717520的博客
05-19 1136
本篇文章主要说明的是带头双向循环链表的基础操作，如果对链表概念不太清楚的可以点击这篇文章进行了解。链表的基本结构与操作。 目录一. 基本结构二. 基础操作1. 在指定位置之前插入元素 一. 基本结构   与单链表不同，每一个节点都增加了一个指向前驱的节点，并且首届点和尾节点分别指向开头与结尾，构成双向循环链表。   接下来的篇幅，主要讲述双向链表与单链表操作的不同之处。 二. 基础操作 1. 在指定位置之前插入元素 void ListInsert(ListNode* pos, LTDataType x)
双向循环链表的讲解及实现（图解+代码/C语言）
qq_62306969的博客
01-04 3583
本文主要分享了双向循环链表（带头）的写法，使用C语言完成，文中附有具体的结构图片帮助大家理解，希望对大家有帮助
双向循环链表
10-13
双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点...一般我们都构造双向循环链表。
如何用C++实现双向循环链表
12-31
双向循环链表，即每个节点都拥有一前一后两个指针且头尾互链的链表。各种链表的简单区别如下：单向链表：基本链表；单向循环链表：不同于单向链表以 NULL 判断链表的尾部，单向循环链表的尾部链接到表头，因此当迭代...
C++实现双向循环链表
12-20
本文实例为大家分享了C++实现双向循环链表的具体代码，供大家参考，具体内容如下 一、概念 1.在双链表中的每个结点应有两个链接指针：  lLink -> 指向前驱结点 （前驱指针或者左链指针） rLink->指向后继结点...
带头结点的双向循环链表
07-17
C++实现的带头结点的双向循环链表， 数据结构课设.。
C语言双向循环链表的基本操作
04-14
双向循环链表的基本操作，用C语言编写，包括创建，插入，删除，查找，获值等……
C语言双向链表基本操作
02-26
用C语言实现双向列表的创建，删除，添加节点，删除节点，插入节点，遍历节点，打印节点，并结合插入排序法实现了基于双向链表的升序排序。
【数据结构-C语言】双向循环链表
sakura0908的博客
03-02 1059
对链表而言，双向均可遍历是最方便的，另外首尾相连循环遍历也可打打增加链表操作的便捷性。因此，双向循环链表，是在实际运用中最常见的链表形态。
【数据结构-C】双向循环链表基本操作及图解分析
qq_52763385的博客
02-04 4308
目录 ????双向链表介绍 ????双向链表的基本操作及图解分析 ????1.双向链表创建新的结点 ????2.双向链表初始化 ????3.双向链表的尾插 ????4.双向链表的头插 ????5.双向链表的头删 ????6.双向链表的尾删 ????7.查找某个结点并返回该节点地址 ????8.在某结点前插入一个新的结点 ????9.删除某个结点 ????10.销毁双向链表 总结 ????双向链表介绍 双向链表的结点：指针域1+数据域+指针域2 ????指针域1：指向该结点
python双向链表以及双向循环链表
tt丫的博客
01-29 1342
深度学习入门小菜鸟，希望像做笔记记录自己学的东西，也希望能帮助到同样入门的人，更希望大佬们帮忙纠错啦~侵权立删。 目录 一、双向链表和双向循环链表概念 二、双向链表的实现 1、建立节点对象 2、链表对象的初始定义 3、判断链表是否为空 4、获取链表长度 5、向头部添加节点 6、向尾部添加节点 7、指定位置插入节点 8、删除指定位置的节点 9、查找是否有该数据的节点 10、遍历输出整个链表 11、输入数据创建链表 12、具体调用 三、双向循环链表的实现 1、建立节点对象 2
循环双向链表基础操作
A2438283157的博客
05-04 178
1.创建循环双向链表 2.双向循环链表的头插 3.双向循环链表的遍历 4.双向循环链表的尾插 5.双向循环链表的位置插入 6.双向循环链表判空 7.双向循环链表头删 8.双向循环链表尾删 9.双向循环链表位置删 10.双向循环链根据位置查询数据 11.双向循环链根据位置更新数据
双链表的基本操作
qq_44631587的博客
03-03 2671
带头结点的双向循环链表 链表结构如下： 每个节点都有一个数据域和两个指针域，这两个指针分别指向链表的前驱节点和后继节点，头节点的前驱节点是链表的最后一个节点，链表最后一个节点的后继节点是头节点。 正因为如此，带头结点的双向循环链表没有空节点，在进行遍历时，循环条件也与单链表不同： 单链表用cur->next为空判断当前节点是否为最后一个节点，带头的双向循环链表则需判断cur->next是否等于头节点。 定义： typedef int DataType; typedef struct ListN
双向链表的基本操作
csdn_ndsc
11-21 508
双向链表的基本操作，包括创建、初始化、添加、删除、比较等
数据结构学习日记---双向循环链表+链表初级大总结
KLh
04-09 344
一、双向循环链表模型 节点与双向链表一样，都是有前驱指针域和后继指针，双向循环链表最后一个节点指向头节点 头节点前驱指针直线循环链表最后一个节点 2..寻找最后一个节点 structlist_node*p=NULL; p=head->prev; 3.设计一个双向循环链表： #include <stdio.h> #include <stdlib.h> //设计节点 struct list_node{ int data; struct list_nod..
双向循环链表基本操作
最新发布
09-12
双向循环链表是一种链表结构，每个节点都有指向前一个节点和后一个节点的指针，同时头节点的前驱指针指向尾节点，尾节点的后继...这些是双向循环链表的基本操作，可以根据实际需求进行扩展和优化。希望对你有所帮助！

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Ryan.Alaskan Malamute

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

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

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

打赏作者

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

抵扣说明：

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

余额充值