数据结构学习之路--实现带头双向循环链表的详解(附C源码)

   嗨嗨大家~本期带来的内容是：带头双向循环链表的实现。在上期文章中我们提到过带头双向循环链表，那么它的实现又是怎样的呢？今天我们来一探究竟！

目录

前言 

一、认识带头双向循环链表

1 认识双向链表 

2 带头双向循环链表的定义

二、带头双向循环链表的实现 

2.1 定义

2.2 创建结点 

2.3 初始化 

方法一： 

方法二：

2.4 链表的判空

2.5 链表的尾插 

2.6 链表的头插 

方法一： 

方法二：

2.7 链表的尾删 

2.8 链表的头删 

2.9 在pos位置之前插入 

2.10  删除pos位置的结点

2.11 链表的长度

2.12 链表的打印

2.13 链表的销毁

三、总代码 

前言 

   我们在上期内容中讲过，链表结构是多样化的。但在实际中最常用的只有两种：无头单向非循环链表和带头双向循环链表。前者已经在上篇博客（http://t.csdnimg.cn/s8ieT）进行了全面的讲解，现在我们来认识并实现后者。

一、认识带头双向循环链表

1 认识双向链表 

   单链表虽然能够实现从任一结点出发沿着链能找到其前驱结点，但时间耗费是O(n)。如果希望从表中快速确定某一个结点的前驱，另一个解决方法就是在单链表的每个结点里再增加一个指向其前驱的指针域prev。这样形成的链表中就有两条方向不同的链，称之为双(向)链表。

   与单链表类似，双向链表也可增加头结点使双向链表的某些运算变得方便。同时双向链表也可以有循环表，称为双向循环链表。 由于在双向链表中既有前向链又有后向链，所以寻找任一结点的直接前驱结点与直接后继结点都变得非常便捷。

2 带头双向循环链表的定义

   带头双向循环链表：结构最复杂，一般用于单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势，实现反而简单了。

二、带头双向循环链表的实现 

2.1 定义

代码实现：

//定义
typedef int LTDataType;
 
typedef struct ListNode
{
	struct ListNode* next;
	struct ListNode* prev;
	LTDataType data;
}LTNode;

分析：这里与单链表的定义不同，带头双向循环链表要定义两个指针：前驱指针prev和后继指针next。前驱指针prev用于指向当前结点的上一个结点，后继指针next用于指向当前结点的下一个结点。 

2.2 创建结点 

代码实现：

//创建结点
LTNode* BuyListNode(LTDataType x)
{
	//动态开辟一个结点node
	LTNode* node = (LTNode*)malloc(sizeof(LTNode));
 
	//判空
	if (node == NULL)
	{
		perror("malloc fail!");
		exit(-1);
	}
 
	//前驱与后继结点均置为空
	node->data = x;
	node->next = NULL;
	node->prev = NULL;
 
	return node;
}

分析：结点的创建主要是通过调用malloc函数来实现，初始化时要将前驱指针和后继指针都置为NULL。 

2.3 初始化 

  • 带头双向循环链表的初始化可以使用两种方法：传二级指针和设置返回值。

方法一： 

代码实现：

//初始化
void ListInit(LTNode** phead)
{
	//这里需要传入二级指针，即传地址，才能实现对链表的修改
 
	//判空
	assert(phead);
	
	//创建头结点
	*phead = BuyListNode(-1);
 
	//因为是带头双向链表，故将头结点的前驱指针和后继指针均指向它们自己
	(*phead)->next = *phead;
	(*phead)->prev = *phead;
}

方法二：

代码实现：

初始化
LTNode* ListInit()
{
	//创建头结点
	LTNode* phead = BuyListNode(-1);
 
	//因为是带头循环双向链表，故将头结点的前驱指针和后继指针均指向它们自己
	phead->next = phead;
	phead->prev = phead;
 
	//返回头结点
	return phead;
}

注意：

  • 若想要改变头指针，就要传二级指针；不需要改变头指针的话，便传入一级指针。
  • 在使用带头结点的单链表时：
  1. 初始化链表头指针需要传二级指针；
  2. 销毁链表需要传二级指针；
  3. 插入、删除、遍历、清空结点用一级指针即可。
  • 不带头结点的单链表，除了初始化和销毁，插入、删除和清空结点也需要二级指针。 

2.4 链表的判空

代码实现：

bool ListEmpty(LTNode* phead)
{
	//判空
	assert(phead);
 
	//如果phead->next等于phead，则链表为空，返回true
	//如果phead->next不等于phead，则链表不为空，返回false
	return phead->next == phead;
}

分析：若phead->next等于phead，则链表为空，返回true；若phead->next不等于phead，则链表不为空，返回false。 

2.5 链表的尾插 

代码实现：

//尾插
void ListPushBack(LTNode* phead, LTDataType x)
{
	//判空
	assert(phead);
 
	//创建新结点
	LTNode* newnode = BuyListNode(x);
 
	//查找尾结点
	LTNode* tail = phead->prev;
 
	//原尾和新尾相互链接
	tail->next = newnode;
	newnode->prev = tail;
	//头结点和新尾相互链接
	newnode->next = phead;
	phead->prev = newnode;
}

分析：与单链表的尾插相比，带头双向循环链表的尾插不需要从头结点开始依次向后遍历，因为头结点的前驱结点便指向尾结点tail。在找到尾结点tail之后，便可将新结点newnode插入到尾结点tail的后面。此时newnode变为新的尾结点。 

2.6 链表的头插 

  • 带头双向循环链表的头插有两种方式实现。

方法一： 

代码实现：

//头插
void ListPushFront(LTNode* phead, LTDataType x)
{
	//判空
	assert(phead);

	//创建新结点
	LTNode* newnode = BuyListNode(x);

	//phead newnode next：三者不分先后顺序
	LTNode* next = phead->next;
	phead->next = newnode;
	newnode->prev = phead;
	newnode->next = next;
	next->prev = newnode;
}

方法二：

代码实现：

//头插
void ListPushFront(LTNode* phead, LTDataType x)
{
	//判空
	assert(phead);
	//创建新结点
	LTNode* newnode = BuyListNode(x);
	
    //phead newnode phead->next：先处理后两个，再处理前两个
	phead->next->prev = newnode;
	newnode->next = phead->next;
	phead->next = newnode;
	newnode->prev = phead;
}

分析：当进行头插时，要注意结点之间插入的先后顺序，这里主要介绍两种方式：

  • 方式一：创建一个临时变量next，然后将头结点的下一个结点保存在next当中。首先调用BuyListNode(x)创建一个新结点newnode，然后将phead，newnode和next三个结点进行链接。三个结点不分先后顺序，直接进行链接即可。该方式最为简单，也最不容易出错；
  • 方式二：不创建临时变量next。首先调用BuyListNode(x)创建一个新结点newnode，然后将phead，newnode和phead->next三个结点进行链接。链接是关键：要先将后两个结点进行链接，然后再将前两个结点进行链接。三个结点一定要注意先后顺序，不可随意链接。 

2.7 链表的尾删 

代码实现：

//尾删
void ListPopBack(LTNode* phead)
{
	//判空
	assert(phead);
 
	//判断链表是否为空
	assert(phead->next != phead);
	//assert(!ListEmpty(phead));
 
	//找尾结点
	LTNode* tail = phead->prev;
 
	//找尾结点的前一结点
	LTNode* tailPrev = tail->prev;
 
	//释放尾结点
	free(tail);
 
	tailPrev->next = phead;
	phead->prev = tailPrev;
}

分析： 在进行尾删之前，首先要判断链表是否为空，可以通过phead->next != phead进行判断，也可以调用ListEmpty(phead)函数进行判断；然后找到链表的尾结点tail，以及链表尾结点的前一个结点tailPrev；接着调用free函数释放尾结点tail，并将tailPrev作为新的尾结点；最后再将新的尾结点与头结点phead进行相连即可。

2.8 链表的头删 

代码实现：

//头删
void ListPopFront(LTNode* phead)
{
	//判空
	assert(phead);
 
	//判断链表是否为空
	assert(phead->next != phead);
	//assert(!ListEmpty(phead));
 
	//tail记录第一个结点之后的下一个结点
	LTNode* tail = phead->next->next;
	
	//释放第一个结点
	free(phead->next);
 
	//将头结点和tail相链接
	phead->next = tail;
	tail->prev = phead;
}

分析：在进行头删之前，首先要判断链表是否为空，可以通过phead->next != phead进行判断，也可以调用ListEmpty(phead)函数进行判断；然后找到链表的第二个有效结点tail；接着调用free函数释放掉第一个有效结点，并将tail作为新的第一个有效结点；最后再将新的第一个结点tail与头结点phead进行相连即可。 

2.9 在pos位置之前插入 

代码实现：

//在pos前插入结点
void ListInsert(LTNode* pos, LTDataType x)
{
	//判空
	assert(pos);
 
	//查找pos的前一个结点
	LTNode* prev = pos->prev;
 
	//创建新结点
	LTNode* newnode = BuyListNode(x);
 
	//prev newnode pos
	prev->next = newnode;
	newnode->prev = prev;
	newnode->next = pos;
	pos->prev = newnode;
}

分析：给定一个结点pos，如果是带头双向循环链表，那么pos之前的结点和pos之后的结点都是可知的。要在pos位置之前插入，首先要找到pos的前一结点prev，然后调用BuyListNode(x)创建一个新结点newnode，接着将prev，newnode和pos三个结点进行链接即可。此时pos位置的结点将由pos变为newnode。 

2.10  删除pos位置的结点

代码实现：

//删除pos位置的结点
void ListErase(LTNode* pos)
{
	//判空
	assert(pos);
 
	//查找pos的前一个结点
	LTNode* prev = pos->prev;
	
	//查找pos的后一个结点
	LTNode* next = pos->next;
 
	//将前一个结点pre与后一个结点next相链接
	prev->next = next;
	next->prev = prev;
 
	//释放pos结点
	free(pos);
}

分析：在删除pos位置的结点之前，首先要找到pos位置的前一个结点prev，然后找到pos位置的后一个结点next，接着将结点prev与next相链接，最后再调用free函数释放掉pos结点即可。 

2.11 链表的长度

 代码实现：

//求链表长度（结点个数）
int ListSize(LTNode* phead)
{
	//判空
	assert(phead);
 
	//cur指向当前链表的第一个结点
	LTNode* cur = phead->next;
	
	//用于记录遍历过的结点数
	int size = 0;
 
	//从第一个结点开始依次向后遍历，直到遍历到头结点
	while (cur != phead)
	{
		++size;
		cur = cur->next;
	}
	return size;
}

2.12 链表的打印

代码实现：

//打印
void ListPrint(LTNode* phead)
{
	//判空
	assert(phead);
 
	//cur指向链表的第一个结点
	LTNode* cur = phead->next;
 
	//cur依次向后遍历，直到cur重新回到头结点
	while (cur != phead)
	{
		printf("%d ", cur->data);
		cur = cur->next;
	}
	printf("\n");
}

分析：设置一个临时变量cur，指向当前链表的第一个结点(非头结点)，然后依次向后遍历该链表，直到cur重新回到头结点phead的位置。 

2.13 链表的销毁

代码实现：

//销毁
void ListDestory(LTNode* phead)
{
	//判空
	assert(phead);
 
	//cur指向当前第一个结点
	LTNode* cur = phead->next;
 
	while (cur != phead)
	{
		//保存cur的下一个结点
		LTNode* next = cur->next;
 
		//删除cur
		ListErase(cur);
 
		//更新cur
		cur = next;
	}
 
	//释放头结点
	free(phead);
}

总结：可以在该链表的任意位置插入和删除（但不能删除head），也无需考虑特殊情况进行单独判断。 

三、总代码 

List.h

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>
 
//带头双向循环链表
 
//定义
typedef int LTDataType;
 
typedef struct ListNode
{
	struct ListNode* next;
	struct ListNode* prev;
	LTDataType data;
}LTNode;
 
//创建结点
LTNode* BuyListNode(LTDataType x);
 
//初始化：方法一
//void ListInit(LTNode** phead);
 
//初始化：方法二
LTNode* ListInit();
 
//判空
bool ListEmpty(LTNode* phead);
 
//尾插
//不用二级指针的原因：尾插时不会改变phead，因为它带哨兵位，尾插时不会对哨兵位进行修改
void ListPushBack(LTNode* phead, LTDataType x);
 
//头插
void ListPushFront(LTNode* phead, LTDataType x);
 
//尾删
void ListPopBack(LTNode* phead);
 
//头删
void ListPopFront(LTNode* phead);
 
//在pos位置之前插入
void ListInsert(LTNode* pos, LTDataType x);
 
//删除pos位置的结点
void ListErase(LTNode* pos);
 
//链表长度
int ListSize(LTNode* phead);

//打印
void ListPrint(LTNode* phead);
 
//销毁
void ListDestory(LTNode* phead);
List.c

#include"List.h"

​//创建结点
LTNode* BuyListNode(LTDataType x)
{
	//动态开辟一个结点node
	LTNode* node = (LTNode*)malloc(sizeof(LTNode));
 
	//判空
	if (node == NULL)
	{
		perror("malloc fail!");
		exit(-1);
	}
 
	//前驱与后继结点均置为空
	node->data = x;
	node->next = NULL;
	node->prev = NULL;
 
	return node;
}
​​//初始化
void ListInit(LTNode** phead)
{
	//这里需要传入二级指针，即传地址，才能实现对链表的修改
 
	//判空
	assert(phead);
	
	//创建头结点
	*phead = BuyListNode(-1);
 
	//因为是带头双向链表，故将头结点的前驱指针和后继指针均指向它们自己
	(*phead)->next = *phead;
	(*phead)->prev = *phead;
}

​​/*
//初始化
LTNode* ListInit()
{
	//创建头结点
	LTNode* phead = BuyListNode(-1);
 
	//因为是带头循环双向链表，故将头结点的前驱指针和后继指针均指向它们自己
	phead->next = phead;
	phead->prev = phead;
 
	//返回头结点
	return phead;
}
*/

//判空
​​bool ListEmpty(LTNode* phead)
{
	assert(phead);
 
	//如果phead->next等于phead，则链表为空，返回true
	//如果phead->next不等于phead，则链表不为空，返回false
	return phead->next == phead;
}
//尾插
​​void ListPushBack(LTNode* phead, LTDataType x)
{
	//判空
	assert(phead);
 
	//创建新结点
	LTNode* newnode = BuyListNode(x);
 
	//查找尾结点
	LTNode* tail = phead->prev;
 
	//原尾和新尾相互链接
	tail->next = newnode;
	newnode->prev = tail;
	//头结点和新尾相互链接
	newnode->next = phead;
	phead->prev = newnode;
}
​//头插
void ListPushFront(LTNode* phead, LTDataType x)
{
	//判空
	assert(phead);

	//创建新结点
	LTNode* newnode = BuyListNode(x);

	//phead newnode next：三者不分先后顺序
	LTNode* next = phead->next;
	phead->next = newnode;
	newnode->prev = phead;
	newnode->next = next;
	next->prev = newnode;
}
​​//头插
void ListPushFront(LTNode* phead, LTDataType x)
{
	//判空
	assert(phead);
	//创建新结点
	LTNode* newnode = BuyListNode(x);
	
    //phead newnode phead->next：先处理后两个，再处理前两个
	phead->next->prev = newnode;
	newnode->next = phead->next;
	phead->next = newnode;
	newnode->prev = phead;
}
​​//尾删
void ListPopBack(LTNode* phead)
{
	//判空
	assert(phead);
 
	//判断链表是否为空
	assert(phead->next != phead);
	//assert(!ListEmpty(phead));
 
	//找尾结点
	LTNode* tail = phead->prev;
 
	//找尾结点的前一结点
	LTNode* tailPrev = tail->prev;
 
	//释放尾结点
	free(tail);
 
	tailPrev->next = phead;
	phead->prev = tailPrev;
}
​​//头删
void ListPopFront(LTNode* phead)
{
	//判空
	assert(phead);
 
	//判断链表是否为空
	assert(phead->next != phead);
	//assert(!ListEmpty(phead));
 
	//tail记录第一个结点之后的下一个结点
	LTNode* tail = phead->next->next;
	
	//释放第一个结点
	free(phead->next);
 
	//将头结点和tail相链接
	phead->next = tail;
	tail->prev = phead;
}
​​//在pos前插入
void ListInsert(LTNode* pos, LTDataType x)
{
	//判空
	assert(pos);
 
	//查找pos的前一个结点
	LTNode* prev = pos->prev;
 
	//创建新结点
	LTNode* newnode = BuyListNode(x);
 
	//prev newnode pos
	prev->next = newnode;
	newnode->prev = prev;
	newnode->next = pos;
	pos->prev = newnode;
}
​​//删除pos位置的结点
void ListErase(LTNode* pos)
{
	//判空
	assert(pos);
 
	//查找pos的前一个结点
	LTNode* prev = pos->prev;
	
	//查找pos的后一个结点
	LTNode* next = pos->next;
 
	//将前一个结点pre与后一个结点next相链接
	prev->next = next;
	next->prev = prev;
 
	//释放pos结点
	free(pos);
}
​​//求链表长度（结点个数）
int ListSize(LTNode* phead)
{
	//判空
	assert(phead);
 
	//cur指向当前链表的第一个结点
	LTNode* cur = phead->next;
	
	//用于记录遍历过的结点数
	int size = 0;
 
	//从第一个结点开始依次向后遍历，直到遍历到头结点
	while (cur != phead)
	{
		++size;
		cur = cur->next;
	}
	return size;
}
​​
//销毁
void ListDestory(LTNode* phead)
{
	//判空
	assert(phead);
 
	//cur指向当前第一个结点
	LTNode* cur = phead->next;
 
	while (cur != phead)
	{
		//保存cur的下一个结点
		LTNode* next = cur->next;
 
		//删除cur
		ListErase(cur);
 
		//更新cur
		cur = next;
	}
 
	//释放头结点
	free(phead);
}

​
test.c
 
#include"List.h"
 
void Test()
{
	LTNode* plist = NULL;
 
	//初始化
	plist = ListInit();
 
	//头插
	ListPushFront(plist, 1);
	ListPushFront(plist, 2);
	ListPushFront(plist, 3);
	ListPushFront(plist, 4);
	ListPushFront(plist, 5);
	ListPrint(plist);
 
	ListDestory(plist);
	ListPrint(plist);
}
 
int main()
{
	Test();
 
	return 0;
}

   大家学到这里，链表的知识分享已经接近尾声，综合本期文章以及前两篇博客来看，其实不难发现，对于任何一个数据结构，基本操作大致上都能归纳为创建销毁，增删改查。其中改建立在查的基础上。

   那么本期的内容就告一段落，有关于链表的总结也已经结束，此时的你是否对链表有了更深层次的了解和掌握呢？如果大家觉得这篇文章对你们有所帮助，记得给博主留下三连支持哈~你们的支持是我创作的最大动力！博主也会继续竭尽所能地为大家带来更加优质的内容，当然啦，或许我存在许多不足之处，欢迎各位佬们的指点！请相信相信的力量，一切也终有回甘！诸君加油~我们下期再会啦。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/549766.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

【精读文献】Scientific data|2017-2021年中国10米玉米农田变化制图

【精读文献】Scientific data|2017-2021年中国10米玉米农田变化制图

论文名称&#xff1a;Mapping annual 10-m maize cropland changes in China during 2017–2021 第一作者及通讯作者&#xff1a;Xingang Li, Ying Qu 第一作者单位及通讯作者单位&#xff1a;北京师范大学地理学部 文章发表期刊&#xff1a;《Scientific data》&#xff08…
阅读更多...
如何在 VM 虚拟机中安装 OpenEuler 操作系统保姆级教程（附链接）

如何在 VM 虚拟机中安装 OpenEuler 操作系统保姆级教程（附链接）

一、VMware Workstation 虚拟机 若没有安装虚拟机的可以参考下篇文章进行安装&#xff1a; 博客链接https://eclecticism.blog.csdn.net/article/details/135713915 二、OpenEuler 镜像 点击链接前往官网 官网 选择第一个即可 三、安装 OpenEuler 打开虚拟机安装 Ctrl …
阅读更多...
【C++】哈希一

【C++】哈希一

这篇博客要说的是哈希算法&#xff0c;哈希又称为散列&#xff0c;它是将存储的值和存储的位置建立起关联关系的一种算法&#xff0c;或者说是一种将任意长度的数据映射为固定长度的输出的算法。 什么意思呢&#xff1f;我们来看一个例子&#xff1a;比如说我们要存储1&#xf…
阅读更多...
控制某个对象缩放

控制某个对象缩放

效果如下&#xff1a; 您只需要控制此对象进行激活&#xff0c;将对象设置为&#xff1a;gameObject.SetActive(true);即可实现此次效果 代码如下&#xff1a; public class StartShowRun : MonoBehaviour {Transform _localTransfrom;Vector3 _localScale;public AnimationC…
阅读更多...
高效可扩展，使用Dask进行大数据分析

高效可扩展，使用Dask进行大数据分析

大家好&#xff0c;Dask技术作为并行计算领域的创新力量&#xff0c;正在重塑大数据的处理模式。这项开源项目为Python语言带来了强大的并行计算能力&#xff0c;突破了传统数据处理在扩展性和性能上的瓶颈。 本文将介绍Dask的发展历程、架构设计&#xff0c;并分析其在大数据…
阅读更多...
Qt中连接mysql

Qt中连接mysql

1、安装mysql&#xff0c;workbench&#xff0c;为mysql添加环境变量 2、安装Qt带src&#xff0c;然后到如下目录&#xff0c;找到mysql.pro(建议做个副本先) http://D:\Qt\Qt5.13.2\5.13.2\Src\qtbase\src\plugins\sqldrivers\mysql mysql.pro 注意路径的 \ / 和双引号的使…
阅读更多...
算法练习第15天|226.翻转二叉树

算法练习第15天|226.翻转二叉树

226.翻转二叉树 力扣链接https://leetcode.cn/problems/invert-binary-tree/description/ 题目描述&#xff1a; 给你一棵二叉树的根节点 root &#xff0c;翻转这棵二叉树&#xff0c;并返回其根节点。 示例 1&#xff1a; 输入&#xff1a;root [4,2,7,1,3,6,9] 输出&am…
阅读更多...
高分二号卫星（GF-2）：中国遥感科技的新高度

高分二号卫星（GF-2）：中国遥感科技的新高度

​高分二号卫星&#xff08;GF-2&#xff09;是中国在高分辨率地球观测领域的重要成就&#xff0c;其引入了先进的成像技术和灵活的数据获取模式&#xff0c;为地球资源监测、环境保护、城市规划等领域提供了强大的数据支持。本文将深入介绍高分二号卫星的技术特点、成像能力以…
阅读更多...
软件测试---性能测试

软件测试---性能测试

1.常见的性能问题有哪些 如图所示 系统内部以及软件的代码实现 1&#xff0c;资源泄漏&#xff0c;包括内存泄漏。 2&#xff0c;CPU使用率达到100%&#xff0c;系统被锁定等。 3&#xff0c;线程死锁&#xff0c;阻塞等造成系统越来越慢。 4&#xff0c;查询速度慢&#xff0c…
阅读更多...
Console口和Telnet功能配置实验

Console口和Telnet功能配置实验

一、基础配置 <Huawei>system-view //进入系统视图 Enter system view, return user view with CtrlZ. [Huawei]undo info-center enable //关闭接口提示 Info: Information center is disabled. [Huawei]sysname AR1 //配置设备名为 R1 [AR1]interface GigabitEthern…
阅读更多...
pta L1-027 出租

pta L1-027 出租

L1-027 出租 分数 20 全屏浏览 切换布局 作者 陈越 单位 浙江大学 下面是新浪微博上曾经很火的一张图&#xff1a; 一时间网上一片求救声&#xff0c;急问这个怎么破。其实这段代码很简单&#xff0c;index数组就是arr数组的下标&#xff0c;index[0]2 对应 arr[2]1&#x…
阅读更多...
steam怎么退款？steam退款教程？简单几步即可轻松实现退款

steam怎么退款？steam退款教程？简单几步即可轻松实现退款

steam怎么退款&#xff1f;steam退款教程&#xff1f;简单几步即可轻松实现退款 说到steam平台大家肯定不会陌生&#xff0c;随着现代的发展&#xff0c;在steam上进行购买游戏已经成了很普遍的东西&#xff0c;但是许多玩家在购买游戏试完之后发现游戏并不符合自己的胃口&…
阅读更多...
transformer上手（9）—— 翻译任务

transformer上手（9）—— 翻译任务

运用 Transformers 库来完成翻译任务。翻译是典型的序列到序列 (sequence-to-sequence, Seq2Seq) 任务&#xff0c;即对于每一个输入序列都会输出一个对应的序列。翻译在任务形式上与许多其他任务很接近&#xff0c;例如&#xff1a; 文本摘要 (Summarization)&#xff1a;将长…
阅读更多...
地质灾害监测预警系统：科技守护，构筑智能预警屏障

地质灾害监测预警系统：科技守护，构筑智能预警屏障

随着全球气候变化和人为活动的加剧&#xff0c;地质灾害频繁发生&#xff0c;给人们的生命财产安全带来了严重威胁。为了降低地质灾害带来的损失&#xff0c;地质灾害监测预警系统应运而生。本文将为您详细介绍地质灾害监测预警系统的原理、功能以及在实际应用中的效果。 一、地…
阅读更多...
【考研数学】全年各阶段用书汇总+资料分享

【考研数学】全年各阶段用书汇总+资料分享

我一战备考很迷茫&#xff0c;身边室友也都是&#xff0c;和室友一起去买资料&#xff0c;网上推荐的看到了就都买了 大家都不知道怎么样才能选对数学参考书然后快速进入备考状态&#xff0c;最后犹犹豫豫买了一堆资料都没有正式开始备考... 从小都算是身边人口中“偏科&…
阅读更多...
L2-3 完全二叉树的层序遍历

L2-3 完全二叉树的层序遍历

完全二叉树的层序遍历 一个二叉树&#xff0c;如果每一个层的结点数都达到最大值&#xff0c;则这个二叉树就是完美二叉树。对于深度为 D 的&#xff0c;有 N 个结点的二叉树&#xff0c;若其结点对应于相同深度完美二叉树的层序遍历的前 N 个结点&#xff0c;这样的树就是完全…
阅读更多...
箭头函数有哪些不适用场景

箭头函数有哪些不适用场景

&#x1f90d; 前端开发工程师、技术日更博主、已过CET6 &#x1f368; 阿珊和她的猫_CSDN博客专家、23年度博客之星前端领域TOP1 &#x1f560; 牛客高级专题作者、打造专栏《前端面试必备》 、《2024面试高频手撕题》 &#x1f35a; 蓝桥云课签约作者、上架课程《Vue.js 和 E…
阅读更多...
预分频器×重装载值)/LSI频率 为什么等于总时间

预分频器×重装载值)/LSI频率 为什么等于总时间

1. 第一种算法理解&#xff1a;分频系数 64 &#xff0c;外部低速时钟40khz&#xff0c; 则一次计数周期1.6ms &#xff0c;计数625个数&#xff0c;则有625个周期 &#xff0c;1.6ms*625 等于1s 如果分频系数是64&#xff0c;外部低速时钟&#xff08;LSI&#xff09;频率是…
阅读更多...
动态规划|416.分割等和子集

动态规划|416.分割等和子集

力扣题目链接 class Solution { public:bool canPartition(vector<int>& nums) {int sum 0;// dp[i]中的i表示背包内总和// 题目中说&#xff1a;每个数组中的元素不会超过 100&#xff0c;数组的大小不会超过 200// 总和不会大于20000&#xff0c;背包最大只需要其…
阅读更多...
STM32标准库+HAL库 | CPU片内FLASH存储器数据掉电读写

STM32标准库+HAL库 | CPU片内FLASH存储器数据掉电读写

一、片内FLASH 在STM32芯片内部有一个FLASH存储器&#xff0c;它主要用于存储代码&#xff0c;我们在电脑上编写好应用程序后&#xff0c;使用下载器把编译后的代码文件烧录到该内部FLASH中&#xff0c; 由于FLASH存储器的内容在掉电后不会丢失&#xff0c;芯片重新上电复位后&…
阅读更多...
最新文章

Copyright @ 2022~2023