数据结构--双链表

已于 2024-09-13 11:34:57 修改
阅读量1.4k 收藏 64
点赞数 86
分类专栏： 数据结构 文章标签： 数据结构
于 2024-09-13 11:11:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_81410974/article/details/142204222
版权

目录

一、引言

二 、链表的分类

1.单向或双向

2.带头或不带头 

3.循环或不循环 

 三、双链表的概念与基本结构

1.概念

2.基本结构 

三、双链表的常见操作

1.创建节点

2.初始化 

3.头插

4.尾插

5.头删

6.尾删

7.打印

8.查找

9.插入节点

10.删除节点

11.销毁链表

五、完整代码

1.List.h

2.List.c

3.test.c

六、总结

一、引言

双链表是一种在节点之间通过两个指针进行连接的数据结构，每个节点都有两个指针：一个指向前一个节点，另一个指向下一个节点。带头节点的双链表在实际应用中非常常见，本文将详细介绍其实现方法，并提供完整的 C 语言代码示例。

二 、链表的分类

链表的结构⾮常多样，以下情况组合起来就有8种（2 x 2 x 2）链表结构：

1.单向或双向

  • 单向链表:

    • 每个节点包含一个指向下一个节点的指针。
    • 只能从头到尾单向遍历。
    • 插入和删除操作较简单，但需要从头开始查找节点。

  • 双向链表:

    • 每个节点包含两个指针，一个指向下一个节点，一个指向前一个节点。
    • 可以从头到尾或尾到头双向遍历。
    • 插入和删除操作更灵活，但每个节点占用更多内存。

2.带头或不带头 

  • 带头节点:

    • 链表有一个额外的头节点，它不存储实际数据，只作为链表的起始点。
    • 操作如插入和删除更简单，因为头节点简化了边界条件处理。

  • 不带头节点:

    • 链表从第一个实际数据节点开始，没有额外的头节点。
    • 需要特别处理空链表和边界情况。

3.循环或不循环 

  • 循环链表:

    • 链表的尾节点指向头节点，形成一个循环结构。
    • 遍历时可以从任何节点开始，不会遇到“末尾”问题。

  • 非循环链表:

    • 链表的尾节点指向 NULL，表示链表的结束。
    • 遍历时需要检查是否到达链表末尾。

虽然有这么多的链表的结构，但是我们实际中最常⽤还是两种结构：单链表和双向带头循环链表
1. ⽆头单向⾮循环链表：结构简单，⼀般不会单独⽤来存数据。实际中更多是作为其他数据结 构的⼦结构，如哈希桶、图的邻接表等等。另外这种结构在笔试⾯试中出现很多。
2. 带头双向循环链表：结构最复杂，⼀般⽤在单独存储数据。实际中使⽤的链表数据结构，都 是带头双向循环链表。另外这个结构虽然结构复杂，但是使⽤代码实现以后会发现结构会带 来很多优势，实现反⽽简单了，后⾯我们代码实现了就知道了。

本节我们所讲的双链表即为双向带头循环链表。 

 三、双链表的概念与基本结构

1.概念

双链表简介
双链表是一种链表变体，每个节点都包含三个部分：
存储的数据。
指向前一个节点的指针（prev）。
指向下一个节点的指针（next）。
带头节点的双链表有一个特殊的节点称为头节点，它不存储有效数据，只是作为链表的一个起始辅助节点存在。头节点的 prev 指针指向自己，next 指针指向链表的第一个有效节点。

2.基本结构 

双链表的基本结构如下：

typedef struct ListNode
{
	DataType data;//数据域
	struct ListNode* prev;//指针域，指向前一个节点
	struct ListNode* next;//指针域，指向后一个节点
}LN;

三、双链表的常见操作

1.创建节点

//申请节点
LN* ListBuyNode(DataType x)
{
	LN* node = (LN*)malloc(sizeof(LN));
	if (node == NULL)
	{
		perror("malloc fail!");
		exit(1);
	}
	node->data = x;
	node->prev = node->next = node;//前后指针都指向自己，使得链表循环起来
}

2.初始化 

//初始化
void ListInit(LN** pphead)
{
	*pphead = ListBuyNode(-1);//头节点，随便给一个值（用不到）
}

3.头插

//头插
void ListPushFront(LN* phead, DataType x)
{
	assert(phead);
	LN* newnode = ListBuyNode(x);
	newnode->next = phead->next;
	newnode->prev = phead;
	phead->next->prev = newnode;
	phead->next = newnode;
	//上面两行代码位置不能交换
}

4.尾插

//尾插
void ListPushBack(LN* phead, DataType x)
{
	assert(phead);
	LN* newnode = ListBuyNode(x);
	newnode->prev = phead->prev;//新节点prev指向原来的尾节点
	newnode->next = phead;//新节点next指向头节点
	phead->prev->next = newnode;//原来的尾节点next指向newnode
	phead->prev = newnode;//头节点的prev指向newnode
	//上面两行代码位置不能交换
}

5.头删

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

 

6.尾删

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

7.打印

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

8.查找

//查找
LN* ListFind(LN* phead, DataType x)
{
	LN* pcur = phead->next;
	while (pcur != phead)
	{
		if (pcur->data == x)
		{
			return pcur;//找到了
		}
		pcur = pcur->next;
	}
	return NULL;//没有找到 
}

9.插入节点

//插入，pos节点后插入
void ListInsert(LN* pos, DataType x)
{
	assert(pos);
	LN* newnode = ListBuyNode(x);
	newnode->next = pos->next;
	newnode->prev = pos;
	pos->next->prev = newnode;
	pos->next = newnode;
}

10.删除节点

//删除
void ListErase(LN* pos)//这里不传二级指针，是为了保持接口一致性
{
	assert(pos);
	pos->next->prev = pos->prev;
	pos->prev->next = pos->next;
	free(pos);
	pos = NULL;
}

11.销毁链表

//销毁链表
void ListDestory(LN* phead)
{
	assert(phead);
	LN* pcur = phead->next;
	while (pcur != phead)
	{
		LN* 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 DataType;
typedef struct ListNode
{
	DataType data;//数据域
	struct ListNode* prev;//指针域，指向前一个节点
	struct ListNode* next;//指针域，指向后一个节点
}LN;
//初始化
void ListInit(LN** pphead);
//尾插
void ListPushBack(LN*phead,DataType x);
//头插
void ListPushFront(LN*phead,DataType x);
//打印
void ListPrint(LN* phead);
//尾删
void ListPopBack(LN* phead);
//头删
void ListPopFront(LN* phead);
//查找
LN* ListFind(LN* phead, DataType x);
//插入，pos节点后插入
void ListInsert(LN* pos, DataType x);
//删除
void ListErase(LN* pos);
//销毁链表
void ListDestory(LN* phead);

2.List.c

该部分是函数功能的实现

#define _CRT_SECURE_NO_WARNINGS
#include"List.h"
//申请节点
LN* ListBuyNode(DataType x)
{
	LN* node = (LN*)malloc(sizeof(LN));
	if (node == NULL)
	{
		perror("malloc fail!");
		exit(1);
	}
	node->data = x;
	node->prev = node->next = node;//前后指针都指向自己，使得链表循环起来
}
//初始化
void ListInit(LN** pphead)
{
	*pphead = ListBuyNode(-1);//头节点，随便给一个值（用不到）
}
//尾插
void ListPushBack(LN* phead, DataType x)
{
	assert(phead);
	LN* newnode = ListBuyNode(x);
	newnode->prev = phead->prev;//新节点prev指向原来的尾节点
	newnode->next = phead;//新节点next指向头节点
	phead->prev->next = newnode;//原来的尾节点next指向newnode
	phead->prev = newnode;//头节点的prev指向newnode
	//上面两行代码位置不能交换
}
//头插
void ListPushFront(LN* phead, DataType x)
{
	assert(phead);
	LN* newnode = ListBuyNode(x);
	newnode->next = phead->next;
	newnode->prev = phead;
	phead->next->prev = newnode;
	phead->next = newnode;
	//上面两行代码位置不能交换
}
//尾删
void ListPopBack(LN* phead)
{
	assert(phead&&phead->next!=phead);//链表必须有效且链表不为空
	LN* del = phead->prev;
	del->prev->next = phead;
	phead->prev = del->prev;
	//删除del节点
	free(del);
	del = NULL;
}
//头删
void ListPopFront(LN* phead)
{
	assert(phead && phead->next != phead);//链表必须有效且链表不为空
	LN* del = phead->next;
	del->next->prev = phead;
	phead->next = del->next;
	//删除del节点
	free(del);
	del = NULL;
}
//打印
void ListPrint(LN* phead)
{
	LN* pcur = phead->next;
	while (pcur != phead)
	{
		printf("%d->", pcur->data);
		pcur = pcur->next;
	}
	printf("NULL\n");
}
//查找
LN* ListFind(LN* phead, DataType x)
{
	LN* pcur = phead->next;
	while (pcur != phead)
	{
		if (pcur->data == x)
		{
			return pcur;//找到了
		}
		pcur = pcur->next;
	}
	return NULL;//没有找到 
}
//插入，pos节点后插入
void ListInsert(LN* pos, DataType x)
{
	assert(pos);
	LN* newnode = ListBuyNode(x);
	newnode->next = pos->next;
	newnode->prev = pos;
	pos->next->prev = newnode;
	pos->next = newnode;
}
//删除
void ListErase(LN* pos)//这里不传二级指针，是为了保持接口一致性
{
	assert(pos);
	pos->next->prev = pos->prev;
	pos->prev->next = pos->next;
	free(pos);
	pos = NULL;
}
//销毁链表
void ListDestory(LN* phead)
{
	assert(phead);
	LN* pcur = phead->next;
	while (pcur != phead)
	{
		LN* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	free(phead);
	phead = NULL;
}

3.test.c

测试，函数的调用

#define _CRT_SECURE_NO_WARNINGS
#include"List.h"
void test01()
{
	LN* plist = NULL;
	ListInit(&plist);
	/*ListPushBack(plist, 3);
	ListPushBack(plist, 2);
	ListPushBack(plist, 1);
	ListPushBack(plist, 0);*/
	ListPushFront(plist, 1);
	ListPushFront(plist, 2);
	ListPushFront(plist, 3);
	ListPushFront(plist, 4);
	// ListPopBack(plist);
	//ListPopFront(plist);
	LN* find = ListFind(plist, 3);
	//if (find == NULL)
	//	printf("没找到\n");
	//else
	//	printf("找到了\n");
	ListInsert(find, 99);
	ListErase(find);
	find = NULL;
	ListPrint(plist);
	ListDestory(plist);
	plist = NULL;

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

六、总结

带头节点的双链表在进行节点的插入和删除操作时具有较好的灵活性。头节点的存在简化了链表操作的边界条件，减少了对空链表和链表边界的特殊处理。通过本文的实现和示例代码，你应该能掌握双链表的基本操作，并能够将其应用于实际的编程任务中。
希望这个博客对你有帮助！如果你有任何问题或者需要进一步的解释，欢迎在评论区留言。

平凡程序猿~
关注
专栏目录
数据结构单链表和双链表
weixin_44786757的博客
05-22 4830
链表的定义 链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是不像顺序表一样连续存储数据，而是在每一个节点（数据存储单元）里存放下一个节点的位置信息（即地址）。 单向链表图示 1 .单链表 """ 算法. 单链表示例： """ class SingleNode(object): """链表的节点类""" def __init__(self, item...
数据结构-链表结构-双向链表
qq_44715376的博客
08-01 3775
双向链表
数据结构-双链表(图解)
2302_78381559的博客
04-20 2329
双链表是一种常用且重要的线性数据结构，它在计算机科学和软件工程中扮演着不可或缺的角色。相较于单链表，双链表的每个节点包含两个指针，分别指向其前驱节点（previous node）和后继节点（next node），这一特性使得双链表在数据操作上具有更高的灵活性。
数据结构-双链表详解
快乐的小小程序猿
09-21 1057
#include<stdio.h> #include<malloc.h> typedef struct DNode { int data; struct DNode *prior; struct DNode *next; }DNode, *DLinkList; //β²å·¨½¨Á¢Ë«Á´±í void Create_DLinkList(DLinkList &a...
Java数据结构--双向链表
m0_74808313的博客
04-23 1840
在上一篇中我们学习了单向链表的实现，链表中我们除了单向链表还有双向链表，在这一篇我们将更进一步地了解链表，实现双向链表。
数据结构 -- 链表详解
hu_143的博客
04-27 2825
链表详解，重点讲解两种常用的链表，看到就是赚到！！！
【数据结构--双链表】
qq_61719813的博客
05-04 3689
文章目录双向链表双向链表的定义双向链表的存储结构双向链表的初始化双向链表的插入双向链表的删除寻找尾结点正向打印反向打印链表节点的读取测试运行截图完整代码闵版代码（略改）总结 双向链表 双向链表的定义 什么是双向链表？ 双向链表顾名思义，就是链表由单向的链变成了双向链。双向链表(double linked list)是在单链表的每个结点中再设置一个指向其前驱结点的指针域。 非空带头结点的双向链表 双向链表的存储结构 //双链表节点结构体 typedef struct DoubleLinkNode {
C++数据结构--双向链表
海到无边天作岸 山登绝顶我为峰
04-07 2238
测试代码 #include <iostream> #include <iomanip> using namespace std; template <class DataType> struct DulNode { DataType data; DulNode <DataType>*prior,*next; }; template <cla...
数据结构--双链表的操作
03-09
数据结构--双链表的操作---带头节点
数据结构---线性表之双链表（C语言）
03-29
双链表是数据结构中的一个重要概念，尤其在C语言编程中有着广泛的应用。本文将深入探讨双链表的基本原理，以及如何使用C语言实现双链表的创建、插入和删除操作。 双链表是一种线性数据结构，与单链表不同，它在每个...
数据结构--数组、单链表和双链表介绍以及双向链表 数组和链表.pdf
04-18
数据结构--数组、单链表和双链表介绍以及双向链表 数据结构是计算机科学中的一种基本概念，指的是数据的组织和存储方式。数组、链表是两种常见的数据结构，下面将对它们进行介绍。 一、数组 数组是数据结构中的一...
漫话数据结构-双向链表及基本操作.pptx
11-03
本讲座主要探讨了一种特殊的数据结构——双向链表。双向链表是一种线性数据结构，它允许我们在列表中的节点之间进行双向移动，而不仅仅像单链表那样只能从前往后或从后往前。 双向链表的定义： 双向链表是由一系列...
【数据结构】【队列】算法汇总
Indigo____的博客
10-07 341
【代码】【数据结构】【队列】算法汇总。
数据结构-5.2.树的性质
最新发布
ADCvbV的博客
10-12 215
一个分支中，如父结点B，两个子结点为E和F，结点B的度的值为2，等于子结点数量，加上这一个父结点(父结点只能有一个)，就是结点B，E，F组成的树的总结点数即结点数 = 总度数 + 1高度为h的m叉树至少有h个结点(每层至少一个结点，共h层，所以至少共h个结点)；高度为h，度为m的树至少有h+m-1个结点(首先度为m，表明至少要有m个分支，最少时一个分支上只有一个结点，此时有m个结点，这些分支占一层，此外有h-1层，每层最少1个结点，因此这h-1层至少h-1个结点，所以整个树至少h-1+m个结点)为了达到最小
《数据结构》--队列【各种实现，算法推荐】
Stark的博客
10-06 983
队列是一种常见的数据结构，按照先进先出（FIFO，First In First Out）的原则排列数据。也就是说，最早进入队列的元素最先被移除。：将元素添加到队列的尾部。：从队列的头部移除并返回元素。：初始化一个空队列。：返回但不移除队列的头部元素（通常称为“peek”或“front”）。：检查队列中是否还有元素。：返回队列中元素的数量。
数据结构编程实践20讲(Python版)—09B树
AnFany
10-12 1094
数据结构编程实践20讲(Python版)—09B树
（JAVA）浅入数据结构 “堆” - 实现和理论
拔高、提升、创新！
10-09 557
在树结构上做出一部分改变的堆结构，是如何实现的呢？强烈建议初学者来看一看噢~！
【关系模型】关系数据结构、基本关系代数运算
lin_miao_2023的博客
10-07 767
昨天补充了DBMS概况的存储管理层面，今天来详细介绍数据库管理系统中常见且应用广泛的关系型数据库（简称关系数据库），比如postgreSQL、MySQL、Oracle Database。
评论 48
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值