【数据结构】双向链表的讲解与实现

已于 2024-08-21 14:10:05 修改
阅读量428 收藏 5
点赞数 6
文章标签： 数据结构 链表 c语言 开发语言
于 2024-08-09 01:01:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_84538476/article/details/141038896
版权

在这里插入图片描述

一、双向链表的概念、结构与操作

1.1概念

双向链表全称双向带头循环链表，属于链表的一种。在双向链表中，每个节点包括数据元素、指向下一个节点的指针以及指向前一个节点的指针。其优点在于：可从前往后和从后往前两个方向进行遍历，在某些操作（如删除节点时）更加灵活和高效。

1.2结构

节点结构：数据＋指向下一个节点的指针＋指向上一个节点的指针
双向链表的结构图解

1.3操作

双向链表基本的操作包括：初始化、插入、删除、查找、销毁

二、双向链表的代码实现

2.1 双向链表的头文件

【注】此处的头文件相当于代码的目录

//初始化创建哨兵位
void LTInit(LTNode** pphead);

//增加节点
LTNode* LTBuyNode(LTdataType x);

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

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

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

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

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

//判断哨兵位（头结点）是否为空
bool LTEmpty(LTNode* phead);

//链表查找
LTNode* LTFind(LTNode* phead, LTdataType x);

//在pos位置之后插入节点
void LTInsert(LTNode* pos, LTdataType x);

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

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

2.2 定义双向链表节点结构：

双向带头，定义指针next和prev

//定义双向链表节点的结构
typedef int LTdataType;
typedef struct ListNode
{
	LTdataType data;
	struct ListNode* next;//指向下一个节点的指针
	struct ListNode* prev;//指向上一个节点的指针


}LTNode;

2.3链表增加节点

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;
}

2.4链表初始化

创建一个哨兵位

//初始化
void LTInit(LTNode** pphead)
{
	//创建一个哨兵位（头结点）
	*pphead = LTBuyNode(-1);

}

2.5链表的打印

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

2.6 链表的插入（包括头插和尾插）

头插图解

void LTPushBack(LTNode* phead, LTdataType x)
{
	LTNode* newnode = LTBuyNode(x);

	LTNode* tail = phead->prev;

	tail->next = newnode;
	newnode->prev = tail;
	newnode->next = phead;
	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;
}

2.7 链表的判空

在进行删除之前，我们要先判断该链表是否为空，若链表为空，则不能进行删除操作！我们用bool类型判断。

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

2.8 链表的删除（包括头删和尾删）

删除之前先进行断言，判断链表是否为空，然后画图分析节点变化。

void LTPopBack(LTNode* phead)
{
	assert(phead);
	assert(!LTEmpty(phead));
	LTNode* del = phead->prev;
	LTNode* prev = del->prev;

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

	free(del);
	del = NULL;
}

void LTPopFront(LTNode* phead)
{
	assert(phead);
	assert(!LTEmpty(phead));

	LTNode* del = phead->next;
	LTNode* tail = del->next;
	tail->prev = phead;
	phead->next = tail;

	free(del);
	del = NULL;
}

2.9 链表的查找

先断言，然后定义一个指针存储头结点的下一个节点，进行循环遍历。

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;
}

2.10 链表指定位置的插入

还是先断言，然后申请一个新的节点存储要插入的数据，在指定位置后插入。

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;
}

2.11 链表删除指定位置节点

void LTErase(LTNode* pos)
{
	assert(pos);
	pos->prev->next = pos->next;
	pos->next->prev = pos->prev;

	free(pos);
	pos = NULL;
}

2.12链表的销毁

void LTDesTroy(LTNode** pphead)
{
	assert(pphead && *pphead);
	LTNode* pcur = (*pphead)->next;
	while (pcur!= *pphead)
	{
		LTNode* 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;
}

三、完整源代码：

LT.c文件的完整代码。

#include"LT.h"


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);

	LTNode* tail = phead->prev;

	tail->next = newnode;
	newnode->prev = tail;
	newnode->next = phead;
	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;
}

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

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

//删除
void LTPopBack(LTNode* phead)
{
	assert(phead);
	assert(!LTEmpty(phead));
	LTNode* del = phead->prev;
	LTNode* prev = del->prev;

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

	free(del);
	del = NULL;
}

void LTPopFront(LTNode* phead)
{
	assert(phead);
	assert(!LTEmpty(phead));

	LTNode* del = phead->next;
	LTNode* tail = del->next;
	tail->prev = phead;
	phead->next = tail;

	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;
}

//在pos位置之后插入结点
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;
}

//删除指定位置结点
void LTErase(LTNode* pos)
{
	assert(pos);
	pos->prev->next = pos->next;
	pos->next->prev = pos->prev;

	free(pos);
	pos = NULL;
}

//销毁
void LTDesTroy(LTNode** pphead)
{
	assert(pphead && *pphead);
	LTNode* pcur = (*pphead)->next;
	while (pcur != *pphead)
	{
		LTNode* 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;
}

test.c文件的代码：

void test01()
{
	//创建双向链表变量
	LTNode* plist = NULL;
	LTInit(&plist);

	//LTNode* plist = LTInit();
	LTPushBack(plist, 1);
	LTPushBack(plist, 2);
	LTPushBack(plist, 3);
	LTPushBack(plist, 4);
	LTPushBack(plist, 5);

	LTPrint(plist);

	/*LTPushFront(plist, 1);
	LTPushFront(plist, 2);
	LTPushFront(plist, 3);
	LTPushFront(plist, 4);
	LTPushFront(plist, 5);

	LTPrint(plist);*/

	//LTPopBack(plist);
	//LTPopBack(plist);


	/*LTPopBack(plist);
	LTPrint(plist);
	LTPopBack(plist);
	LTPrint(plist);*/

	/*LTPopFront(plist);
	LTPrint(plist);*/

	LTNode* pos = LTFind(plist, 3);
	if (pos == NULL)
	{
		printf("没有找到！\n");
	}
	else
	{
		printf("找到了！\n");
	}

	LTInsert(pos, 11);
	LTErase(pos);
	LTPrint(plist);

	//LTDesTroy(&plist);
	LTDesTroy2(plist);
	plist = NULL;


}

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

test.c文件的代码时用于测试，按需取，非常粗糙…

潘潘潘潘潘潘潘潘潘潘潘潘
关注
双向链表
高老板爱吃橙子和橙子的博客
05-05 439
双向链表 特点：有两个指针域，一个指向直接前驱，一个指向直接后继。 双向链表的设计 因为链表能够双向移动，所以得有两个指针域。 typedef int ELEMTYPE; typedef struct DNode { ELEMTYPE data; //数据域 DNode* next; //指向直接后继 DNode* prior; //指向直接前驱 }DNode, * Dlist; //Dlist == DNode* 双向链表的基本操作 初始化
数据结构-链表结构-双向链表
qq_44715376的博客
08-01 3746
双向链表
数据结构：双向链表
最新发布
2401_86551514的博客
08-03 991
这里的“带头”跟“头节点”是两个概念，带头链表里的头节点，实际为“哨兵位”，哨兵位节点不存储任何有效元素，只是站在这里“放哨 的” ，存在的意义： 遍历循环链表避免死循环。虽然有这么多的链表的结构，但是我们实际中最常用还是两种结构：单链表和双向带头循环链表，上一篇我们已经讲了单链表，今天就来了解一下双向链表并将其实现。顺序表和链表我们都学了，两者各有各的优缺点，根据需求的不通，运用在不同的场景。本篇的内容就到这里了，希望对各位有帮助，如果有错误欢迎指出。还是老样子，在头文件里写出我们需要功能的函数名。
数据结构之双向链表详解
小源_ 的博客
12-20 3584
本文着重讲解了LinkedList(无头双向单链表)的实现和LinkedList的使用。内附代码和图文分析，看完就会！
数据结构-使用javascript讲解数据结构之链表.zip
02-12
本资料包“数据结构-使用javascript讲解数据结构之链表.zip”将深入探讨链表的概念、实现以及其在JavaScript中的应用。 链表不同于数组，数组是连续的内存空间，而链表的元素在内存中是非连续存储的。每个元素称为...
数据结构《LinkeList 双向链表》
m0_66483195的博客
11-13 1146
LinkeList 的模拟和使用
python数据结构之链表的实例讲解
09-21
在实际应用中，链表常用于实现堆栈、队列、哈希表等更复杂的数据结构，因为它能有效地处理数据的插入和删除。例如，Python的内置`collections.deque`类就是一种双端队列，其底层实现就利用了链表的特性。 总结来说...
无头双向链表方法
yanweiding的博客
10-29 126
public class DoubleLinkedList { //头插法 public void addFirst(int data); //尾插法 public void addLast(int data); //任意位置插入,第一个数据节点为0号下标 public boolean addIndex(int index,int data); //查找是否包含关键字key是否在单链表当中 public boolean contains(int key); //删除第一次出现关键字为key的节点 publi
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值