【数据结构】双链表（定义 创建 插入 删除 销毁 查找）完整代码

已于 2023-06-27 21:19:08 修改
阅读量133 收藏
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构
于 2023-06-27 16:48:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_61628700/article/details/131420629
版权

文章目录

3.2 双链表

3.2.1 定义
  • 作用

方便找上一个结点。

typedef struct DNode {
	ElemType data;
	struct DNode* prior, * next;//指向上一个和下一个的结点
}DNode,*DLinklist;
//DNode强调是结点，*DLinklist强调是链表

//初始化双链表
bool InitDLinkList(DLinklist& L) {
	L = (DNode*)malloc(sizeof(DNode));//分配一个头结点
	if (L == NULL)return false;
	L->prior = NULL;//头结点的prior永远指向null
	L->next = NULL;
	return true;
}
3.2.2 插入

  • 步骤

    1.插入节点的next指向后继节点；

    2.后继节点的prior指向插入节点；

    3.插入节点的prior指向前驱节点；

    4.前驱节点的next指向插入节点。

//p后插s
bool InsertNextDNode(DLinklist& L, int i, ElemType e) {
	if (i < 1)return false;

	DNode* p;//指针指向当前扫描到的节点
	int j = 0;//当前p指向的是第几个节点
	//查找第i个位置
	p = L;//L指向头节点，头节点是第0个节点
	while (p != NULL && j < i )
	{
		p = p->next;
		j++;
	}

	//非法参数
	if (p == NULL)return false;

	DNode* s = (DNode*)malloc(sizeof(DNode));
	s->data = e;
	s->next = p->next;//指向后继节点
	if (p->next != NULL)//如果插入位置不是链表末尾
	{
		p->next->prior = s;//后继节点指向插入节点
	}
	s->prior = p;//插入节点指向前驱节点
	p->next = s;//前驱节点指向插入节点
	return true;
}

//p前插s
//找到待插入位置的前驱节点，再进行后插
bool InsertPriorDNode(DLinklist& L, int i, ElemType e) {
	if (i < 1)return false;

	DNode* p;//指针指向当前扫描到的节点
	int j = 0;//当前p指向的是第几个节点
	//查找第i个位置
	p = L;//L指向头节点，头节点是第0个节点
	while (p != NULL && j < i - 1)
	{
		p = p->next;
		j++;
	}

	//非法参数
	if (p == NULL)return false;

	DNode* s = (DNode*)malloc(sizeof(DNode));
	s->data = e;
	s->next = p->next;//指向后继节点
	if (p->next != NULL)//如果插入位置不是链表末尾
	{
		p->next->prior = s;//后继节点指向插入节点
	}
	s->prior = p;//插入节点指向前驱节点
	p->next = s;//前驱节点指向插入节点
	return true;
}
3.2.3 删除

  • 步骤

    1.前驱节点的next指向后驱节点；

    2.后继节点的prior指向前驱节点；

    3.释放要删除的节点。

bool ListDelete(DLinklist& L, int i, ElemType& e)
{
	if (i < 1)return false;

	DNode* p;//指针p指向当前扫描到的结点
	int j = 0;//当前p指向的是第几个结点

	//循环找到第i-1个结点
	p = L;//指向头结点
	while (p != NULL && j < i - 1) {
		p = p->next;
		j++;
	}
	//i值不合法
	if (p == NULL || p->next == NULL)return false;

	DNode* q = p->next;//令q指向被删除结点
	e = q->data;//用e返回元素的值
	p->next = q->next;//将*q结点从链中断开
	if (q->next != NULL)//q不是最后一个
	{
		q->next->prior = p;
	}
	free(q);//释放结点存储空间
	return true;
}
3.2.4 销毁

相当于循环删除每个节点。

void DestoryList(DLinklist& L)
{
	//循环释放各节点
	DNode* p = L->next;
	while (p != NULL)
	{
		DNode* q = p->next;
		if (q != NULL)
		{
			p->next = q->next;
			if (q->next != NULL)
			{
				q->next->prior = p;
			}
			free(q);
		}
		p = p->next;
	}
	free(L);//释放头结点
	L = NULL;
}
3.2.5 查找

同单链表查找

时间复杂度：O(n)

* 双链表完整代码
#include<stdio.h>
#include<stdlib.h>
#include<time.h>

#define ElemType int

//----------------定义-----------------
typedef struct DNode {
	ElemType data;
	struct DNode* prior, * next;//指向上一个和下一个的结点
}DNode,*DLinklist;
//DNode强调是结点，*DLinklist强调是链表
//*DNode等价于DLinklist

//初始化双链表
bool InitDLinkList(DLinklist& L) {
	L = (DNode*)malloc(sizeof(DNode));//分配一个头结点
	if (L == NULL)return false;
	L->prior = NULL;//头结点的prior永远指向null
	L->next = NULL;
	return true;
}


//---------------建立单链表---------------

//头插法建立单链表
DLinklist List_HeadInsert(DLinklist& L)
{
	int m;
	printf("\n1.手动输入\n2.自动生成\n");
	scanf_s("%d", &m);

	if (m == 1)
	{
		DNode* s;
		int x;
		scanf_s("%d", &x);//输入结点值
		//插入表中
		while (x != 9999)//9999表示结束
		{
			//创建新结点
			s = (DNode*)malloc(sizeof(DNode));
			s->data = x;
			s->next = L->next;//新结点指针域指向原来的第一个结点
			s->prior = L;
			//头结点指向新结点
			L->next = s;
			scanf_s("%d", &x);
		}
		return L;
	}
	else if (m == 2)
	{
		DNode* s;
		int n = 10;//结点个数
		srand(time(0));//初始化随机数种子
		while (n--)
		{
			//创建新结点
			s = (DNode*)malloc(sizeof(DNode));
			s->data = rand() % 100 + 1;//随机产生100以内的数
			s->next = L->next;
			L->next = s;
		}
	}
	else
	{
		printf("请重新输入！\n");
		List_HeadInsert(L);
	}

}

//尾插法建立链表
DLinklist List_TailInsert(DLinklist& L)
{
	int m;
	printf("\n1.手动输入\n2.自动生成\n");
	scanf_s("%d", &m);

	if (m == 1)
	{
		DNode* s, * r = L;//r为表尾指针
		int x;
		scanf_s("%d", &x);//输入结点值
		//插入表中
		while (x != 9999)//9999表示结束
		{
			//创建新结点
			s = (DNode*)malloc(sizeof(DNode));
			s->data = x;
			s->prior = r;
			//表尾指针指向新结点
			r->next = s;
			//更新表尾结点
			r = s;
			scanf_s("%d", &x);
		}
		r->next = NULL;//尾结点指针置空
		return L;
	}
	else if (m == 2)
	{
		DNode* s, * r = L;
		int n = 10;//结点个数
		srand(time(0));//初始化随机数种子
		while (n--)
		{
			//创建新结点
			s = (DNode*)malloc(sizeof(DNode));
			s->data = rand() % 100 + 1;//随机产生100以内的数
			r->next = s;
			r = s;
		}
		r->next = NULL;
		return L;
	}
	else
	{
		printf("请重新输入！\n");
		List_TailInsert(L);
	}
}


//-------------------插入操作-----------------------
//p后插s
bool InsertNextDNode(DLinklist& L, int i, ElemType e) {
	if (i < 1)return false;

	DNode* p;//指针指向当前扫描到的节点
	int j = 0;//当前p指向的是第几个节点
	//查找第i个位置
	p = L;//L指向头节点，头节点是第0个节点
	while (p != NULL && j < i )
	{
		p = p->next;
		j++;
	}

	//非法参数
	if (p == NULL)return false;

	DNode* s = (DNode*)malloc(sizeof(DNode));
	s->data = e;
	s->next = p->next;//指向后继节点
	if (p->next != NULL)//如果插入位置不是链表末尾
	{
		p->next->prior = s;//后继节点指向插入节点
	}
	s->prior = p;//插入节点指向前驱节点
	p->next = s;//前驱节点指向插入节点
	return true;
}

//p前插s
//找到待插入位置的前驱节点，再进行后插
bool InsertPriorDNode(DLinklist& L, int i, ElemType e) {
	if (i < 1)return false;

	DNode* p;//指针指向当前扫描到的节点
	int j = 0;//当前p指向的是第几个节点
	//查找第i个位置
	p = L;//L指向头节点，头节点是第0个节点
	while (p != NULL && j < i - 1)
	{
		p = p->next;
		j++;
	}

	//非法参数
	if (p == NULL)return false;

	DNode* s = (DNode*)malloc(sizeof(DNode));
	s->data = e;
	s->next = p->next;//指向后继节点
	if (p->next != NULL)//如果插入位置不是链表末尾
	{
		p->next->prior = s;//后继节点指向插入节点
	}
	s->prior = p;//插入节点指向前驱节点
	p->next = s;//前驱节点指向插入节点
	return true;
}


//-----------------删除------------------
bool ListDelete(DLinklist& L, int i, ElemType& e)
{
	if (i < 1)return false;

	DNode* p;//指针p指向当前扫描到的结点
	int j = 0;//当前p指向的是第几个结点

	//循环找到第i-1个结点
	p = L;//指向头结点
	while (p != NULL && j < i - 1) {
		p = p->next;
		j++;
	}
	//i值不合法
	if (p == NULL || p->next == NULL)return false;

	DNode* q = p->next;//令q指向被删除结点
	e = q->data;//用e返回元素的值
	p->next = q->next;//将*q结点从链中断开
	if (q->next != NULL)//q不是最后一个
	{
		q->next->prior = p;
	}
	free(q);//释放结点存储空间
	return true;
}


//-----------------销毁------------------
void DestoryList(DLinklist& L)
{
	//循环释放各节点
	DNode* p = L->next;
	while (p != NULL)
	{
		DNode* q = p->next;
		if (q != NULL)
		{
			p->next = q->next;
			if (q->next != NULL)
			{
				q->next->prior = p;
			}
			free(q);
		}
		p = p->next;
	}
	free(L);//释放头结点
	L = NULL;
}


//---------------查找----------------
//按序号查找结点
DNode* GetElem(DLinklist L, int i)
{
	if (i < 1)return NULL;
	int j = 1;
	DNode* p = L->next;//第1个结点指针赋给p
	while (p != NULL && j < i)
	{
		p = p->next;
		j++;
	}
	return p;
}

//按值查找
DNode* LocateElem(DLinklist L, ElemType e)
{
	DNode* p = L->next;
	while (p != NULL && p->data != e)
	{
		p = p->next;
	}
	if (p != NULL)
	{
		printf("Success!\n");
	}
	else
	{
		printf("没有这个值！\n");
	}
	return p;
}


void Menu()
{
	printf("\n----------菜单----------\n");
	printf("1.头插法创建\n2.尾插法创建\n");
	printf("3.后插\n4.前插\n");
	printf("5.删除节点\n6.销毁双链表\n");
	printf("7.按序号查找\n8.按值查找\n");
}

void Listprint(DLinklist& L)
{
	if (L == NULL)
	{
		printf("链表为空！\n");
		return;
	}
	DLinklist t = L->next;
	while (t->next != NULL)
	{
		printf("%d ", t->data);
		t = t->next;
	}
	printf("%d\n", t->data);
}


int main()
{
	DLinklist L;
	InitDLinkList(L);

	int x;
	Menu();
	while (~scanf_s("%d", &x)) {
		if (x == 1)
		{
			List_HeadInsert(L);
			Listprint(L);
		}
		else if (x == 2)
		{
			List_TailInsert(L);
			Listprint(L);
		}
		else if (x == 3)
		{
			int pos;
			ElemType data;
			printf("请输入要插入的位置和值：\n");
			scanf_s("%d %d", &pos,& data);
			InsertNextDNode(L, pos,data);
			Listprint(L);
		}
		else if (x == 4)
		{
			int pos;
			ElemType data;
			printf("请输入要插入的位置和值：\n");
			scanf_s("%d %d", &pos, &data);
			InsertPriorDNode(L, pos, data);
			Listprint(L);
		}
		else if (x == 5)
		{
			int pos;
			ElemType x;
			printf("请输入要删除的位置:\n");
			scanf_s("%d", &pos);
			ListDelete(L, pos, x);
			printf("已删除元素：%d\n", x);
			Listprint(L);
		}
		else if (x == 6)
		{
			DestoryList(L);
			printf("Success!\n");
			Listprint(L);
		}
		else if (x == 7)
		{
			DNode* p;
			int n;
			printf("请输入需要查找的序号：\n");
			scanf_s("%d", &n);
			p = GetElem(L, n);
			printf("查找结点的值：%d", p->data);
		}
		else if (x == 8)
		{
			DNode* p;
			int n;
			printf("请输入需要查找的结点值：\n");
			scanf_s("%d", &n);
			p = LocateElem(L, n);
		}

		Menu();
	}
	return 0;
}
吧啦吧啦嘭
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构C语言-双链表的定义、销毁及增删改查
T1cH9的博客
06-08 835
学习自用
数据结构顺序表和链表（超详细）
08-14
创建返回链表的头结点.// 双向链表销毁// 双向链表打印// 双向链表尾插// 双向链表尾删// 双向链表头插// 双向链表头删// 双向链表查找// 双向链表在pos的前面进行插入// 双向链表删除pos位置的结点
双向链表API及C语言实现
03-29
双向链表的API和C语言实现，程序说明在我的专栏《数据结构与算法学习笔记》中双向链表相关文章。包含了双向链表的结点结构体、表头结构体、创建双向链表、销毁双向链表、获取链表长度、清空双向链表、插入一个节点元素（包含异常分析）、按位置删除链表结点（包含异常分析）、按元素删除链表结点、返回一个结点元素、重置游标、游标上移、游标下移以及测试函数。所有API实现均为C语言版本，在我的文章《【数据结构】双向链表的API及C语言实现》中有所有API说明和异常分析的图解。另外还有线性表顺序存储、单链表、循环链表的C语言实现，文章及代码资源均已上传，可在专栏《数据结构与算法学习笔记》中查看，欢迎大家查看下载，如果内容有不合理的地方，欢迎大家批评指正。
双向链表创建插入删除销毁等
11-29
双向链表，创建，插入，删除，销毁等，写的一个代码（包括详细的注释，初学者都看得懂），已经成功测试。及拿即用。
编程实现顺序存储结构和链式存储结构线性表的建立、查找、插入、删除等基本操作
热门推荐
foreverlove111的博客
10-30 1万+
#include #include typedef struct LNode{ int data; //链表数据 struct LNode* next; //链表指针 }LNode,*LinkList; typedef enum __bool { false = 0, true = 1, } bool; /*头插法-建立单链表*/ LinkList HeadCreate(Li
c语言,c++顺序表操作（创建、插入、查找、显示、删除、有序合并、排序）
Systemas的博客
02-27 3589
C++链表 **这次链表操作包括 “链表初始化” “链表创建“ ”链表插入“ ”链表查找“ ”链表显示“ ”链表删除“ ”链表有序合并“；链表是c++的一个难点，这次我为大家献上了我的教程。 这也是我的第一篇博客因为本人也是一位大学生，学习时间紧所以不经常发博客，此次老师留作业要做链表操作，本来链表也是难点同学们也需要理解，这次共享望大家支持点赞。 下面是整体的代码 #include...
C语言 双链表 插入/删除/查找/遍历/递归/合并/排序
HardessGod的博客
12-12 2375
       双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。 1 双链表数据结构 1.1 新增节点图解 1.2 删除一个节点图解 2 双链表操作          双链表和单链表在操作主要区别在于插入和删除，双链表需要修改...
数据结构之双链表（c语言附完整代码)
m0_62795460的博客
11-04 2097
双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。声明双链表typedef struct DNode //定义双链表结点类型 {//数据域 struct DNode * prior;//指向前驱结点 struct DNode * next;//指向后继结点 } DLinkNode;注意：本文章讨论的双链表是带头结点的双链表。
双链表详解(初始化、插入、删除、遍历)(数据结构与算法)
AII_IIA的博客
11-04 1995
同时，删除节点后必须确保释放相应的内存空间，以防止内存泄漏问题的发生。11. 双链表相较于单链表需要额外存储指向前一个节点的指针，因此会在空间上占用更多的内存。7. 双链表的每个节点包含三个部分：数据域、指向前一个节点的指针和指向下一个节点的指针。在双链表中删除节点的操作相对比较复杂，因为我们需要维护前驱节点和后继节点之间的指针连接。在双链表中插入节点需要更新前驱节点和后继节点的指针连接，操作相对比较复杂。将 p 结点的next指针，指向q结点的后继结点。程序设计如下：注意修改指针时要注意顺序！
C++实现双链表的创建、插入、删除、查询、遍历、销毁等基本操作
Qian_Qian_IT的博客
09-20 1330
C++实现双链表的创建、插入、删除、查询、遍历、销毁等基本操作
数据结构——双向链表
麦麦的博客
03-11 2027
数据结构——双向链表：本文对双向链表的功能实现进行了详细地讲解，并与单链表的实现进行对比，干货满满，图文并茂，过万好文，不容错过！！！
数据结构：图解链表，用链表实现栈（c语言版）
06-06
数据结构：图解链表，用链表实现栈（c语言版） 栈(stack)是限定仅在表尾进行插入或者删除的线性表。对于栈来说，表尾端称为栈顶（top），表头端称为栈低（bottom）。不含元素的空表称为空栈。因为栈限定在表尾进行...
基于C++(QT)链表实现过程化（数据结构）【100011836】
04-11
功能分为三个板块，分别是单链表、循环链表、双向链表的建立、插入、删除等基本操作的过程。 单链表：●查看单链表定义，相应算法代码；●建立一个带头结点的空单链表；●指定插入位置及元素值到单链表中；●随机...
数据结构之循环双链表（c语言附完整代码）
m0_62795460的博客
11-10 875
将双链表的尾结点next指针域由原来的为空改为指向头结点，将它的头结点prior指针域改为指向尾结点，整个双链表构成两个环，便构成了循环双链表。示意图：typedef struct DNode //定义双链表结点类型 {//指向前驱结点 struct DNode * next;//指向后继结点 } DLinkNode;注意：本文章讨论的循环双链表是带头结点的循环双链表。增加头结点的优点如下：1.循环双链表中首结点的插入和删除操作与其他结点一致，无需进行特殊处理。
数据结构 双向链表及其基本操作
Mi-ronin的博客
03-17 7099
双向链表的一系列操作讲解及代码
数据结构（python）之小杨笔记一
m0_74811962的博客
05-10 353
数据结构：数据结构是计算机科学中研究数据组织、管理和存储方式的一门重要领域。（5.）树：一种非线性的数据结构，由节点和边组成，每个节点最多有一个夫节点和多个子节点。（2.）链表：由一系列节点组成的数据结构，每个结构包含数据和指向下一个节点的指针。（3.）图的算法：用于解决图结构中的各种问题的算法，如最短路径，最小生成树。的数据结构，只能在队列的前端进行删除操作，在队列的后端进行插入操作。（6.）图：一种包含节点和边的数据结构，用于表示对象之间的关系。（1.）堆：一种特殊的树形数据结构，用于实现。
Go解析的数据类型可能含有不同数据结构的处理方式
最新发布
不主动，不拒绝，不负责
05-14 175
最近做一个需求，各种业务消息都会往我的消息队列中写各种类型的数据，服务端需要接受各种不同的参数然后转换为本地数据结构，Go语言不确定上游传过来的数值是什么类型，然后又下面四种解决方案。
【数据结构】线性表----链表详解
Skrrapper的博客
05-14 993
前面我们介绍的顺序表，在逻辑结构和物理结构上都是线性、连续的关系，那么我们在篇尾的时候也提到了是否有一种顺序表，无需在物理结构上连续，从而达到更好存取的目的呢？今天它来了。链表（LinkList）属于线性表的一种，以下是百度百科关于链表的定义：在结构上链表数据域指针域。我们可以类比成火车，火车每一节车厢实际上是独立的，也就好比数据域，存储着各自的数据；但每一节车厢之间都会由一条链连接在一起，从而形成整个火车，链也就好比指针域，起到连接该车厢和指向下一车厢的作用。而实际上这样的存储结构也就是为什么。
【数据结构】链表
小林的博客
05-12 340
​ 链表不同于顺序表，顺序表底层采用数组作为存储容器，需要分配一块连续且完整的内存空间进行使用，而链表不需要，它通过一个指针来连接各个分散的结点，形成了一个链状的结构，每个结点存放一个元素，以及一个指向下一个结点的指针，通过这样一个一个相连，最后形成了链表。​ 它不需要申请连续的空间，只需要按顺序连接即可，虽然物理上可能不想邻，但在逻辑上依然是每个元素相邻存放的，这种结构就叫链表（单链表）
数据结构循环链表代码
11-06
循环链表是一种链式存储结构，它的特点是表尾结点的指针域指向表头结点，形成一个环。以下是C语言实现循环链表的代码： ```c #include <stdio.h> #include <stdlib.h> // 定义循环链表结点 typedef struct node { int data; struct node *next; } Node; // 初始化循环链表 void initList(Node **head) { *head = (Node *)malloc(sizeof(Node)); (*head)->next = *head; } // 插入数据 void insert(Node *head, int data) { Node *p = (Node *)malloc(sizeof(Node)); p->data = data; p->next = head->next; head->next = p; } // 删除数据 void delete(Node *head, int data) { Node *p = head->next; Node *pre = head; while (p != head) { if (p->data == data) { pre->next = p->next; free(p); return; } pre = p; p = p->next; } } // 查找数据 Node *search(Node *head, int data) { Node *p = head->next; while (p != head) { if (p->data == data) { return p; } p = p->next; } return NULL; } // 销毁循环链表 void destroyList(Node **head) { Node *p = (*head)->next; while (p != *head) { Node *temp = p; p = p->next; free(temp); } free(*head); *head = NULL; } ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值