双向链表的操作

无聊看看天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~

相关推荐
别NULL3 小时前
机试题——疯长的草
数据结构·c++·算法
ZSYP-S4 小时前
Day 15：Spring 框架基础
java·开发语言·数据结构·后端·spring
唐叔在学习4 小时前
【唐叔学算法】第21天：超越比较-计数排序、桶排序与基数排序的Java实践及性能剖析
数据结构·算法·排序算法
ALISHENGYA5 小时前
全国青少年信息学奥林匹克竞赛（信奥赛）备考实战之分支结构（switch语句）
数据结构·算法
武昌库里写JAVA7 小时前
浅谈怎样系统的准备前端面试
数据结构·vue.js·spring boot·算法·课程设计
S-X-S8 小时前
代码随想录刷题-数组
数据结构·算法
l138494274518 小时前
每日一题（4）
java·数据结构·算法
kyrie_sakura8 小时前
c++数据结构算法复习基础--13--基数算法
数据结构·c++·算法
axxy20008 小时前
leetcode之hot100---21合并两个有序链表（C++）
c++·leetcode·链表
XWXnb68 小时前
数据结构：顺序表
数据结构·算法
热门推荐
01Cube-Studio：开源大模型全链路一站式中台02ARM学习（31）编译器对overlay方式的支持03玄机平台应急响应—webshell查杀04Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO05校验 GPT-4 真实性的三个经典问题：快速区分 GPT-3.5 与 GPT-4，并提供免费测试网站06Docker 夺命连环 15 问07构建高效的广告投放系统：应用架构的设计与实现08基于大语言模型（LLM）的合成数据生成、策展和评估的综述09(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明10【一文读懂】NTN（非地面网络）技术介绍