数据结构——双向链表的实现

于 2024-04-14 17:55:37 发布
阅读量516 收藏 11
点赞数 9
分类专栏： 数据结构 文章标签： 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79998744/article/details/137747879
版权

文章目录

一、双向链表的结构

带头双向循环链表
在这里插入图片描述

注意：这⾥的“带头”跟前⾯我们说的“头节点”是两个概念，实际前⾯的在单链表阶段称呼不严
谨，但是为了更好的理解就直接称为单链表的头节点。
带头链表⾥的头节点，实际为“哨兵位”，哨兵位节点不存储任何有效元素，只是站在这⾥“放哨的”

“哨兵位”存在的意义：
遍历循环链表避免死循环。

二、实现双向链表

创建双向链表的项目

在这里插入图片描述
List.h 定义双向链表的结构，声明相关的函数
List.c 实现双向链表声明的函数
test.c 测试代码

双向链表的结构

在这里插入图片描述

在这里插入图片描述

List.h

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

typedef int LTDateType;
//定义双向链表结点的结构
typedef struct ListNode
{
	LTDateType date;
	struct ListNode* next;
	struct ListNode* prev;
}LTNode;

//声明双向链表中提供的方法

//初始化

//void LTInit(LTNode** pphead);
LTNode* LTInit();

//打印
void LTPrint(LTNode* phead);

//插入数据之前，链表必须初始化为只有一个结点的情况下
// 不改变哨兵位的位置，因此传一级指针即可

//尾插
void LTPushBack(LTNode* phead, LTDateType x);

//头插
void LTPushFront(LTNode* phead, LTDateType x);

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

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

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

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

//删除pos结点
void LTErase(LTNode* pos);

//销毁
void LTDesTroy(LTNode* phead);

申请结点

//申请结点
LTNode* LTBuyNode(LTDateType x)
{
	LTNode* node = (LTNode*)malloc(sizeof(LTNode));
	if (node == NULL)
	{
		perror("malloc fail!");
		exit(1);
	}
	node->date = x;
	node->next = node->prev = node;
	return node;
}

初始化

这里有两种实现方法
在这里插入图片描述

//初始化
//void LTInit(LTNode** pphead)
//{
//	//给双向链表创建一个哨兵位
//	*pphead = LTBuyNode(-1);
//}
LTNode* LTInit()
{
	LTNode* phead = LTBuyNode(-1);
	return phead;
}

打印

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

注意：插入数据之前，链表必须初始化为只有一个结点的情况下
不改变哨兵位的位置，因此传一级指针即可

尾插

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

头插

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

尾删

//尾删
void LTPopBack(LTNode* phead)
{
	//链表必须有效并且链表不能为空（只有一个哨兵位）
	assert(phead && phead->next != phead);
	LTNode* del = phead->prev;
	//phead  del->prev  del
	del->prev->next = phead;
	phead->prev = del->prev;
	//删除del结点
	free(del);
	del = NULL;
}

头删

//头删
void LTPopFront(LTNode* phead)
{
	//链表必须有效并且链表不能为空（只有一个哨兵位）
	assert(phead && phead->next != phead);
	LTNode* del = phead->next;
	//phead  del  del->next
	del->next->prev = phead;
	phead->next = del->next;
	//删除del结点
	free(del);
	del = NULL;
}

查找

//查找
LTNode* LTFind(LTNode* phead, LTDateType x)
{
	assert(phead && phead->next != phead);
	LTNode* pcur = phead->next;
	while (pcur != phead)
	{
		if (pcur->date == x)
		{
			return pcur;
		}
		pcur = pcur->next;
	}
	return NULL;
}

在pos位置之后插入数据

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

删除pos结点

//删除pos结点
void LTErase(LTNode* pos)
{
	assert(pos);
	//pos->prev  pos  pos->next
	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;
}

三、所有源代码

List.h

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

typedef int LTDateType;
//定义双向链表结点的结构
typedef struct ListNode
{
	LTDateType date;
	struct ListNode* next;
	struct ListNode* prev;
}LTNode;

//声明双向链表中提供的方法

//初始化

//void LTInit(LTNode** pphead);
LTNode* LTInit();

//打印
void LTPrint(LTNode* phead);

//插入数据之前，链表必须初始化为只有一个结点的情况下
// 不改变哨兵位的位置，因此传一级指针即可

//尾插
void LTPushBack(LTNode* phead, LTDateType x);

//头插
void LTPushFront(LTNode* phead, LTDateType x);

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

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

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

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

//删除pos结点
void LTErase(LTNode* pos);

//销毁
void LTDesTroy(LTNode* phead);

List.c

#define _CRT_SECURE_NO_WARNINGS 1
#include "List.h"

//申请结点
LTNode* LTBuyNode(LTDateType x)
{
	LTNode* node = (LTNode*)malloc(sizeof(LTNode));
	if (node == NULL)
	{
		perror("malloc fail!");
		exit(1);
	}
	node->date = x;
	node->next = node->prev = node;
	return node;
}

//初始化
//void LTInit(LTNode** pphead)
//{
//	//给双向链表创建一个哨兵位
//	*pphead = LTBuyNode(-1);
//}
LTNode* LTInit()
{
	LTNode* phead = LTBuyNode(-1);
	return phead;
}


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

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

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

//尾删
void LTPopBack(LTNode* phead)
{
	//链表必须有效并且链表不能为空（只有一个哨兵位）
	assert(phead && phead->next != phead);
	LTNode* del = phead->prev;
	//phead  del->prev  del
	del->prev->next = phead;
	phead->prev = del->prev;
	//删除del结点
	free(del);
	del = NULL;
}

//头删
void LTPopFront(LTNode* phead)
{
	//链表必须有效并且链表不能为空（只有一个哨兵位）
	assert(phead && phead->next != phead);
	LTNode* del = phead->next;
	//phead  del  del->next
	del->next->prev = phead;
	phead->next = del->next;
	//删除del结点
	free(del);
	del = NULL;
}

//查找
LTNode* LTFind(LTNode* phead, LTDateType x)
{
	assert(phead && phead->next != phead);
	LTNode* pcur = phead->next;
	while (pcur != phead)
	{
		if (pcur->date == x)
		{
			return pcur;
		}
		pcur = pcur->next;
	}
	return NULL;
}

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

//删除pos结点
void LTErase(LTNode* pos)
{
	assert(pos);
	//pos->prev  pos  pos->next
	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;
}

test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include "List.h"
//测试代码
void test()
{
	//测试初始化
	/*LTNode* plist = NULL;
	LTInit(&plist);*/
	LTNode* plist = LTInit();

	//测试尾插
	LTPushBack(plist, 1);
	LTPrint(plist);
	LTPushBack(plist, 2);
	LTPrint(plist);
	LTPushBack(plist, 3);
	LTPrint(plist);
	LTPushBack(plist, 4);
	LTPrint(plist);

	//测试头插
	/*LTPushFront(plist, 8);
	LTPushFront(plist, 7);
	LTPushFront(plist, 6);
	LTPushFront(plist, 5);
	LTPrint(plist);*/

	//测试尾删
	/*LTPopBack(plist);
	LTPrint(plist);
	LTPopBack(plist);
	LTPrint(plist);
	LTPopBack(plist);
	LTPrint(plist);
	LTPopBack(plist);
	LTPrint(plist);
	LTPopBack(plist);
	LTPrint(plist);*/

	//测试头删
	/*LTPopFront(plist);
	LTPrint(plist);
	LTPopFront(plist);
	LTPrint(plist);
	LTPopFront(plist);
	LTPrint(plist);
	LTPopFront(plist);
	LTPrint(plist);
	LTPopFront(plist);
	LTPrint(plist);*/

	//测试查找
	/*LTNode* find = LTFind(plist, 4);
	if (find == NULL)
	{
		printf("找不到！\n");
	}
	else
	{
		printf("找到了！\n");
	}*/

	//测试在pos位置之后插入数据
	/*LTNode* find = LTFind(plist, 4);
	LTInsert(find, 88);
	LTPrint(plist);*/

	//测试删除pos结点
	/*LTNode* find = LTFind(plist, 2);
	LTErase(find);
	LTPrint(plist);
	find = NULL;*/

	//测试销毁
	LTDesTroy(plist);
	plist = NULL;
}

int main()
{
	test();
	return 0;
}
郭二哈
关注
  • 9
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
redis的数据结构——双向链表
jkzyx123的博客
08-20 899
Redis的双向链表数据结构详解
数据结构——双向链表
Labrador_Katie的博客
01-03 941
双向链表
数据结构 —— 双向链表（超详细图解 & 接口函数实现）
十里坡小白的博客
08-08 6934
数据结构是计算机存储、组织数据的方式。数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。博主将会用代码结合大量图解，对数据结构进行深度剖析。
数据结构——双向链表（保姆级教程，包学包会）
m0_74459304的博客
05-14 8250
1.双向链表的概念 双向链表就是带头双向循环链表 我们在学完单链表之后，就感觉这个非常简单了，他的主要表现就是拥有头节点，链表永不为空，不需要二级指针；可以通过一个节点找到上一个或者下一个节点；头尾相连呈环状。 他主要结构是由prev、next、data，这三个结构组成，通过prev找到前一个节点，next就不用多说了。
数据结构之链表详解(2)——双向链表
weixin_69283129的博客
08-29 9405
C语言版万字详解：数据结构之链表详解(2)——双向链表的结构和功能实现
数据结构学习——双向链表
weixin_62410421的博客
05-03 5283
文章目录前言——双向链表含义一、双向链表结构（图解）二、 双向链表的实际操作1、 结构2、创建头结点3、打印4、插入5、定位6、删除完整代码运行结果 前言——双向链表含义 双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。 一、双向链表结构（图解） 二、 双向链表的实际操作 1、 结构 /** * Double linked list of integ
数据结构—双向链表（详解）
梅山
03-20 6206
双向链表 在之前一篇文章中介绍了单向链表的实现，可以看出单向链表实现过程中，只能够逐次向下继续查找，指针一直指向下一个节点，而本文中的双向链表，在结构体定义的时候多了一个指向上一节点的指针，因此，无论是在插入还是删除来说，从后往前和从前往后遍历都极大的提高了便利性。下面来介绍双向链表的具体实现。 双向非循环链表的实现 1、链表结构体封装 /* 双向链表的结构 */ typedef struct llist_st { int data; struct llist_st * prev;
数据结构——双向链表PTA习题
流楚丶格念的博客
12-17 5935
文章目录单选题函数题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分别
大话数据结构 —— 双向链表 C#、C++代码实现
TAOTAO
06-07 471
双向列表 双向链表是每个结点除后继指针外还有一个前驱指针。和单链表类同，双向链表也有带头结点结构和不带头结点结构两种，带头结点的双向链表更为常用；另外，双向链表也可以有循环和非循环两种结构，循环结构的双向链表更为常用。 双向链表相当于两个单向循环链表,双链表节点结构如下图示： 双链表节点比单链表多一个前驱指针域。 如下图是带头结点的双向循环链表的图示结构。双向循环链...
数据结构——双向循环链表（C语言实现）
最新发布
GDYJLXQ的博客
10-22 309
双向循环链表：结构复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势。
数据结构之双向链表(完整版)
09-12
双向聊表的实现细节以及菜单显示，对数据结构的同学很有帮助，有注释！大学必备源码，可直接运行，c程序设计加数据结构
数据结构-链表结构-双向链表
qq_44715376的博客
08-01 3683
双向链表
数据结构与算法—双向链表
Han同学
10-21 666
详细讲解了数据结构中—双向链表的实现。
【数据结构】双向链表
m0_73648729的博客
06-28 7524
和单向链表一样，双向链表每个节点都是由结构体组成的数据类型，但是双向链表结构体中增加了一个指向前一个节点的指针。//方便修改数据类型//指向下一个节点的指针//指向前一个节点的指针//存储的数据}LTNode;我们今天要将的是带哨兵卫头节点的双向循环链表，它的头节点不存储有效数据，头节点中的prev指针指向最后一个节点。
数据结构--双向链表的操作（增加和删除节点）
HurryPotter
03-07 5769
第一步：首先找到插入位置，节点 s 将插入到节点 p 之前 第二步：将节点 s 的前驱指向节点 p 的前驱，即 s->prior = p->prior; 第三步：将节点 p 的前驱的后继指向节点 s 即 p->prior->next = s; 第四步：将节点 s 的后继指向节点 p 即 s->next = p; 第五步：将节点 p 的前驱指向节点 s 即 ...
数据结构-双向链表
热门推荐
aaa0329的博客
05-03 1万+
双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点 ...
数据结构之双向链表的实现
qq_62905847的博客
10-02 779
java自主实现双向链表
C语言---双向链表（详解）---数据结构
weixin_57535054的博客
02-07 7476
双向链表所需要头文件 首先重定义类型名 意义我前几篇讲过几次了，这里就不在赘述了，（顺序表，单链表的开头都有说明） 然后我们需要一个结构体 结构体包含 ： 存储数据的 a 指向一个节点的指针 next 指向上一个节点的指针 prve 双向链表实现的函数功能有 ：1.申请动态内存空间 2.初始化 3.双向链表的头，尾的插入与删除，在合法的任意位置进行插入和删除 4.释放链表，5.打印链表 1.申请动态内存空间 因为进行插入和初始化需要用到此函数 所以我们要先实现此功能 1.先申.
循环链表
zzyczzyc的博客
11-12 7693
循环链表
通讯录管理系统设计——基于链表实现
2. **基本要求**：使用《数据结构》教材中的双向链表实现通讯录管理。系统应具备以下功能： - 输入信息：录入联系人的各项详情。 - 显示信息：展示所有或特定联系人信息。 - 查找信息：按姓名查找联系人。 - ...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值