【初阶数据结构篇】双向链表的实现（赋源码）

已于 2024-07-26 19:38:36 修改
阅读量239 收藏 13
点赞数 18
文章标签： 数据结构 链表 算法 c语言
于 2024-07-26 16:36:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79849925/article/details/140718818
版权

文章目录

双向链表

前言

​ 在上一篇博客中介绍了单链表（不带头单向不循环链表）的实现方法，本篇将介绍双向链表（带头双向循环链表）的实现方法。

虽然双向链表在结构上比单向链表复杂，每个结点都多了一个指向上一个结点的前驱指针，但在实现上比单链表简单很多~~

读者大大一一往下看就明白了

代码位置

[Gitee](List/List · petrichor/2024-summer-c-language - 码云 - 开源中国 (gitee.com))

双向链表的实现

双向链表的初始化和打印及销毁

List.h(其中方法会一一讲到)

  • 定义链表结构
  • 将存储数据类型重命名(方便之后替换->例如我们要求单链表内存储char类型数据，只用改一行代码即可)
  • 函数的声明，声明的时候参数只需要类型就可以了，名字加不加都一样
#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <stdbool.h>
typedef int LTDataType;
typedef struct ListNode
{
	LTDataType data;
	struct ListNode* next;
	struct ListNode* prev;
}LTNode;

//打印链表
void Print(LTNode*);
//初始化
void LTInit(LTNode**);


//插入数据
void LTPushBack(LTNode*,LTDataType);
void LTPushFront(LTNode*,LTDataType);


//删除
//判空
bool LTEmpty(LTNode*);

void LTPopBack(LTNode*);
void LTPopFront(LTNode*);


//查找
LTNode* LTFind(LTNode* phead, LTDataType x);

//在指定位置之前或之后插入节点
void LTInsert(LTNode* pos, LTDataType x);
void LTInsertBefore(LTNode* pos, LTDataType x);


//删除指定位置的节点
void LTErase(LTNode* pos);

//销毁
void LTDestroy(LTNode**);

//为了保持接口的一致性,优化代码
//将初始化和销毁函数传递的参数统一为一级指针
void LTDestroy2(LTNode*);
LTNode* LTInit2();

test.c

  • 用来测试我们写的函数(函数的调用)
  • 这一部分就是自己写的时候用的测试用例，随便什么都行

养成好习惯，写一个方法测试一次，不然找错误的时候会很痛苦😜

#define _CRT_SECURE_NO_WARNINGS 1
#include"List.h"
void ListTest01()
{
	//LTNode* plist = NULL;
	//LTInit(&plist);//初始化,只有一个哨兵位,为空链表
	 
	
	//保持接口一致性使用一级指针
	LTNode* plist = LTInit2();


	//测验尾插
	LTPushBack(plist, 4);
	//LTPushBack(plist, 3);
	//LTPushBack(plist, 4);
	//LTPushBack(plist, 5);

	//测验头插
	LTPushFront(plist, 1);
	LTPushFront(plist, 2);
	LTPushFront(plist, 3);
	//LTNode* pos=LTFind(plist, 2);
	//if (pos == NULL)
//	printf("没有找到\n");
//else
//	printf("找到了\n");


	//在指定位置之后插入数据;
	//LTInsert(pos, 6);
	//在指定位置之前插入数据
	//LTInsertBefore(pos, 7);

	//删除指定位置数据
	//LTErase(pos);
	

	//测验尾删
	//LTPopBack(plist);
	//LTPopBack(plist);
	//LTPopBack(plist);
	//LTPopBack(plist);
	// 测验头删
	//LTPopFront(plist);
	//LTPopFront(plist);
	//LTPopFront(plist);
	//LTPopFront(plist);
	//LTPopFront(plist);
	 
	//LTDestroy(&plist);

	//保持接口一致性使用一级指针
	LTDestroy2(plist);//记得把plist置为NULL
	plist = NULL;
	Print(plist);
}
int main()
{
	ListTest01();
	return 0;
}
双向链表的初始化
  • 双向链表的头结点只是拿来保存第一个节点的地址的，不用来存储有效数据，双向链表为空的时候就是只有头结点，所以双向链表初始化就是申请一个头结点，并让plist指向头结点即可
LTNode* LTBuyNode(LTDataType x)
{
	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
	if (newnode == NULL)
	{
		perror("malloc fail!");
		exit(1);
	}
	newnode->data = x;
	newnode->next = newnode->prev = newnode;
	return newnode;
}

注意：这里在申请新节点的时候，我们让它的next指针和prev指针都指向自己（否则只有一个头结点时就不叫循环链表了）

  • 我们可以和单链表一样，将plist的地址传过去，然后进行初始化
void LTInit(LTNode** pphead)
{
	//创建头结点(哨兵位)
	*pphead = LTBuyNode(-1);
}
  • 为了保持接口的一致性（在之后的方法我们都是传一级指针），此处也采用一级指针更好
LTNode* LTInit2()
{
	return LTBuyNode(-1);
}
  • 通过函数的返回值我们就让plist指向了新申请的头结点
双向链表的打印
void Print(LTNode* phead)
{
	assert(phead);
	LTNode* pcur = phead->next;
	while (pcur != phead)
	{
		printf("%d ", pcur->data);
		pcur = pcur->next;
	}
}
  • 基本思想还是定义一个pcur指针来遍历，与单链表相同
  • 不同的是结束条件，因为尾节点的next指针指向的是头结点，当pcur指向到头结点时结束遍历
  • 开始时让pcur指向头结点下个结点，头结点只是拿来存放地址的，不存放有效数据，不要打印里面的数据
双向链表的销毁
  • 和单链表一样，传二级指针
  • 最后别忘了销毁头结点
//销毁链表
void LTDestroy(LTNode** pphead)
{
	assert(pphead&&*pphead);
	LTNode* pcur, * next;
	pcur = (*pphead)->next;
	while (pcur != *pphead)
	{
		next = pcur->next;
		free(pcur);
		pcur = next;
	}
	//销毁头结点
	free(*pphead);
	*pphead = NULL;
	pcur = NULL;
}
  • 同样的，也是为了保持接口的一致性，建议使用一级指针
void LTDestroy2(LTNode* phead)
{
	assert(phead);
	LTNode* pcur = phead->next;
	while (pcur != phead)
	{
		LTNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	free(phead);
	phead=pcur = NULL;
}

在main函数中调用完这个函数后，别忘了把plist置为空！！！

双向链表的插入

  • 只要是插入都先改newnode的两个指针（否则可能会导致找不到下一个或上一个结点了）
  • 再根据插入方式改变受到影响的两个节点的prev或是next指针即可
双向链表头插
//头插
void LTPushFront(LTNode* phead, LTDataType x)
{
	LTNode* newnode = LTBuyNode(x);
	newnode->next = phead->next;
	newnode->prev = phead;
	phead->next->prev = newnode;
	phead->next = newnode;
}
双向链表尾插
//尾插
void LTPushBack(LTNode* phead, LTDataType x)
{
	LTNode* newnode = LTBuyNode(x);
	newnode->next = phead;
	newnode->prev = phead->prev;
	phead->prev->next = newnode;
	phead->prev = newnode;
}
双向链表在指定位置之前插入数据
//在指定位置之前插入数据
void LTInsertBefore(LTNode* pos, LTDataType x)
{
	assert(pos);
	LTNode* newnode = LTBuyNode(x);
	newnode->next = pos;
	newnode->prev = pos->prev;
	pos->prev = newnode;
	newnode->prev->next = newnode;
}
双向链表在指定位置之后插入数据
//在指定位置之后插入数据
void LTInsert(LTNode* pos, LTDataType x)
{
	assert(pos);
	LTNode* newnode = LTBuyNode(x);
	newnode->prev = pos;
	newnode->next = pos->next;
	//pos->next = newnode;
	//newnode->next->prev = newnode;
	pos->next->prev = newnode;
	pos->next = newnode;
}

双向链表的删除

  • 删除都别忘了判空
  • 只有一个头结点为空
//判空
bool LTEmpty(LTNode* phead)
{
	assert(phead);
	return phead->next == phead;
}
  • 将要删除的节点保存，然后更改前后结点的next指针或prev指针，最后释放
双向链表的头删
//头删
void LTPopFront(LTNode* phead)
{
	assert(phead);
	assert(!LTEmpty(phead));
	LTNode* del = phead->next;
	del->next->prev = phead;
	phead->next = del->next;
	free(del);
	del = NULL;
}
双向链表的尾删
//尾删
void LTPopBack(LTNode* phead)
{
	assert(phead);
	assert(!LTEmpty(phead));
	LTNode* del = phead->prev;
	phead->prev = del->prev;
	del->prev->next = phead;
	free(del);
	del = NULL;

}
双向链表在指定位置删除数据
//删除指定位置节点
void LTErase(LTNode* pos)
{
	LTNode* del = pos;
	del->prev->next = pos->next;
	del->next->prev = del->prev;
	free(pos);
	pos = 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;
}
  • 找到就返回指向节点的指针，否则返回空

List.c(完整版)

#define _CRT_SECURE_NO_WARNINGS 1
#include "List.h"
//打印链表
void Print(LTNode* phead)
{
	assert(phead);
	LTNode* pcur = phead->next;
	while (pcur != phead)
	{
		printf("%d ", pcur->data);
		pcur = pcur->next;
	}
}

//申请新节点
LTNode* LTBuyNode(LTDataType x)
{
	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
	if (newnode == NULL)
	{
		perror("malloc fail!");
		exit(1);
	}
	newnode->data = x;
	newnode->next = newnode->prev = newnode;
	return newnode;
}


//初始化链表
void LTInit(LTNode** pphead)
{
	//创建头结点(哨兵位)
	*pphead = LTBuyNode(-1);
}


//尾插
void LTPushBack(LTNode* phead, LTDataType x)
{
	LTNode* newnode = LTBuyNode(x);
	newnode->next = phead;
	newnode->prev = phead->prev;
	phead->prev->next = newnode;
	phead->prev = newnode;
}

//头插
void LTPushFront(LTNode* phead, LTDataType x)
{
	LTNode* newnode = LTBuyNode(x);
	newnode->next = phead->next;
	newnode->prev = phead;
	phead->next->prev = newnode;
	phead->next = newnode;
}

//判空
bool LTEmpty(LTNode* phead)
{
	assert(phead);
	return phead->next == phead;
}


//尾删
void LTPopBack(LTNode* phead)
{
	assert(phead);
	assert(!LTEmpty(phead));
	LTNode* del = phead->prev;
	phead->prev = del->prev;
	del->prev->next = phead;
	free(del);
	del = NULL;

}


//头删
void LTPopFront(LTNode* phead)
{
	assert(phead);
	assert(!LTEmpty(phead));
	LTNode* del = phead->next;
	del->next->prev = phead;
	phead->next = del->next;
	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;
}



//在指定位置之后插入数据
void LTInsert(LTNode* pos, LTDataType x)
{
	assert(pos);
	LTNode* newnode = LTBuyNode(x);
	newnode->prev = pos;
	newnode->next = pos->next;
	//pos->next = newnode;
	//newnode->next->prev = newnode;
	pos->next->prev = newnode;
	pos->next = newnode;
}


//在指定位置之前插入数据
void LTInsertBefore(LTNode* pos, LTDataType x)
{
	assert(pos);
	LTNode* newnode = LTBuyNode(x);
	newnode->next = pos;
	newnode->prev = pos->prev;
	pos->prev = newnode;
	newnode->prev->next = newnode;
}

//删除指定位置节点
void LTErase(LTNode* pos)
{
	LTNode* del = pos;
	del->prev->next = pos->next;
	del->next->prev = del->prev;
	free(pos);
	pos = NULL;
}


//销毁链表
void LTDestroy(LTNode** pphead)
{
	assert(pphead&&*pphead);
	LTNode* pcur, * next;
	pcur = (*pphead)->next;
	while (pcur != *pphead)
	{
		next = pcur->next;
		free(pcur);
		pcur = next;
	}
	//销毁头结点
	free(*pphead);
	*pphead = NULL;
	pcur = NULL;
}


void LTDestroy2(LTNode* phead)
{
	assert(phead);
	LTNode* pcur = phead->next;
	while (pcur != phead)
	{
		LTNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	free(phead);
	phead=pcur = NULL;
}


LTNode* LTInit2()
{
	return LTBuyNode(-1);
}

在双向链表的实现方法中，有几点总结心得

  1. 因为头结点的存在，plist指针始终指向头结点，不会改变。所以在插入删除等操作时不必像单链表一样分情况讨论，同时在接口上也只需传一级指针即可，对此在初始化和销毁方法上进行了优化

  2. 双向链表在遍历时如果一直沿着next或prev指针遍历会陷入死循环，所以结束条件是pcur!=phead.

  3. 总之，可以发现虽然双向链表比单链表多了一个前驱指针，但在实现方法上比单链表简单很多

链表与顺序表的比较

  • 最后，介绍完链表与顺序表后，将二者进行总结比较
    在这里插入图片描述

以上就是双向链表的实现方法啦，各位大佬有什么问题欢饮在评论区指正，您的支持是我创作的最大动力！❤️
请添加图片描述

Trouvaille ~
关注
  • 18
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 7
    评论
JAVA初阶数据结构链表（2）双向链表（ +专栏数据结构练习是完整版）
cjmyydsds的博客
03-09 378
需要注意的一点就是，在jdk中的链表就是双向链表一个节点有三个域 val（数值域） next（地址域） prev（前驱记录前一个节点的地址）在双向链表中我们还定义了一个last用来标记最后一个节点。
C语言实现数据结构和双向链表操作
01-21
数据结构 双向链表的实现 双向链表中的每一个结点都含有两个指针域，一个指针域存放其后继结点的存储地址，另一个指针域则存放其前驱结点的存储地址。 双向链表结点的类型描述： //双向链表的类型描述 typedef ...
数据结构初阶 --- 双向链表的C语言实现
m0_71722065的博客
09-12 2516
带头双向循环链表
『初阶数据结构 • C语言』⑨ - 基于结点的数据结构——链表（单链表&&双向循环链表）附完整源码
花想云的博客
01-15 1438
像数组一样，链表也用来表示一系列的元素。事实上，能用数组来做的事情，一般也可以用链表来做。然而，链表的实现跟数组是不一样的，在不同场景它们会有不同的性能表现。计算机的内存就像一大堆格子，每格都可以用来保存比特形式的数据。当要创建数组时，程序会在内存中找出一组连续的空格子，给它们起个名字，以便你的应用存放数据。我们之前说过，计算机能够直接跳到数组的某一索引上。如果代码要求它读取索引 4的值，那么计算机只需一步就可以完成任务。
【初阶数据结构篇】单链表的实现（赋源码）
最新发布
2301_79849925的博客
07-25 977
​ 链表是⼀种物理存储结构上⾮连续、⾮顺序的存储结构，数据元素的逻辑顺序是通过链表主要有两个部分：当前结点要保存的数据和保存下⼀个结点的地址（指针变量）。本篇主要介绍单链表的实现方法。
【初阶数据结构】——带头双向循环链表（C描述）
m0_70980326的博客
11-21 1246
带头双向循环链表详解
【数据结构】带头+双向+循环链表（增、删、查、改）的实现_【附源码、图片示例】_ [初阶篇_ 复习专用]
Dream_Y.ocean的博客
05-06 1143
链表是一种物理存储结构上非连续、非顺序的存储结构数据元素的逻辑顺序是通过链表中的指针链接次序实现的❗链表也符合我们在顺序表中提及的线性表，即链表也是线性表的一种🥯Ⅱ.✨综上就是链表的概念啦~➡️简单来说链表是逻辑结构上类似于顺序表的连续的结构，但实际物理结构是不一定连续存储的【数据结构】单链表（增、删、查、改）的实现[初阶篇_复习专用]但今天，我们终点来看看链表的终极形态带头+双向+循环链表🍞二.✨综上就是带头+双向+循环链表接口实现的内容啦~➡️相信大家对带头+双向+循环链表🍭。...
【初阶数据结构】带头双向循环链表讲解
s1mplewo的博客
05-15 1278
本文详细讲解了带头双向循环链表的概念及具体实现源码
【数据结构初阶】由浅入深学习链表
weixin_61654591的博客
03-11 315
在我们学习了顺序表之后，我们发现了顺序表有很多的不足之处，例如顺序表在空间不足之后需要扩容，扩容会对空间造成浪费，并且当需要头部或者中部操作数据时，顺序表必须进行挪动数据，挪动数据会造成浪费。概念：链表是一种、非顺序的存储结构，数据元素的是通过链表中的次序实现的。链表就像一辆火车一样，一节车厢接着一节车厢，这每一节车厢都可以被看做是一个结点，每一个结点链接在一起就构成了链表。
【数据结构初阶】图解链表（二）双向带头循环链表
Bitdancing的专栏
10-30 713
单链表在之前的博客里已经详细讲解过了 （指路导航 无哨兵位单向非循环链表），接下来讲解的是 双向带头循环链表。 源码地址链接 一级指针还是二级指针？ 首先我们要确定的问题是带哨兵位的链表，需要传啥类型的实参？ 由图见，因为带哨兵位，不对phead进行修改，所以只需要传一级指针。 结点结构体 // 带头+双向+循环链表增删查改 typedef int LTDataType; typedef struct ListNode { LTDataType data; struct ListNode* next
数据结构 用双向链表实现约瑟夫环
11-07
数据结构大作业，c++用双向链表实现约瑟夫环，内含.h与.cpp
（Python3）数据结构–双向链表的原理及实现
01-20
学过数据结构那自然是最好的 原理和需要注意的点 双向链表 双向链表和单链表的差别在哪？双向链表的节点和单链表的节点是不一样的。单链表的节点有item和next，而双向链表的节点还必须有一个指向前一个节点的prior...
C#数据结构之双向链表(DbLinkList)实例详解
09-03
在C#中，双向链表（Double-Linked List，简称DbLinkList）是一种重要的数据结构，它允许在列表中的每个元素都有两个链接：一个指向前一个元素，另一个指向后一个元素。这种数据结构使得在链表中进行前向和后向遍历变...
数据结构(5.3_3)——由遍历序列构造二叉树
m0_65240792的博客
07-25 121
若只给出一棵二叉树的前/中/后/层 序遍历序列中的一种，不能唯一确定一棵二叉树 例：前序遍历序列：DAEFBCHGI 中序遍历序列：DAEFBCHGI
学习记录day19——数据结构 查找算法
weixin_64918301的博客
07-25 202
在给定数据元素的某个值，在查找表中确定一个其关键字等于给定值的数据元素的操作，叫做查找。
数据结构之初始二叉树（4）
我要学编程的博客
07-22 1265
二叉树的前序遍历、二叉树的层序遍历、根据二叉树的前序和中序遍历构造二叉树、二叉树的最近公共祖先、根据二叉树创建字符串
数据结构---二叉树
weixin_47808575的博客
07-22 280
参考：二叉树遍历方法——前、中、后序遍历（图解）_二叉树遍历前序中序后序-CSDN博客
数据结构——二叉树性质
鲸落博客
07-23 391
这个性质很好记忆，观察一下图6-5-5。第一层是根结点，只有一个，所以2^(1-1)=2^0=1。第二层有两个，2^(2-1)=2=2。第三层有四个，2^(3-1)=2^2=4。第四层有八个，2^(4-1)=2^3=8。通过数据归纳法的论证，可以很容易得出在二叉树的第i层上至多有2^(i-1)个结点(i≥1)的结论。
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值