0
点赞
收藏
分享

微信扫一扫

学习笔记---更进一步的双向链表专题~~

幺幺零 2023-10-29 阅读 16
笔记链表双向链表数据结构算法新手c语言

目录

1. 双向链表的结构🦊

2. 实现双向链表🐝

2.1 要实现的目标🎯

2.2 创建+初始化🦋

2.2.1 List.h

2.2.2 List.c

2.2.3 test.c

2.2.4 代码测试运行

2.3 尾插+打印+头插🪼

思路分析

2.3.1 List.h

2.3.2 List.c

2.3.3 test.c

2.3.4 代码测试运行

2.4 尾删+头删🐊

2.4.0 思路分析

2.4.1 List.h

2.4.2 List.c

2.4.3 test.c

2.4.4 代码测试运行

2.5 查找数据+pos节点后插入+删除pos节点🦩

2.5.0 思路分析

2.5.1 List.h

2.5.2 List.c

2.5.3 test.c

2.5.4 代码测试运行

2.6 销毁☄️

2.6.0思路分析

1. 一级指针

2.6.1 List.h

2.6.2 List.c

2.6.3 test.c

2.6.4 代码测试运行

2. 二级指针

2.6.1 List.h

2.6.2 List.c

2.6.3 test.c

2.6.4 代码测试运行

2.7 完整代码💦

2.7.1 List.h

2.7.2 List.c

2.7.3 test.c

3. 顺序表和双向链表的分析🍻

1. 双向链表的结构🦊

2. 实现双向链表🐝

2.1 要实现的目标🎯

2.2 创建+初始化🦋

2.2.1 List.h

#include<assert.h>
#include<string.h>
#include<stdbool.h>

typedef int LTDataType;
//创建双向链表的结构体
typedef struct ListNode {
	LTDataType data;
	struct ListNode* prev;
	struct ListNode* next;
}ListNode;

//初始化
ListNode* LTInit();//不用传入参数，直接调用接口返回一个头节点

2.2.2 List.c

#include"List.h"
//初始化
ListNode* LTInit()//不用传入参数，直接调用接口返回一个头节点
{
	//为头节点申请空间
	ListNode* phead = (ListNode*)malloc(sizeof(ListNode));
	//判断开辟是否成功
	if (phead == NULL)
	{
		perror("malloc error!\n");
		return;
	}
	//开辟成功--->初始化头节点
	phead->data = -1;//头节点不存储有效数据，可以任意赋值
	//只有哨兵位的时候，要实现双向链表，不能指向NULL，否则无法双向循环，所以我们指向自己
	phead->prev = phead->next = phead;
	return phead;
}

2.2.3 test.c

#include"List.h"
void ListTest()
{
	ListNode* plist = LTInit();
}
int main()
{
	ListTest();
	return 0;
}

2.2.4 代码测试运行

2.3 尾插+打印+头插🪼

思路分析

2.3.1 List.h

//在双向链表中不会改变哨兵位，所以这里都可以传一级指针
//尾插
void LTPushBack(ListNode* phead, LTDataType x);

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

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

2.3.2 List.c

//在双向链表中不会改变哨兵位，所以这里都可以传一级指针
// 只改变数据，不改变地址

//开辟空间
ListNode* ListBuyNode(LTDataType x)
{
	ListNode* node = (ListNode*)malloc(sizeof(ListNode));
	if (node == NULL)
	{
		perror("malloc error!\n");
		return;
	}
	node->data = x;
	node->next = node->prev = NULL;
	return node;
}

//尾插
void LTPushBack(ListNode* phead, LTDataType x)
{
	assert(phead);//注意哨兵位不能为空
	//申请空间
	ListNode* node = ListBuyNode(x);
	//先处理node的前驱指针和后继指针
	node->prev = phead->prev;
	node->next = phead;
	//再处理之前的尾节点和phead
	phead->prev->next = node;
	phead->prev = node;
}

//打印
void LTPrint(ListNode* phead)
{
	//哨兵位不能改变
	ListNode* cur = phead->next;
	while (cur != phead)//当cur再次指向phead的时候，循环结束
	{
		printf("%d->", cur->data);
		cur = cur->next;
	}
	printf("\n");
}

//头插
void LTPushFront(ListNode* phead, LTDataType x)
{
	assert(phead);//注意哨兵位不能为空
	//申请空间
	ListNode* node = ListBuyNode(x);
	//node插入头节点之后才算头插
	//先处理node的前驱指针和后继指针
	node->prev = phead;
	node->next = phead->next;
	//再处理phead和phead->next
	phead->next->prev = node;
	phead->next = node;
}

2.3.3 test.c

#include"List.h"
void ListTest()
{
	ListNode* plist = LTInit();
	LTPushBack(plist, 1);
	LTPushBack(plist, 2);
	LTPushBack(plist, 3);
	LTPushBack(plist, 4);
	LTPrint(plist);//1 2 3 4 
	LTPushFront(plist, 5);
	LTPrint(plist);//5 1 2 3 4 
}
int main()
{
	ListTest();
	return 0;
}

2.3.4 代码测试运行

2.4 尾删+头删🐊

2.4.0 思路分析

2.4.1 List.h

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

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

2.4.2 List.c

//尾删
void LTPopBack(ListNode* phead)
{
	//不能为空链表，只有一个哨兵位不能尾删
	assert(phead&&(phead->prev!=phead||phead->next!=phead));
	ListNode* del = phead->prev;//phead->prev就是尾节点
	//先处理del
	del->prev->next = phead;
	//再处理phead
	phead->prev = del->prev;
	free(del);
	del = NULL;
}

//头删
void LTPopFront(ListNode* phead)
{
	//不能为空链表，只有一个哨兵位不能头删
	assert(phead && (phead->prev != phead || phead->next != phead));
	ListNode* del = phead->next;
	del->next->prev = phead;
	phead->next = del->next;
	free(del);
	del = NULL;
}

2.4.3 test.c

#include"List.h"
void ListTest()
{
	ListNode* plist = LTInit();
	LTPushBack(plist, 1);
	LTPushBack(plist, 2);
	LTPushBack(plist, 3);
	LTPushBack(plist, 4);
	LTPrint(plist);//1 2 3 4 
	LTPushFront(plist, 5);
	LTPrint(plist);//5 1 2 3 4 
	LTPopBack(plist);
	LTPrint(plist);//5 1 2 3
	LTPopFront(plist);
	LTPrint(plist);//1 2 3
}
int main()
{
	ListTest();
	return 0;
}

2.4.4 代码测试运行

2.5 查找数据+pos节点后插入+删除pos节点🦩

2.5.0 思路分析

2.5.1 List.h

//查找数据
ListNode* LTFind(ListNode* phead, LTDataType x);

//pos节点之后插入
void LTPushAfter(ListNode* pos, LTDataType x);

//删除pos节点
void LTErase(ListNode* pos);

2.5.2 List.c

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

//pos节点之后插入
void LTPushAfter(ListNode* pos, LTDataType x)
{
	assert(pos);
	ListNode* node = ListBuyNode(x);
	//node
	node->next = pos->next;
	node->prev = pos;
	//pos
	pos->next = node;
	node->next->prev = node;
}

//删除pos节点
void LTErase(ListNode* pos)
{
	assert(pos);
	pos->prev->next = pos->next;
	pos->next->prev = pos->prev;
	free(pos);
	pos = NULL;
}

2.5.3 test.c

#include"List.h"
void ListTest()
{
	ListNode* plist = LTInit();
	LTPushBack(plist, 1);
	LTPushBack(plist, 2);
	LTPushBack(plist, 3);
	LTPushBack(plist, 4);
	LTPrint(plist);//1 2 3 4 
	LTPushFront(plist, 5);
	LTPrint(plist);//5 1 2 3 4 
	LTPopBack(plist);
	LTPrint(plist);//5 1 2 3
	LTPopFront(plist);
	LTPrint(plist);//1 2 3
	ListNode* find = LTFind(plist, 1);
	/*LTPushAfter(find, 4);*/	
	//LTPrint(plist);//1 4 2 3
	LTErase(find);
	LTPrint(plist);//2 3

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

2.5.4 代码测试运行

2.6 销毁☄️

2.6.0思路分析

1. 一级指针

2.6.1 List.h
//销毁
void LTDestroy(ListNode* phead);
2.6.2 List.c
//销毁
void LTDestroy(ListNode* phead)
{
	assert(phead);
	ListNode* cur = phead->next;
	while(cur!=phead)
	{
		ListNode* next = cur->next;
		free(cur);
		cur = next;
	}
	//注意哨兵位还没有释放
	free(phead);
	phead = NULL;
}
2.6.3 test.c
#include"List.h"
void ListTest()
{
	ListNode* plist = LTInit();
	LTPushBack(plist, 1);
	LTPushBack(plist, 2);
	LTPushBack(plist, 3);
	LTPushBack(plist, 4);
	LTPrint(plist);//1 2 3 4 
	//LTPushFront(plist, 5);
	//LTPrint(plist);//5 1 2 3 4 
	//LTPopBack(plist);
	//LTPrint(plist);//5 1 2 3
	//LTPopFront(plist);
	//LTPrint(plist);//1 2 3
	//ListNode* find = LTFind(plist, 1);
	/*LTPushAfter(find, 4);*/	
	LTPrint(plist);//1 4 2 3
	//LTErase(find);
	//LTPrint(plist);//2 3
	LTDestroy(plist);

}
int main()
{
	ListTest();
	return 0;
}
2.6.4 代码测试运行

2.6.5 一级指针的改进---test.c

2. 二级指针

2.6.1 List.h
//销毁
//void LTDestroy(ListNode* phead);
void LTDestroy(ListNode** phead);
2.6.2 List.c
//销毁
void LTDestroy(ListNode** phead)
{
	assert(phead && *phead);
	ListNode* cur = (*phead)->next;
	while (cur != *phead)
	{
		ListNode* next = cur->next;
		free(cur);
		cur = next;
	}
	free(*phead);
	*phead = NULL;
}
2.6.3 test.c
#include"List.h"
void ListTest()
{
	ListNode* plist = LTInit();
	LTPushBack(plist, 1);
	LTPushBack(plist, 2);
	LTPushBack(plist, 3);
	LTPushBack(plist, 4);
	LTPrint(plist);//1 2 3 4 
	//LTPushFront(plist, 5);
	//LTPrint(plist);//5 1 2 3 4 
	//LTPopBack(plist);
	//LTPrint(plist);//5 1 2 3
	//LTPopFront(plist);
	//LTPrint(plist);//1 2 3
	//ListNode* find = LTFind(plist, 1);
	///*LTPushAfter(find, 4);*/	
	LTPrint(plist);//1 4 2 3
	//LTErase(find);
	//LTPrint(plist);//2 3
	//LTDestroy(plist);
	//plist = NULL;
	LTDestroy(&plist);
}
int main()
{
	ListTest();
	return 0;
}
2.6.4 代码测试运行

2.7 完整代码💦

2.7.1 List.h

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

typedef int LTDataType;
//创建双向链表的结构体
typedef struct ListNode {
	LTDataType data;
	struct ListNode* prev;
	struct ListNode* next;
}ListNode;

//初始化
ListNode* LTInit();//不用传入参数，直接调用接口返回一个头节点

//在双向链表中不会改变哨兵位，所以这里都可以传一级指针
//尾插
void LTPushBack(ListNode* phead, LTDataType x);

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

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

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

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

//查找数据
ListNode* LTFind(ListNode* phead, LTDataType x);

//pos节点之后插入
void LTPushAfter(ListNode* pos, LTDataType x);

//删除pos节点
void LTErase(ListNode* pos);

//销毁
void LTDestroy(ListNode* phead);

2.7.2 List.c

#include"List.h"
//初始化
ListNode* LTInit()//不用传入参数，直接调用接口返回一个头节点
{
	//为头节点申请空间
	ListNode* phead = (ListNode*)malloc(sizeof(ListNode));
	//判断开辟是否成功
	if (phead == NULL)
	{
		perror("malloc error!\n");
		return;
	}
	//开辟成功--->初始化头节点
	phead->data = -1;//头节点不存储有效数据，可以任意赋值
	//只有哨兵位的时候，要实现双向链表，不能指向NULL，否则无法双向循环，所以我们指向自己
	phead->prev = phead->next = phead;
	return phead;
}

//在双向链表中不会改变哨兵位，所以这里都可以传一级指针
// 只改变数据，不改变地址

//开辟空间
ListNode* ListBuyNode(LTDataType x)
{
	ListNode* node = (ListNode*)malloc(sizeof(ListNode));
	if (node == NULL)
	{
		perror("malloc error!\n");
		return;
	}
	node->data = x;
	node->next = node->prev = NULL;
	return node;
}

//尾插
void LTPushBack(ListNode* phead, LTDataType x)
{
	assert(phead);//注意哨兵位不能为空
	//申请空间
	ListNode* node = ListBuyNode(x);
	//先处理node的前驱指针和后继指针
	node->prev = phead->prev;
	node->next = phead;
	//再处理之前的尾节点和phead
	phead->prev->next = node;
	phead->prev = node;
}

//打印
void LTPrint(ListNode* phead)
{
	//哨兵位不能改变
	ListNode* cur = phead->next;
	while (cur != phead)//当cur再次指向phead的时候，循环结束
	{
		printf("%d->", cur->data);
		cur = cur->next;
	}
	printf("\n");
}

//头插
void LTPushFront(ListNode* phead, LTDataType x)
{
	assert(phead);//注意哨兵位不能为空
	//申请空间
	ListNode* node = ListBuyNode(x);
	//node插入头节点之后才算头插
	//先处理node的前驱指针和后继指针
	node->prev = phead;
	node->next = phead->next;
	//再处理phead和phead->next
	phead->next->prev = node;
	phead->next = node;
}

//尾删
void LTPopBack(ListNode* phead)
{
	//不能为空链表，只有一个哨兵位不能尾删
	assert(phead&&(phead->prev!=phead||phead->next!=phead));
	ListNode* del = phead->prev;//phead->prev就是尾节点
	//先处理del
	del->prev->next = phead;
	//再处理phead
	phead->prev = del->prev;
	free(del);
	del = NULL;
}

//头删
void LTPopFront(ListNode* phead)
{
	//不能为空链表，只有一个哨兵位不能头删
	assert(phead && (phead->prev != phead || phead->next != phead));
	ListNode* del = phead->next;
	del->next->prev = phead;
	phead->next = del->next;
	free(del);
	del = NULL;
}

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

//pos节点之后插入
void LTPushAfter(ListNode* pos, LTDataType x)
{
	assert(pos);
	ListNode* node = ListBuyNode(x);
	//node
	node->next = pos->next;
	node->prev = pos;
	//pos
	pos->next = node;
	node->next->prev = node;
}

//删除pos节点
void LTErase(ListNode* pos)
{
	assert(pos);
	pos->prev->next = pos->next;
	pos->next->prev = pos->prev;
	free(pos);
	pos = NULL;
}

//销毁
void LTDestroy(ListNode* phead)
{
	assert(phead);
	ListNode* cur = phead->next;
	while(cur!=phead)
	{
		ListNode* next = cur->next;
		free(cur);
		cur = next;
	}
	//注意哨兵位还没有释放
	free(phead);
	phead = NULL;
}

2.7.3 test.c

#include"List.h"
void ListTest()
{
	ListNode* plist = LTInit();
	LTPushBack(plist, 1);
	LTPushBack(plist, 2);
	LTPushBack(plist, 3);
	LTPushBack(plist, 4);
	LTPrint(plist);//1 2 3 4 
	LTPushFront(plist, 5);
	LTPrint(plist);//5 1 2 3 4 
	LTPopBack(plist);
	LTPrint(plist);//5 1 2 3
	LTPopFront(plist);
	LTPrint(plist);//1 2 3
	ListNode* find = LTFind(plist, 1);
	/*LTPushAfter(find, 4);*/	
	//LTPrint(plist);//1 4 2 3
	LTErase(find);
	LTPrint(plist);//2 3
	LTDestroy(plist);
	plist = NULL;
}
int main()
{
	ListTest();
	return 0;
}

3. 顺序表和双向链表的分析🍻

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

本次的分享到这里就结束了！！！

PS：小江目前只是个新手小白。欢迎大家在评论区讨论哦！有问题也可以讨论的！

如果对你有帮助的话，记得点赞👍+收藏⭐️+关注➕

举报

相关推荐

将“左移”方法更进一步：“一开始就左移”

开发人员思维方式代码质量软件研发

做好它，你的服务离“毛遂自荐”更进一步

自定义开发者前端开发

数据结构前导课 | 7 更进一步——STL库之List链表

链表c++数据Linux系统/运维

百尺竿头更进一步：最高排名16

生活JavaScript前端开发

小小Tips：更进一步“突破浏览器12px限制”

htmlsvgcssfont-familychrome

百尺竿头，更进一步——如何最后一步再提升一下模型的精度？

pytorch深度学习python

多御安全浏览器锁屏功能正式上线，保护隐私更进一步

锁屏安全浏览器新版本IT业界

双案入选！博云助力金融信创，百尺竿头，更进一步！

云原生kubernetesK8S管理devops平台金融信创Html/CSS前端开发

进一步走近HDFS

hdfshadoop大数据

模板进一步探究

c++
0 条评论