【数据结构】—— 双向链表(超详细)

已于 2025-01-10 06:16:24 修改
阅读量1.1k 收藏 23
点赞数 23
文章标签： 数据结构 链表 c语言
于 2025-01-10 06:13:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/2301_80741580/article/details/145045614
版权

本文干货满满，你准备好了吗？

目录

前面我们了解到链表总共有八种类型，我们已经学习了其中的一种，即不带头单向不循环链表，也就是单链表。那么今天我们又将学习一种链表的结构，即带头双向循环链表，简称双向链表。

接下来让我们一起进入双向链表的学习吧！ \color{green}{接下来让我们一起进入双向链表的学习吧！} 接下来让我们一起进入双向链表的学习吧！

一、什么是双向链表？

带头双向循环链表简称双向链表，是链表结构的一种，其结构如下图所示：在这里插入图片描述
我们可以看到，双向链表与单链表不同的是双向链表的第一个节点之前有一个head节点，这个就是头节点，同时双向链表每个节点有两个指针，一个指向前一个节点（prev），一个指向后一个节点（next），它可以从头到尾，也可以从尾到头双向遍历，所以它是循环的，这大大增加了双向链表的灵活性。

二、单链表和双向链表的不同点

在我们实际运用中，最常用的即单链表和双向链表
那么这两种结构具体有什么不同点呢？下面为大家总结一下。
节点指针
单链表：每个节点只有一个指向下一个节点的指针。这意味着你只能从当前节点访问下一个节点，而无法直接访问前一个节点。
双向链表：每个节点有两个指针，一个指向前一个节点，一个指向后一个节点。这使得你可以从当前节点访问前一个节点和后一个节点。
遍历方向
单链表：由于每个节点只有一个指向下一个节点的指针，因此只能从头到尾单向遍历。
双向链表：由于每个节点有两个指针，因此可以从头到尾，也可以从尾到头双向遍历。
增删节点复杂度
单链表：增加和删除节点相对简单，只需调整一个指针。例如，删除一个节点时，只需将前一个节点的指针指向被删除节点的下一个节点。
双向链表：增加和删除节点较为复杂，需要调整两个指针。例如，删除一个节点时，需要将前一个节点的后指针指向被删除节点的后一个节点，并将后一个节点的前指针指向被删除节点的前一个节点。
内存占用
单链表：内存占用较少，因为每个节点只包含一个指针。
双向链表：内存占用较多，因为每个节点包含两个指针。
使用场景
单链表：适用于节点的增加和删除操作频繁的场景，因为这些操作相对简单。
双向链表：适用于需要双向查找节点值的场景，因为可以从两个方向遍历链表，提供了更大的灵活性。

三、双向链表的实现

1、定义节点结构

双向链表的节点也是结构体结构，别忘了双向链表每个节点有prev和next两个指针
注意
双向链表为空时，还剩下一个头结点，头结点的prev和next指针都指向自己，如下图所示：
在这里插入图片描述
双向链表头结点不存储有效数据

//定义节点结构
 typedef int LTDataType;
 typedef struct ListNode
 {
   LTDataType data;
   struct ListNode* next;//指向下一节点的指针
   struct ListNode* prev;//指向前一个节点的指针
   LTDataType data;//存储的数据
 }LTNode;

2、双向链表要实现的功能

对于双向链表，我们要实现以下功能：

 //初始化
//void LTInit(LTNode** pphead);
LTNode* LTInit();
//申请节点
LTNode* LTBuyNode(LTDataType x);
//销毁
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、双向链表功能的实现

3.1、申请节点

//申请节点
 LTNode* LTBuyNode(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 = BuyListNode(-1);//哨兵位不存储有效的值，这里传参传-1（也可以传其他值）
   return phead;
 }

3.3、打印链表

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

3.4、双向链表尾插

在双向链表尾插过程中，哨兵位节点（即头结点）不能被删除，节点的地址也不能发生改变（哨兵位不能被修改），所以在传形参的时候传一级指针。

//尾插
 void LTPushBack(LTNode* phead,LTDataType x)
 {
   assert(phead);//哨兵位不能为空
   LTNode* newnode = LTBuyNode(x);
   newnode->prev = phead->prev;
   newnode->next = phead;
   phead->prev->next = newnode;/1
   phead->prev = newnode;//2
   //1和2不能交换位置
 }

在这里插入图片描述

3.5、双向链表头插

头插不是往哨兵位前面去插入，而是往第一个有效的节点前面去插入新节点。

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

在这里插入图片描述

3.6、双向链表尾删

要注意链表必须有效且链表不能为空，链表为空即链表只有一个哨兵位。

 //尾删
 void LTPopBack(LTNode* phead)
 {
   assert(phead && phead->next != phead);//链表有效且不为空
   LTNode* del = phead->prev;
   del->prev->next = phead;
   phead->prev = del->prev;
   free(del);//删除del节点
   del = NULL;
 }

3.7、双向链表头删

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

3.8、查找指定数据

//查找
 LTNode* LTFind(LTNode* phead, LTDataType x)
{
	LTNode* pcur = phead->next;
	while (pcur != phead)
	{
		if (pcur->data == x)
		{
			return pcur;
		}
		pcur = pcur->next;
	}
	//没有找到
	return NULL;
}

3.9、在指定位置之后插入数据

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

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

在这里插入图片描述

3.10、删除pos节点

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

   free(pos);
   pos = NULL;
}

3.11、销毁链表

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

LTErase和LTDestroy参数理论上要传二级指针，因为我们需要让形参的改变影响到实参，但是为了保持接口的一致性才传的一级指针，传一级指针存在的问题是：当形参phead置为NULL后，实参plist不会被修改为NULL，因此解决办法是：调用完方法后手动将实参置为NULL。

四、总代码

1、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;
}LTNode;

//初始化
//void LTInit(LTNode** pphead);
LTNode* LTInit();
//申请节点
LTNode* LTBuyNode(LTDataType x);
//销毁
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);

2、List.c

 #include"List.h"

 //申请节点
 LTNode* LTBuyNode(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;
}

//初始化
 LTNode* LTInit()
 {
   //给双向链表创建一个哨兵位
   LTNode* phead = BuyListNode(-1);//哨兵位不存储有效的值，这里传参传-1（也可以传其他值）
   return phead;
 }
  
  //打印
  void LTPrint(LTNode* phead)
{
	LTNode* pcur = phead->next;
	while (pcur != phead)
	{
		printf("%d->", pcur->data);
		pcur = pcur->next;
	}
	printf("\n");
}

//尾插
 void LTPushBack(LTNode* phead,LTDataType x)
 {
   assert(phead);//哨兵位不能为空
   LTNode* newnode = LTBuyNode(x);
   newnode->prev = phead->prev;
   newnode->next = phead;
   phead->prev->next = newnode;/1
   phead->prev = newnode;//2
   //1和2不能交换位置
 }

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

  //尾删
 void LTPopBack(LTNode* phead)
 {
   assert(phead && phead->next != phead);//链表有效且不为空
   LTNode* del = phead->prev;
   del->prev->next = phead;
   phead->prev = del->prev;
   free(del);//删除del节点
   del = NULL;
 }
  
 //头删
 void LTPopFront(LTNode* phead)
 {
   assert(phead && phead->next != phead);
   
   LTNode* del = phead->next;
   phead->next = del->next;
   del->next->prev = phead;
   free(del);//删除del节点
   del = NULL;
 }

 //查找
 LTNode* LTFind(LTNode* phead, LTDataType x)
{
	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->next = pos->next;
   newnode->prev = pos;

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

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

   free(pos);
   pos = NULL;
}

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

3、test.c

 #include"List.h"

void ListTest01()
{
	//LTNode* plist = NULL;
	//LTInit(&plist);
	LTNode* plist = LTInit();

	LTPushBack(plist, 1);
	LTPushBack(plist, 2);
	LTPushBack(plist, 3);
	LTPrint(plist);

	LTNode* find = LTFind(plist, 3);
	//LTInsert(find, 66);
	LTErase(find);
	find = NULL;

	LTPrint(plist);
	LTDesTroy(plist);
	//测试尾删
	LTPopBack(plist);
	LTPrint(plist);
	LTPopBack(plist);
	LTPrint(plist);
	LTPopBack(plist);
	LTPrint(plist);
}

int main()
{
	ListTest01();
	return 0;
}

那么到这里就结束啦！感谢您的阅读，点个小赞再走吧。后面将持续为您更新哦！

数据结构-双向链表
小马不奔腾的博客
04-03 220
一. 双向链表
数据结构之双向链表
红莲灭的博客
08-18 267
文章目录双向链表节点代码分析代码实现 双向链表 双向链表也叫双向表，是链表的一种，他由多个节点组成，每个结点都有一个数据域和两个指针域祖晨，数据域用来存储数据，其中一个指针域用来指向后继节点，两一个指针域用来指向前驱节点，链表的头结点的数据域不存储数据，指向前驱节点的指针域值为null，指向后继节点的指针域指向第一个真正存储数据的节点。 节点代码分析 class Node<T> { T item; Node next; Node pre; public No
双向链表的C实现
热门推荐
12-20 1万+
双向链表需要定义一个结构体，结构体有3个属性typedef struct __Node{     int data;    数据     struct __Node *pre;    指向前一个结点指针     struct __Node *next;    指向下一个结点指针 }Node;其中 pre和next指针式嵌套定义。一般链表定义一个头指针Node *head；指向链表第一个结点，如果链表为空的话，那么head == NULL。双向链表一般分为init，insert, delete, se
数据结构——双向链表
最新发布
xiaoxin_________的博客
02-03 809
（存储元素）、（prev）和（next）。与单向链表不同，双向链表的节点不仅可以通过下一个节点（next）进行访问，还可以通过前一个节点（prev）进行访问，因此它支持从两个方向进行遍历。这种结构使得在任意节点的插入、删除以及遍历操作都非常高效。希望这个简要的图示和说明可以帮助你理解双向链表的基本概念！
redis的数据结构——双向链表
jkzyx123的博客
08-20 1022
Redis的双向链表数据结构详解
数据结构——双链表详解（超详细）
effort123_的博客
08-05 1216
哨兵位这个名字看起来是很威武的，其实了解它之后就知道它仅仅就是名字威武点，它才是真正意义上的头结点，哨兵位是不存数据的，它的存在仅仅就是为了说明这个链表是带头的，是用来“放哨的”，小编在讲述单链表的时候曾多次提到了头结点这个名字，那个时候头结点是链表第一个结点，这个叫法是不太规范的，不过为了让读者朋友更好的去理解链表的知识，小编于是就直接头结点来代替链表第一个结点了，不过各位读者朋友一定要清楚。下面紧跟小编的步伐，开启今天的双链表之旅！
数据结构——双向循环链表
qq_67611811的博客
08-28 2379
双向循环链表，在原单链表的基础上多了一个指向上一个结点的前驱指针prev，这样前后结点就不仅仅有了单向的从头至尾的指向顺序，也可以从后指向前，从末结点指向头结点。双向带头循环链表结构} DGR;加入前驱指针后，不管是对于链表数据的尾插尾删，或是头插头删，其时间复杂度都为O(1)，大大简化了链表遍历过程，而可以直接在链表首尾增减数据，因为一个链表的末节点可由头结点的前驱指针直接访问而不需要遍历至尾。为了简化文本描述，本章双向循环带头链表均简称为双向链表。...
数据结构——双向链表PTA习题
流楚丶格念的博客
12-17 6031
文章目录单选题函数题6-1 链式表操作集 (20分)各个操作函数的定义为：输入样例：输出样例：代码6-2 带头结点的链式表操作集 (20分)输入样例：输出样例：代码6-4 共享后缀的链表 (25分)输入样例：输出样例：代码 单选题 题号 题目 答案 1 设h为不带头结点的单向链表。在h的头上插入一个新结点t的语句是： t->next=h; h=t; 2 带头结点的单链表h为空的判定条件是： h->next == NULL; 3 对于一非空的循环单链表，h和p分别
数据结构：双向链表
qq_43824618的博客
03-09 617
双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。 双向链表的实现代码 函数的声明：（头文件名DSeqList.h） #include<stdio.h> typedef int ElemType; typedef struct Node// 创建结点...
数据结构中的双向链表
Bixiwen_liu的博客
12-16 634
本博客主要介绍数据结构中的双向链表。双向链表是在单向链表基础上改进的一种链表。本文主要介绍双向链表的由来，代码演示等来介绍。
链表------双向链表详解
weixin_51134816的博客
05-05 2075
双链表在增删改查方面比单链表方便很多，但在存储空间方面，单链表是比双链表更优的，根据场景不同，两种链表都能发挥出其优点。在学习链表方面，还是要注意区分头指针和头结点！不懂就查，不懂就问，不会就多练！
数据结构之双向链表（四）
An Insecure Programming
09-04 525
双向链表 概念 双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。 双向链表示意图如下： 双向链表的优缺点： ★优点：对于链表中一个给定的结点，可以从两个方向进行操作。 ☆缺点：每个结点添加一个额外的指针，因此需要更多的空间开销；结...
双向链表超详解——连我奶奶都能学会的复杂链表(带头双向循环)
2301_78190552的博客
11-25 2185
手把手教你如何手撕双向链表！
数据结构笔记（四）顺序表和链表的基本操作
weixin_45541911的博客
08-20 549
线性表 线性表又分为顺序储存和链式储存，分别称为顺序表和链表。 顺序表 在计算机中申请一块连续的空间，将元素按存入,是一种随机存取的方式，这种方式可以随时读取，其时间复杂度为O(1)，但需要做增删操作时，需要移动大量元素，时间复杂度是O（n）。因为是连续的空间，因此会造成空间浪费或溢出的现象。 删除顺序表的第 i 个元素时，需要移动 n - i 个元素； 插入到第 i 个位置时，需要移动 n - i + 1个元素。 顺序表有静态分配与动态分配，这里记录最常用的动态分配 #include<stdlib
双向链表
DY_DAVE的博客
09-12 385
双向链表其实是单链表的改进。 当我们对单链表进行操作时，有时你要对某个结点前面的一个结点进行操作时，又必须从表头开始查找。这是由单链表结点的结构所限制的。因为单链表每个结点只有一个存储直接子结点地址的链域，那么能不能定义一个既有存储直接子结点地址的链域，又有存储直接父结点地址的链域的这样一个双链域结点结构呢？这就是双向链表。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值