双向链表的操作

无聊看看天T^T2023-10-22 13:15

目录

前言

带头双向循环链表

双向链表的结构定义

链表的初始化

尾删

头删

结点的查找

在指定位置后插入

删除指定位置结点

链表的销毁

最终结果：

SList.h文件：

SList.c文件：

test.c文件：

顺序表和链表的优缺点分析

前言

在前面的单链表专题中，我们了解到了链表的一共有八种结构，但是最常用的链表结构还是单链表中的不带头单向不循环链表和双链表中的带头双向循环链表。

带头双向循环链表

每个结点有三个内容：

1、保存的数据data

2、保存下一个结点的地址next指针

3、保存前一个结点的地址的prev指针

双向链表的结构定义

cpp 复制代码 
//定义双向链表结点的结构
typedef int LTDataType;
struct ListNode {
	LTDataType data;//保存的数据
	struct ListNode* next;  //指向下一个结点的指针next
	struct ListNode* prev;  //指向上一个结点的指针prev
};
typedef struct ListNode LTNode;

链表的初始化

在这里我们进行插入和删除等操作时函数传参时是一个一级指针而非二级，这是因为我们的带头双向不循环链表在开始时便已经有了一个哨兵位，我们只需要使用指向该哨兵位的指针就可以实现对其它有效结点的操作，而之前的不带头单向不循环链表中没有哨兵位就需要使用一个二级指针指向存放链表第一个有效结点地址的一级指针，然后通过操纵该一级指针指向的有效结点中的next指针实现插入和删除操作（带头的单向不循环链表也可以不使用二级指针）

带头的链表传参时使用的是二级指针，不带头的链表传参时使用的是一级指针

至于使用一级指针后到底简不简单请往下看：

cpp 复制代码 
//test.c文件：
#include "List.h"
void ListTest()
{	
	LTNode* plist = LTInit();
}

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

//SList.c文件：
#include "List.h" 
LTNode* LTInit()
{
    //用phead指针指向为哨兵位申请的内存空间
	LTNode* phead = (LTNode*)malloc(sizeof(LTNode));
	if (phead == NULL)
	{
		perror("malloc error");
		return;
	}
    //哨兵位中不存储有效数据，我们这里给它存一个-1表示无效数据就行
	phead->data = -1;
    //对哨兵位的前驱和后继指针实现一个循环效果
	phead->next = phead->prev = phead;
	//返回新创建的哨兵位
	return phead;
}

（这里的应该是phead忘记改了┭┮﹏┭┮）

通过调试可以发现两种方法都实现了循环效果

尾插

cpp 复制代码 
//申请新结点node，并为其存储数据x
LTNode* ListByNode(LTDataType x)
{
	LTNode* node = (LTNode*)malloc(sizeof(LTNode));
	node->data = x;
	node->next = node->prev = NULL;
	return node;
}

//尾插
void LTPushBack(LTNode* phead,LTDataType x)
{
    //保证哨兵位不为空
	assert(phead);
	LTNode* node = ListByNode(x);
	
	//先处理新节点node的前驱和后继指针
	node->prev = phead->prev;
	node->next = phead;

	//再处理哨兵位的上一个结点的的后继指针（相当于图里的d3）和哨兵位的前驱指针
	phead->prev->next = node;
	phead->prev = node;
}

（关于成功演示，这里只看一个结果，具体代码会一起放在test.c文件中）

头插

cpp 复制代码 
//头插
void LTPushFront(LTNode* phead, LTDataType x)
{
	assert(phead);
	LTNode* node = ListByNode(x);

	//先处理新节点node的前驱和后继指针
	node->prev = phead;
	node->next = phead->next;

	//再处理phead->prev(之前的尾结点)和phead
	phead->next->prev = node;
	phead->next = node;
}

尾删

cpp 复制代码 
//尾删
void LTPopBack(LTNode* phead)
{
	assert(phead);
    //除了保证有哨兵位之外，还需要保证链表必须要有有效结点，只有哨兵位时不能执行删除操作
	assert(phead->next != phead);
    
    //这里的del就相当于d2
	LTNode* del = phead->prev;
	//先处理del的prev结点
	del->prev->next = phead;
	//处理phead
	phead->prev = del->prev;
	free(del);
	del = NULL;
}

字体懒得再写一遍改成蓝色的了，将就着看吧┭┮﹏┭┮

头删

cpp 复制代码 
//头删
void LTPopFront(LTNode* phead)
{
	assert(phead && phead->next != phead);
	LTNode* del = phead->next;

	//phead del->next
	del->next->prev = phead;
	phead->next = del->next;
	free(del);
	del = NULL;
}

结点的查找

cpp 复制代码 
//查找结点
LTNode* LTFind(LTNode* phead, LTDataType x)
{
	assert(phead);
	LTNode* cur = phead->next;
    //遍历链表
	while (cur != phead)//不能等于哨兵位
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}

在指定位置后插入

cpp 复制代码 
//在pos位置后插入数据
void LTInsert(LTNode* pos, LTDataType x) 
{
	assert(pos);
	LTNode* node = ListByNode(x);
	//node的prev和next
	node->next = pos->next;
	node->prev = pos;

	//pos的next职责和pos->next的prev
	pos->next = node;
	node->next->prev = node;
}

删除指定位置结点

cpp 复制代码 
//删除指定位置
void LTErase(LTNode* pos)
{
	assert(pos);
	//pos->prev:next pos pos->next:prev
	pos->next->prev = pos->prev;
	pos->prev->next = pos->next;
	free(pos);
	pos = NULL;
}

链表的销毁

cpp 复制代码 
//销毁链表
void LTDestory(LTNode* phead)
{
	assert(phead);
	LTNode* cur = phead->next;
	while (cur != phead)
	{
		LTNode* next = cur->next;
		free(cur);
		cur = next;
	}
	//除了循环之后，哨兵位还未释放
	free(phead);
	phead = NULL;
}

接下来是我们在链表销毁时开启的监视窗口，虽然可能有点长但是还请看完：

程序结束后：

我们会发现即使程序结束后，phea的值已经被置空但是plist的值并未被置空......

这是因为我们用于接收plist的是一个一级指针phead，对于一级指针phead的改变并不会影响plist（前面单链表中我们了解到对二级指针一次解引用后才能修改plist） ,所以当我们传递一级指针时需要手动在test.c文件中的销毁链表函数后添加一个free(plist)

最终结果：

SList.h文件：

cpp 复制代码 
#include "List.h" 

//不需要传入参数，调用该方法后我们返回一个头结点
LTNode* LTInit()
{
	LTNode* phead = (LTNode*)malloc(sizeof(LTNode));
	if (phead == NULL)
	{
		perror("malloc error");
		return;
	}
	phead->data = -1;
	phead->next = phead->prev = phead;
	//返回新创建的头结点
	return phead;
}

//申请新结点node，并为其存储数据x
LTNode* ListByNode(LTDataType x)
{
	LTNode* node = (LTNode*)malloc(sizeof(LTNode));
	node->data = x;
	node->next = node->prev = NULL;
	return node;
}

//尾插
void LTPushBack(LTNode* phead,LTDataType x)
{
	assert(phead);
	LTNode* node = ListByNode(x);
	
	//先处理新节点node的前驱和后继指针
	node->prev = phead->prev;
	node->next = phead;

	//再处理phead->prev(之前的尾结点)和phead
	phead->prev->next = node;
	phead->prev = node;
}

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

//头插
void LTPushFront(LTNode* phead, LTDataType x)
{
	assert(phead);
	LTNode* node = ListByNode(x);

	//先处理新节点node的前驱和后继指针
	node->prev = phead;
	node->next = phead->next;

	//再处理phead->prev(之前的尾结点)和phead
	phead->next->prev = node;
	phead->next = node;
}

//尾删
void LTPopBack(LTNode* phead)
{
	assert(phead);
	assert(phead->next != phead);

	LTNode* del = phead->prev;
	//先处理del的prev结点
	del->prev->next = phead;
	//处理phead
	phead->prev = del->prev;
	free(del);
	del = NULL;
}

//头删
void LTPopFront(LTNode* phead)
{
	assert(phead && phead->next != phead);
	LTNode* del = phead->next;

	//phead del->next
	del->next->prev = phead;
	phead->next = del->next;
	free(del);
	del = NULL;
}

//在指定位置后插入
void LTInsert(LTNode* pos, LTDataType x) 
{
	assert(pos);
	LTNode* node = ListByNode(x);
	//node的prev和next
	node->next = pos->next;
	node->prev = pos;

	//pos的next职责和pos->next的prev
	pos->next = node;
	node->next->prev = node;
}

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

//查找结点
LTNode* LTFind(LTNode* phead, LTDataType x)
{
	assert(phead);
	LTNode* cur = phead->next;
	while (cur != phead)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}

//销毁链表
void LTDestory(LTNode* phead)
{
	assert(phead);
	LTNode* cur = phead->next;
	while (cur != phead)
	{
		LTNode* next = cur->next;
		free(cur);
		cur = next;
	}
	//除了循环之后，哨兵位还未释放
	free(phead);
	phead = NULL;
}

SList.c文件：

cpp 复制代码 
#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <stdbool.h>
//定义双向链表结点的结构
typedef int LTDataType;
struct ListNode {
	LTDataType data;//保存的数据
	struct ListNode* next;
	struct ListNode* prev;
};
typedef struct ListNode LTNode;

//链表的初始化
LTNode* LTInit(); //不需要传入参数，调用该方法后直接返回一个头结点
//因为这是带头双向循环链表，在初始状态时，双向链表为空（只有一个哨兵位），哨兵位结点是不能被操作，
//即哨兵位不能被改变的，所以我们就不需要像之前的不带头单向不循环链表一样需要修改头结点
//哨兵位的下一个结点是链表的第一个结点（头结点），而哨兵位下一个结点是链表的最后一个结点（尾结点） 
//我们在这里规定：称后续的链表的第一个有效结点为链表的头结点，链表的最后一个结点叫做尾结点，原来的头结点现在我们称之为哨兵位

//尾部插入操作（往哨兵位的前一个位置插入也叫尾插）
void LTPushBack(LTNode* phead, LTDataType x);

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

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

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

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

//在指定位置后插入
void LTInsert(LTNode* pos, LTDataType x);

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

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

//销毁链表
void LTDestory(LTNode* phead);

test.c文件：

cpp 复制代码 
#include "List.h"

void ListTest()
{	
	LTNode* plist = LTInit();
	LTPushBack(plist, 1);
	LTPushBack(plist, 2);
	LTPushBack(plist, 3);
	LTPushBack(plist, 4);
	LTPushBack(plist, 5);//1->2->3->4->5->
	//LTPrint(plist);

	//LTPushFront(plist, 6);
	//LTPushFront(plist, 7);
	//LTPushFront(plist, 8);//8->7->6->1->2->3->4->5->
	//LTPrint(plist);

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

	//LTPopFront(plist);
	//LTPopFront(plist);
	//LTPopFront(plist);
	//LTPopFront(plist);
	//LTPopFront(plist);
	//LTPrint(plist);
	
	//LTNode* find = LTFind(plist, 2);
	///*LTInsert(find, 11);*/
	LTErase(find);
	LTPrint(plist);
	LTDestory(plist);
	传递一级指针时需要手动将plist置为空
	//plist = NULL;
}

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

顺序表和链表的优缺点分析

|-------------|------------------|----------------|
| 不同点 | 顺序表 | 链表 |
| 存储空间上 | 物理上一定连续 | 逻辑上连续但物理上不一定连续 |
| 随机访问 | 支持O（1） | 不支持：O（N） |
| 任意位置插入或删除元素 | 可能需要移动元素，效率低O（N） | 只需修改指针方向 |
| 插入 | 动态顺序表，空间不够时需要扩容 | 没有容量的概念 |
| 应用场景 | 元素高效存储+频繁访问 | 任意位置插入和删除频繁 |

emm，可能有些地方写的还是不太好但由于时间原因还没来得及更改，这两天抽时间再看看改一下┭┮﹏┭┮

~over~

相关推荐
Hera_Yc.H4 小时前
数据结构之一：复杂度
数据结构
肥猪猪爸5 小时前
使用卡尔曼滤波器估计pybullet中的机器人位置
数据结构·人工智能·python·算法·机器人·卡尔曼滤波·pybullet
linux_carlos5 小时前
环形缓冲区
数据结构
readmancynn5 小时前
二分基本实现
数据结构·算法
Bucai_不才5 小时前
【数据结构】树——链式存储二叉树的基础
数据结构·二叉树
盼海5 小时前
排序算法(四)--快速排序
数据结构·算法·排序算法
一直学习永不止步5 小时前
LeetCode题练习与总结：最长回文串--409
java·数据结构·算法·leetcode·字符串·贪心·哈希表
珹洺6 小时前
C语言数据结构——详细讲解 双链表
c语言·开发语言·网络·数据结构·c++·算法·leetcode
_whitepure6 小时前
常用数据结构详解
java·链表·树·图·栈·队列·稀疏数组
几窗花鸢7 小时前
力扣面试经典 150（下）
数据结构·c++·算法·leetcode
热门推荐
01(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明02PyTorch机器学习实现液态神经网络03【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总04玄机平台应急响应—webshell查杀05Coze扣子平台完整体验和实践（附国内和国际版对比）06Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO07怎样让音频速度变慢？请跟随以下方法进行操作08Unity中PICO实现 隔空取物 和 接触抓取物体09RAG 实践- Ollama+RagFlow 部署本地知识库10【目标跟踪】相机运动补偿