数据结构【双链表】

已于 2024-05-24 09:19:15 修改
阅读量694 收藏 31
点赞数 26
分类专栏： #数据结构 文章标签： 数据结构 c语言 笔记
于 2024-05-22 15:52:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80216111/article/details/139052302
版权

前言

我们前面学习了单链表(点击这里跳转到单链表博客)，那么应该发现了一个问题，就是我每次尾插和尾删都需要先把链表遍历一遍，这样是不是过于麻烦了，这时候我们就可以使用双向链表。

1. 链表的分类

  • 带头和不带头

首先带头就是在链表的头节点前面再添加一个节点，这个节点的next指针指向的是头节点并且不存储任何的数据，就像一个哨兵一样(所以我们也把这个节点成为哨兵位)。
不带头就是我的链表的第一个节点就会存储数据。
在这里插入图片描述

  • 单向和双向

单向就是我只有一个指针变量，只用来存放我下一个节点的地址。
双向就是我在单向的基础上，再加一个指针变量，这个指针变量是用来存放前一个节点的地址。
在这里插入图片描述

  • 循环和不循环

是否循环是看你最后一个节点的next的指向；如果指向NULL，就为不循环；如果指向的是我的头节点或者链表的其他节点，就为循环链表。
在这里插入图片描述

一个链表都是包含这三个元素的，这样下来，前前后后能组成八种链表，其中单链表和双链表是两个极端。
单链表的全名是不带头单向不循环链表。
双链表的全名是带头双向循环链表。
在这里插入图片描述

2. 双链表的结构

typedef int LTDATATYPE;

typedef struct ListNode
{
	LTDATATYPE data;
	struct ListNode* next; //指向下一个节点
	struct ListNode* prev; //指向前一个节点 prev(previous的缩写)
}LTNode;

3. 双链表接口的实现

头文件(List.h)

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

typedef int LTDATATYPE;

typedef struct ListNode
{
	LTDATATYPE data;
	struct ListNode* next; //指向下一个
	struct ListNode* prev; //指向前一个 prev(previous的缩写)
}LTNode;

//初始化
LTNode* LTInit();
void LTDesTroy(LTNode* phead);

void LTPrint(LTNode* phead);

//插入数据之前，链表必须初始化到只有一个头结点的情况
//不改变哨兵位的地址，因此传一级即可
//尾插
void LTPushBack(LTNode* phead, LTDATATYPE x);
//头插
void LTPushFront(LTNode* phead, LTDATATYPE x);

//尾删
void LTPopBack(LTNode* phead);
//头删
void LTPopFront(LTNode* phead);


//在pos位置之后插入数据
void LTInsert(LTNode* pos, LTDATATYPE x);
//删除pos节点
void LTErase(LTNode* pos);
LTNode* LTFind(LTNode* phead, LTDATATYPE x);

3.1 创建新节点

LTNode* BuyNode(LTDATATYPE x)
{
	LTNode* Node = (LTNode*)malloc(sizeof(LTNode));
	if(Node == NULL)
	{
		perror("malloc fail!");
		exit(1);
	}
	Node->data = x;
	Node->next = Node->prev = Node;
	return Node;
}

由于这段函数只用来服务该文件内的函数，所以不需要再头节点声明；如果后面需要再其他文件内使用，则再声明到头文件即可。

3.2 双链表的初始化

由于我们这个双链表是带头的，所以我们可以使用函数(创建新节点)来解决

//初始化
LTNode* LTInit()
{
	LTNode* phead = BuyNode(-1);//这里可以传任意的值，我们要使用双链表的时候并不会使用哨兵位的数据
	return phead;
}

创建哨兵位节点时，我们可以给随机的值，我们在使用双链表的时候并不会使用哨兵位的数据。

3.3 尾插

由于我们并不改变哨兵位的地址，因此传一级即可！！！

void LTPushBack(LTNode* phead, LTDATATYPE x)
{
	assert(phead);
	LTNode* NewNode = BuyNode(x);
	
	//用来存放当前链表的尾节点
	LTNode* pcur = phead->prev;

	//改变新节点的指向
	NewNode->prev = pcur;
	NewNode->next = phead;

	pcur->next = NewNode;
	phead->prev = NewNode;
}

具体如下图
在这里插入图片描述

3.4 头插

//头插
void LTPushFront(LTNode* phead, LTDATATYPE x)
{
	assert(phead);
	//头插是在插入在哨兵位的后面，成为哨兵位后的第一个节点
	//不是插入到哨兵位的前面

	LTNode* NewNode = BuyNode(x);
	
	LTNode* ptmp = phead->next;

	NewNode->prev = phead;
	NewNode->next = ptmp;

	ptmp->prev = NewNode;
	phead->next = NewNode;

}

原理和尾插大致相同，但要注意的是头插是在插入在哨兵位的后面，成为哨兵位后的第一个节点，而不是在链表的前面插入节点。
具体如下图：
在这里插入图片描述

3.5 尾删

我们除了判断phead是否为空以外，我们还要判断phead是否只有哨兵位。

//尾删
void LTPopBack(LTNode* phead)
{
	assert(phead && phead->prev != phead);

	LTNode* del = phead->prev;

	phead->prev = del->prev;
	del->prev->next = phead;

	free(del);
	del = NULL;
}

我们先创建一个del来储存链表的尾节点，将del的前节点的next指针指向phead，再将phead的prev的指针指向del的前一个节点。在这里插入图片描述

3.6 头删

//头删
void LTPopFront(LTNode* phead)
{
	assert(phead && phead->prev != phead);

	LTNode* del = phead->next;

	del->next->prev = phead;
	phead->next = del->next;

	free(del);
	del = NULL;
}

逻辑如下图
在这里插入图片描述

3.7 查找节点

根据节点的数据进行查找，如果找到了，返回被找到的节点；如果找不到，就返回NULL

LTNode* LTFind(LTNode* phead, LTDATATYPE x)
{
	assert(phead);
	LTNode* pcur = phead->next;
	while (pcur != phead)
	{
		if (pcur->data == x)
		{
			return pcur;
		}
		pcur = pcur->next;
	}
	return NULL;
}

3.8 在指定节点后插入数据

//在pos位置之后插入数据
void LTInsert(LTNode* pos, LTDATATYPE x)
{
	assert(pos);

	LTNode* NewNode = BuyNode(x);

	NewNode->prev = pos;
	NewNode->next = pos->next;

	pos->next->prev = NewNode;
	pos->next = NewNode;
}

注意：改变原链表的顺序不能变
假设我是先改变了pos的next指针，再改变原pos的下一个节点的指向就会很麻烦
在这里插入图片描述
所以我们先改变pos的下一个节点的prev，再改变pos的next
在这里插入图片描述

3.9 删除指定节点

//删除pos节点
void LTErase(LTNode* pos)
{
	assert(pos && pos->next != pos);

	LTNode* del = pos;

	pos->prev->next = pos->next;
	pos->next->prev = pos->prev;

	free(del);
	del = NULL;

}

大致和头删一样，先改变前一个节点的指向和先改变后一个节点的指向都可以。

3.10 打印双链表

void LTPrint(LTNode* phead)
{
	assert(phead != NULL);
	LTNode* pcur = phead->next;
	while (pcur != phead)
	{
		printf("%d ->", pcur->data);
		pcur = pcur->next;
	}
}

3.11 销毁双链表

void LTDesTroy(LTNode* phead)
{
	assert(phead);
	LTNode* del = phead->next;
	while (del != phead)
	{
		LTNode* pcur = del->next;
		free(del);
		del = pcur;
	}
	//跳出循环后，phead只剩下哨兵位
	free(phead);
	phead = NULL;
}

大体和单链表的销毁类似，就是要在循环结束后把哨兵位给释放掉。

4. 完整代码

头文件

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

typedef int LTDATATYPE;

typedef struct ListNode
{
	LTDATATYPE data;
	struct ListNode* next; //指向下一个
	struct ListNode* prev; //指向前一个 prev(previous的缩写)
}LTNode;


//初始化
LTNode* LTInit();
//销毁
void LTDesTroy(LTNode* phead);
//打印
void LTPrint(LTNode* phead);

//插入数据之前，链表必须初始化到只有一个头结点的情况
//不改变哨兵位的地址，因此传一级即可
//尾插
void LTPushBack(LTNode* phead, LTDATATYPE x);
//头插
void LTPushFront(LTNode* phead, LTDATATYPE x);

//尾删
void LTPopBack(LTNode* phead);
//头删
void LTPopFront(LTNode* phead);


//在pos位置之后插入数据
void LTInsert(LTNode* pos, LTDATATYPE x);
//删除pos节点
void LTErase(LTNode* pos);
LTNode* LTFind(LTNode* phead, LTDATATYPE x);

源文件

#include"List.h"
//创建新节点
LTNode* BuyNode(LTDATATYPE x)
{
	LTNode* Node = (LTNode*)malloc(sizeof(LTNode));
	Node->data = x;
	Node->next = Node->prev = Node;
	return Node;
}
//初始化
//void LTInit(LTNode** pphead);
LTNode* LTInit()
{
	LTNode* phead = BuyNode(-1);
	return phead;
}

//销毁
void LTDesTroy(LTNode* phead)
{
	assert(phead);
	LTNode* del = phead->next;
	while (del != phead)
	{
		LTNode* pcur = del->next;
		free(del);
		del = pcur;
	}

	free(phead);
	phead = NULL;
}

//打印
void LTPrint(LTNode* phead)
{
	assert(phead != NULL);
	LTNode* pcur = phead->next;
	while (pcur != phead)
	{
		printf("%d ->", pcur->data);
		pcur = pcur->next;
	}
}


//尾插
void LTPushBack(LTNode* phead, LTDATATYPE x)
{
	assert(phead);
	LTNode* NewNode = BuyNode(x);

	LTNode* pcur = phead->prev;

	NewNode->prev = pcur;
	NewNode->next = phead;

	pcur->next = NewNode;
	phead->prev = NewNode;

}
//头插
void LTPushFront(LTNode* phead, LTDATATYPE x)
{
	assert(phead);
	//头插是在插入在哨兵位的后面，成为哨兵位后的第一个节点
	//不是插入到哨兵位的前面

	LTNode* NewNode = BuyNode(x);
	
	LTNode* ptmp = phead->next;

	NewNode->prev = phead;
	NewNode->next = ptmp;

	ptmp->prev = NewNode;
	phead->next = NewNode;

}

//尾删
void LTPopBack(LTNode* phead)
{
	assert(phead && phead->prev != phead);

	LTNode* del = phead->prev;

	phead->prev = del->prev;
	del->prev->next = phead;

	free(del);
	del = NULL;
}
//头删
void LTPopFront(LTNode* phead)
{
	assert(phead && phead->prev != phead);

	LTNode* del = phead->next;

	del->next->prev = phead;
	phead->next = del->next;

	free(del);
	del = NULL;
}


//在pos位置之后插入数据
void LTInsert(LTNode* pos, LTDATATYPE x)
{
	assert(pos);

	LTNode* NewNode = BuyNode(x);

	NewNode->prev = pos;
	NewNode->next = pos->next;

	pos->next->prev = NewNode;
	pos->next = NewNode;
}
//删除pos节点
void LTErase(LTNode* pos)
{
	assert(pos && pos->next != pos);

	LTNode* del = pos;

	pos->prev->next = pos->next;
	pos->next->prev = pos->prev;

	free(del);
	del = NULL;

}

LTNode* LTFind(LTNode* phead, LTDATATYPE x)
{
	assert(phead);
	LTNode* pcur = phead->next;
	while (pcur != phead)
	{
		if (pcur->data == x)
		{
			return pcur;
		}
		pcur = pcur->next;
	}
	return NULL;
}

结语

最后感谢您能阅读完此片文章，如果有任何建议或纠正欢迎在评论区留言，也可以前往我的主页看更多好文哦(点击此处跳转到主页)。
如果您认为这篇文章对您有所收获，点一个小小的赞就是我创作的巨大动力，谢谢！！！

向上爬的卓卓卓
关注
  • 26
    点赞
  • 踩
  • 31
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构-链表结构-双向链表
qq_44715376的博客
08-01 3292
双向链表
数据结构双向链表
09-24
编译环境vs2010,C语言实现双向链表的基础操作，详细注释，基础必备。
数据结构 双向链表及其基本操作
Mi-ronin的博客
03-17 7176
双向链表的一系列操作讲解及代码
数据结构——双向链表
麦麦的博客
03-11 2080
数据结构——双向链表：本文对双向链表的功能实现进行了详细地讲解，并与单链表的实现进行对比，干货满满，图文并茂，过万好文，不容错过！！！
【双向链表】数据结构双向链表的实现
m0_56069910的博客
02-01 1942
双向链表的实现
【数据结构】双链表
m0_62531913的博客
08-15 1325
数据结构中的双链表
数据结构学习——双向链表
weixin_62410421的博客
05-03 4989
文章目录前言——双向链表含义一、双向链表结构（图解）二、 双向链表的实际操作1、 结构2、创建头结点3、打印4、插入5、定位6、删除完整代码运行结果 前言——双向链表含义 双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。 一、双向链表结构（图解） 二、 双向链表的实际操作 1、 结构 /** * Double linked list of integ
数据结构-双向链表
热门推荐
aaa0329的博客
05-03 1万+
双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点 ...
【数据结构】双向链表
m0_73648729的博客
06-28 6140
和单向链表一样，双向链表每个节点都是由结构体组成的数据类型，但是双向链表结构体中增加了一个指向前一个节点的指针。//方便修改数据类型//指向下一个节点的指针//指向前一个节点的指针//存储的数据}LTNode;我们今天要将的是带哨兵卫头节点的双向循环链表，它的头节点不存储有效数据，头节点中的prev指针指向最后一个节点。
数据结构-双向链表操作
有朋自远方来，不亦乐乎。
08-05 1226
先创建好一个双向链表：代码： 结果： （1）加表头假设新元素节点为 temp，表头节点为 head，则需要做以下 2 步操作即可： （2）加表中 （3）加表尾 2、双向链表删除节点 只需遍历链表找到要删除的结点，然后将该节点从表中摘除即可 3、双向链表查找节点 双向链表同单链表一样，都仅有一个头指针。因此，双链表查找指定元素的实现同单链表类似，都是从表头依次遍历表中元素。 4、双向链表修改节点 通过遍历找到存储有该数据元素的结点，直接更改其数据域即可。 完整代码：
数据结构—双向链表（详解）
梅山
03-20 6067
双向链表 在之前一篇文章中介绍了单向链表的实现，可以看出单向链表实现过程中，只能够逐次向下继续查找，指针一直指向下一个节点，而本文中的双向链表，在结构体定义的时候多了一个指向上一节点的指针，因此，无论是在插入还是删除来说，从后往前和从前往后遍历都极大的提高了便利性。下面来介绍双向链表的具体实现。 双向非循环链表的实现 1、链表结构体封装 /* 双向链表的结构 */ typedef struct llist_st { int data; struct llist_st * prev;
数据结构 双向链表（C++）
06-07
数据结构　双向链表的实现
C语言 数据结构双向链表简单实例
08-31
主要介绍了C语言 数据结构双向链表简单实例的相关资料,需要的朋友可以参考下
C语言数据结构 双向链表的建立与基本操作
01-01
C语言数据结构 双向链表的建立与基本操作 双向链表比单链表有更好的灵活性，其大部分操作与线性表相同。下面总结双向链表与单链表之间的不同之处及我在实现过程中所遇到的问题。 1.双向链表的建立 双向链表在初始...
数据结构逻辑
qq_42129915的博客
06-10 349
1、线性关系2：树型关系3：图像关系。
【排序算法】计数排序（CountSort）
SWsunlight的博客
06-08 614
计数排序
排序-快速排序
最新发布
18602
06-15 195
快速排序（Quick Sort）是一种高效的排序算法，由英国计算机科学家霍尔（C. A. R. Hoare）在1960年提出。它的基本思想是：通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。
数据结构之LinkedList与链表（上）
我要学编程的博客
06-12 1121
手动实现单链表的源码 手动实现双链表的源码 分析LinkedList 的源码 LinkedList的使用：常用方法 ArrayList 和 LinkedList的区别
C语言刷题（函数）
2303_82176667的博客
06-09 793
一个数如果恰好等于它的所有因子(不包括它本身)之和，这个数就称为“完数”。
数据结构双链表的插入
03-28
双链表是一种常见的数据结构，它由一系列节点组成，每个节点包含两个指针，一个指向前一个节点，一个指向后一个节点。双链表的插入操作可以分为三种情况： 1. 在头部插入：将新节点插入到双链表的头部，即成为新的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值