【数据结构初阶】---堆的实现、堆排序以及文件中的TopK问题

1.树的概念及结构

1.1树的概念

树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。
有一个特殊的结点，称为根结点，根结点没有前驱结点，除根结点外，其余结点被分成M(M>0)个互不相交的集合T1、T2、……、Tm，其中每一个集合Ti(1<= i <= m)又是一棵结构与树类似的子树。每棵子树的根结点有且只有一个前驱，可以有0个或多个后继
结构图：在这里插入图片描述
注意：树形结构中，子树之间不能有交集，否则就不是树形结构
在这里插入图片描述

1.2树的相关概念

在这里插入图片描述
1.结点的度：一个结点含有的子树的个数称为该结点的度； 如上图：A的为6
2.叶结点或终端结点：度为0的结点称为叶结点； 如上图：B、C、H、I…等结点为叶结点
3.非终端结点或分支结点：度不为0的结点； 如上图：D、E、F、G…等结点为分支结点
4.双亲结点或父结点：若一个结点含有子结点，则这个结点称为其子结点的父结点； 如上图：A是B的父结点
5.孩子结点或子结点： 一个结点含有的子树的根结点称为该结点的子结点； 如上图：B是A的孩子结点
6.兄弟结点：具有相同父结点的结点互称为兄弟结点； 如上图：B、C是兄弟结点
7.树的度：一棵树中，最大的结点的度称为树的度； 如上图：树的度为6
8.结点的层次：从根开始定义起，根为第1层，根的子结点为第2层，以此类推；
9.树的高度或深度：树中结点的最大层次； 如上图：树的高度为4
10.堂兄弟结点：双亲在同一层的结点互为堂兄弟；如上图：H、I互为兄弟结点
11.结点的祖先：从根到该结点所经分支上的所有结点；如上图：A是所有结点的祖先
12.孩子结点或子结点：以某结点为根的子树中任一结点都称为该结点的子孙。如上图：所有结点都是A的子孙
13.森林：由m（m>0）棵互不相交的树的集合称为森林；

2.二叉树的概念及结构

2.1二叉树的概念

与树不同，二叉树根结点的子节点有且不超过两个。
在这里插入图片描述
以下几个都是二叉树：
在这里插入图片描述

2.2特殊的二叉树

满二叉树：一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树。也就是说，如果一个二叉树的层数为K，且结点总数是 ，则它就是满二叉树。
完全二叉树：完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树而引出来的。对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树。要注意的是满二叉树是一种特殊的完全二叉树。
在这里插入图片描述
##2.3 二叉树的性质

  1. 若规定根结点的层数为h，则一棵非空二叉树的第h层上最多有2^(h-1)个结点
  2. 若规定根结点的层数为h，则深度为h的二叉树的最大结点数是 2^h-1
  3. 对任何一棵二叉树, 如果度为0其叶结点个数为n1, 度为2的分支结点个数为n2,则有n1=n2+1
  4. 假设在顺序表中父亲节点parent的下标是i，则孩子节点child的下标分别是i * 2 + 1和i * 2 + 2，分别对应左右孩子
  5. 假设在顺序表中孩子节点child的下标是i,不管其是左孩子还是有孩子，其父亲节点的下标都是(i - 1) / 2

2.4二叉树的存储形式

二叉树分为完全二叉树和不完全二叉树，对于完全二叉树，我们可以采用顺序表进行存储，对于不完全二叉树我们则需采用链式存储
在这里插入图片描述

3.堆的顺序结构及实现

3.1堆的概念

堆是一种特别的完全二叉树，堆分为大堆和小堆。
对于大堆，堆中任意某个节点的值总是大于其子节点的值。
对于小堆，堆中任意某个节点的值总是小于其父节点的值。
在这里插入图片描述

3.2堆的实现

堆结构的定义

对于堆我们是采用顺序表进行存储，因此定义了一个指向数组的指针a和存储数据个数和申请的空间大小的两个变量。

typedef int HPDataType;

typedef struct Heap
{
	HPDataType* a;
	int size;//数据个数
	int capacity;//空间大小
}HP;

堆的初始化

堆的初始化就是顺序表的初始化，我们先不申请空间，后续插入数据的时候我们再申请。

//堆的初始化
void HPInit(HP* php)
{
	php->a = NULL;
	php->size = php->capacity = 0;
}

堆的插入

我们先判断空间是否足够，当前空间大小为0的话申请4个字节大小的空间，不为空的话就进行扩容两倍。

//堆的插入
void HPPush(HP* php, HPDataType x)
{
	assert(php);
	//判断空间是否足够
	if (php->size == php->capacity)
	{
		HPDataType newCapacity = php->capacity == 0 ? 4 : 2 * php->capacity;
		HPDataType* tmp = (HPDataType*)realloc(php->a,sizeof(HPDataType) * newCapacity);
		if (tmp == NULL)
		{
			perror("HPPush():realloc");
			return;
		}
		php->a = tmp;
		php->capacity = newCapacity;
	}
	//先把数据插入数组尾部
	php->a[php->size++] = x;
	//然后向上调整
	AdjustUp(php->a, php->size - 1);
}

向上调整这个函数传的两个参数分别表示要调整的数组和要调整的孩子节点child在数组中的下标。
有了孩子节点的下标我们就可以计算其父亲节点的下标：int parent = (child - 1) / 2;
因为我们要实现的是小堆，所以如果父亲节点比孩子节点大，我们则将父子节点进行交换，交换完后我们得到新的父子节点的下标，最坏的情况是孩子节点向上不断交换，最后孩子节点的下标==0，说明其所在位置已经是根节点了，是最小的数了，比较也就停止。

//向上比较交换
void AdjustUp(HPDataType* a, int child)
{
	//将数组和最后一个数据下标传过去
	//求这个孩子节点的父亲节点
	int parent = (child - 1) / 2;
	//这个孩子节点最终成为根节点则不再比较
	while (child > 0)
	{
		//我们要实现的是小堆，父亲节点得比孩子节点小
        //如果孩子节点比父亲节点小，则交换
		if (a[child] < a[parent])
		{
			Swap(&a[child], &a[parent]);
			//孩子节点成为父亲节点，继续和祖宗节点比较
			child = parent;
			parent = (child - 1) / 2;
		}
		//a[child] > a[parent],符合小堆逻辑，不用交换了
		else
		{
			break;
		}
	}
}

里面对父子节点进行交换我们也单独写一个函数，方便后续我们要使用的时候直接调用

//交换父子节点
void Swap(HPDataType* child, HPDataType* parent)
{
	HPDataType tmp = *child;
	*child = *parent;
	*parent = tmp;
}

堆的删除

我们要删除的是堆的根，我们怎么删除他呢？直接删除吗？不行，因为直接删除的话剩下的节点直接的关系就全乱了，假如直接删除根节点后，顺序表中的第二个数据就成为了根，而其兄弟节点成为了他的孩子，这时候二者就有了大小关系，但我们知道兄弟节点之间是没有大小关系的，因此这时候顺序表的剩下的数据还是一个堆吗？不是了，他们直接的关系全乱了。
所以我们要删除根节点的办法是先将根节点个顺序表中的最后一个数据进行交换，然后这时候删除最后一个节点就相当于删除了原本的根节点。删除完后我们就需要对这时候的根节点进行调整了。

//堆的删除，删除的是根
void HPPop(HP* php)
{
	assert(php);
	assert(php->size);
	//先将根和数组最后一个数据进行交换
	Swap(&(php->a[0]), &(php->a[php->size - 1]));
	//然后删除数组最后一个数据，即是删除原本小堆的根数据
	php->size--;
	//然后向下比较交换父子节点
	AdjustDown(php->a, php->size, 0);
}

如何调整呢？，我们传三个参数，一个是要操作的顺序表，一个是顺序表中元素的个数，因为我们前面删除了最后一个数(也就是原本的根节点)，所以我们传数据个数的时候需要减去原本的那个根节点。第三个参数是需要调整的这个节点的下标，因为我们是向下调整，需要这个节点与其孩子节点进行比较，所以我们命名这个节点为parent。
怎么比较呢？这里我们是要保持我们的堆依旧是小堆，所以我们要让大的元素与其孩子进行交换，但一般父亲节点都有两个孩子，我们要与谁进行交换呢？我们要与两个孩子中较小的那个孩子进行交换，因为如果我们是与较大的那个孩子进行交换的话，我们还记得小堆的性质：小堆中任意一个父亲节点的值都小于其孩子节点。
所以如果我们与较大的那个孩子节点交换后，这个孩子节点就成为了父亲节点，他需要比他的孩子节点小，但是他是两个孩子中大的那个呀，他成为父亲节点后，他原本的兄弟节点就成为了他的孩子，但他比他孩子大，这就不构成小堆了。所以我们要与较小的那个孩子进行比较。
我们用假设法先假设左孩子较小，如果右孩子比左孩子小，那child就变成右孩子。
后续就是如果父亲节点比孩子节点大，就交换，然后确认出新的孩子节点和父亲节点。

//向下比较交换父子节点
void AdjustDown(HPDataType* a, int n, int parent)
{
	//n是数据个数，parent是父亲节点的下标
	//假设法，先假设左孩子是比较小的那个
	int child = parent * 2 + 1;
	//当这个父亲节点变成叶子节点的时候就结束了
	//当他是叶子节点，那他就没孩子了，他孩子的下标就越界了
	while (child < n)
	{		
		//如果只有左孩子，child+1最后可能越界
		if (child + 1 < n && a[child + 1] < a[child])
		{
			//那较小的那个就是右孩子
			child++;
		}
		//父子节点进行比较，父亲节点大于孩子节点则进行交换
		if (a[parent] > a[child])
		{
			Swap(&a[parent], &a[child]);
			//这个节点变成孩子节点了，继续找他的孩子节点
			parent = child;
			child = parent * 2 + 1;
		}
		//a[parent] < a[child]满足小堆逻辑
		else
		{
			break;
		}
	}
}

返回堆的根

判断不为空后直接返回顺序表第一个元素即可。

//返回堆的根
HPDataType HPTop(HP* php)
{
	assert(php);
	assert(php->size);
	return php->a[0];
}

堆的判空

size == 0为真返回1，为假返回0

//堆的判空
bool HPEmpty(HP* php)
{
	assert(php);
	return php->size == 0;
}

堆的销毁

堆的销毁就是将顺序表动态申请的空间进行释放。

//堆的销毁
void HPDestroy(HP* php)
{
	free(php->a);
	php->a = NULL;
	php->size = php->capacity = 0;
}

4.堆排序

堆排序的思路是：降序建小堆，升序建大堆。
以升序为例，我们先建大堆，建完后我们的根节点是不是就是这个堆中最大的那个元素，我们将根节点和数组中的最后一个元素进行交换，然后将除最后一个元素(被交换的那个根节点)之外剩下的元素进行向下调整再次形成一个大堆，这时候这个大堆的根节点是不是就是这个堆中最大的元素，也就是数组中第二大的元素，然后我们继续向下调整，一直这个样重复，我们就能得到一个升序的序列了。
参考代码如下：

#define _CRT_SECURE_NO_WARNINGS 1

#include<stdio.h>
#include<assret.h>

void Swap(int* child, int* parent)
{
	int temp = *child;
	*child = *parent;
	*parent = temp;
}

//向下调整，父亲与孩子比较交换
void AdjustDown(int* a, int n, int parent)
{
	assert(a);
	//假设法，先假设左孩子是较大的那个
	int child = parent * 2 + 1;
	//孩子下标超过剩余元素个数说明父亲节点已经变成叶子节点了
	while (child < n)
	{
		if (child + 1 < n && a[child + 1] > a[child])
		{
			++child;
		}
		if (a[child] > a[parent])
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

void HeapSort(int* a, int n)
{
	assert(a);
	//升序建大堆
	//从最后一个非叶子节点开始向下调整建堆
	//最后一个非叶子节点的下标是(n - 1 - 1) / 2，这个下标作为父亲节点的下标
	for (int i = (n - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(a, n, i);
	}

	//建堆完后，我们交换第一个和最后一个元素，然后将根元素向下调整
	int end = n - 1;
	while (end)
	{
		Swap(&a[0], &a[end]);//end是最后一个元素的下标
		AdjustDown(a, end, 0);//end是除最后一个元素外剩余元素的个数
		--end;
	}
}

int main()
{
	int a[] = { 9,5,6,3,7,8,1,2,0,4 };
	//排个升序
	HeapSort(a, sizeof(a) / sizeof(a[0]));
	for (int i = 0; i < sizeof(a) / sizeof(a[0]); i++)
	{
		printf("%d ", a[i]);
	}
	return 0;
}

5.文件中的TopK问题

文件中的TopK问题就是我们有一个文件，里面有很多数据，我们要找出这些数据中最大的前k个元素。
思路是: 我们先创建一个k个元素的小堆(向下调整建堆)，这k个元素是文件中的前k个元素。因为是小堆，所以根节点位置的元素是k个元素中最小的那个元素，然后我们将文件中剩下的n-k个元素依次与根节点进行比较，如果比根节点位置的数据大，我们就将根节点的数据进行覆盖，然后我们将这个节点进行向下调整成新的小堆，这样我们确保了根节点永远是k个元素中最小的那个，这样子最后比较完后我们这个小堆中的k个元素就是文件里的n个元素中最大的k个元素了。
参考代码如下：

#define _CRT_SECURE_NO_WARNINGS 1

#include<stdio.h>
#include<assret.h>
#include<stdlib.h>
#include<time.h>

//空间复杂度:O(k)
//时间复杂度:O((N-K)*logK),即O(N)

void Swap(int* child, int* parent)
{
	int temp = *child;
	*child = *parent;
	*parent = temp;
}

//向下调整，父亲与孩子比较交换
void AdjustDown(int* a, int n, int parent)
{
	assert(a);
	//假设法，先假设左孩子是较小的那个
	int child = parent * 2 + 1;
	//孩子下标超过剩余元素个数说明父亲节点已经变成叶子节点了
	while (child < n)
	{
		if (child + 1 < n && a[child + 1] < a[child])
		{
			++child;
		}
		if (a[child] < a[parent])
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

void CreateNData()
{
	int n = 100000;
	srand((unsigned int)time(NULL));
	FILE* fp = fopen("test.txt", "w");
	if (fp == NULL)
	{
		perror("CreateNData():fopen");
		return;
	}
	for (int i = 0; i < n; i++)
	{
		int x = rand() % 10000000;
		fprintf(fp, "%d\n", x);
	}
	fclose(fp);
	fp = NULL;
}

void PrintTopK()
{
	printf("请输入要查找最大的前多少个数:");
	int k = 0;
	scanf("%d", &k);
	//为数组申请k个空间
	int* kminHeap = (int*)malloc(sizeof(int) * k);
	FILE* pf = fopen("test.txt", "r");
	if (pf == NULL)
	{
		perror("PrintTopK():fopen");
		return;
	}
	//读取文件前k个数据
	for (int i = 0; i < k; i++)
	{
		fscanf(pf, "%d", &kminHeap[i]);
	}
	//建小堆
	for (int i = (k - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(kminHeap, k, i);
	}

	int x = 0;
	//返回的是读取成功的个数，读取失败返回-1
	while (fscanf(pf, "%d", &x) > 0)
	{
		if (x > kminHeap[0])
		{
			kminHeap[0] = x;
			AdjustDown(kminHeap, k, 0);
		}
	}
	for (int i = 0; i < k; i++)
	{
		printf("%d ", kminHeap[i]);
	}
}

int main()
{
	//先先文件中放些数据
	//CreateNData();
	PrintTopK();
	return 0;
}

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

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

相关文章

Autojs无线连接vscode方法

Autojs无线连接vscode方法

1.获得电脑的IP 在电脑的CMD界面输入 ipconfig 然后找到ipv4的那一行&#xff0c;后面的即是你的电脑IP地址 2.打开vscode的autojs服务 安装autojs插件 在vscode界面按下ctrlshiftp 输入autojs 找到 点击 之后打开手机上的autojs 之后输入刚刚电脑上的地址 可以看到vsc…
阅读更多...
【Java开发指南 | 第三十五篇】Maven + Tomcat Web应用程序搭建

【Java开发指南 | 第三十五篇】Maven + Tomcat Web应用程序搭建

读者可订阅专栏&#xff1a;Java开发指南 |【CSDN秋说】 文章目录 前言Maven Tomcat Web应用程序搭建1、使用Maven构建新项目2、单击项目&#xff0c;连续按两次shift键&#xff0c;输入"添加"&#xff0c;选择"添加框架支持"3、选择Java Web程序4、点击&…
阅读更多...
PyTorch深度学习框架60天进阶学习计划第16天：循环神经网络进阶！

PyTorch深度学习框架60天进阶学习计划第16天：循环神经网络进阶！

PyTorch深度学习框架60天进阶学习计划 - 第16天&#xff1a;生成对抗网络原理 学习目标 今天我们将深入探讨生成对抗网络(GAN)的基本原理和数学基础&#xff0c;重点解析GAN的minimax博弈公式&#xff0c;推导生成器与判别器的损失函数&#xff0c;分析Wasserstein GAN的改进…
阅读更多...
系统架构设计师—系统架构设计篇—微服务架构

系统架构设计师—系统架构设计篇—微服务架构

文章目录 概述优势挑战 概述 微服务是一种架构风格&#xff0c;将单体应用划分成一组小的服务&#xff0c;服务之间相互协作&#xff0c;实现业务功能&#xff0c;每个服务运营在独立的进程中&#xff0c;服务间采用轻量级的通信机制协作&#xff08;通常是HTTP/JSON&#xff0…
阅读更多...
静态时序分析STA——2. 数字单元库-（2）

静态时序分析STA——2. 数字单元库-（2）

参考文献 [1]Static Timing Analysis for Nanometer Designs A Practical Approach [2]静态时序分析圣经翻译计划 三.组合逻辑单元的时序模型 对于一个两输入与门的时序弧&#xff0c;两个时序弧均为正单边类型&#xff08;positive_unate&#xff09;。这意味着对于 NLDM 模型…
阅读更多...
Mysql的卸载安装配置以及简单使用

Mysql的卸载安装配置以及简单使用

MySQL其它问题已经更新在&#xff1a;MySQL完善配置---可视化-CSDN博客 一、卸载 ①控制面板卸载 ②C盘隐藏项目>ProgramData>mysql相关文件夹&#xff0c;还有Program file下的MySQL文件夹 ③开始菜单栏搜索>服务&#xff0c;找到MySQL相关服务删除&#xff0c;如果再…
阅读更多...
第五课：Express框架与RESTful API设计：技术实践与探索

第五课：Express框架与RESTful API设计：技术实践与探索

在使用Node.js进行企业应用开发&#xff0c;常用的开发框架Express&#xff0c;其中的中间件、路由配置与参数解析、RESTful API核心技术尤为重要&#xff0c;本文将深入探讨它们在应用开发中的具体使用方法&#xff0c;最后通过Postman来对开发的接口进行测试。 一、Express中…
阅读更多...
基于Django的协同过滤算法养老新闻推荐系统的设计与实现

基于Django的协同过滤算法养老新闻推荐系统的设计与实现

基于Django的协同过滤算法养老新闻推荐系统&#xff08;可改成普通新闻推荐系统使用&#xff09; 开发工具和实现技术 Pycharm&#xff0c;Python&#xff0c;Django框架&#xff0c;mysql8&#xff0c;navicat数据库管理工具&#xff0c;vue&#xff0c;spider爬虫&#xff0…
阅读更多...
Facebook 的隐私保护数据存储方案研究

Facebook 的隐私保护数据存储方案研究

Facebook 的隐私保护数据存储方案研究 在这个信息爆炸的时代&#xff0c;数据隐私保护已成为公众关注的热点。Facebook&#xff0c;作为全球最大的社交媒体平台之一&#xff0c;承载着海量用户数据&#xff0c;其隐私保护措施和数据存储方案对于维护用户隐私至关重要。本文将深…
阅读更多...
World of Warcraft [CLASSIC] BigFoot BiaoGe

World of Warcraft [CLASSIC] BigFoot BiaoGe

World of Warcraft [CLASSIC] BigFoot BiaoGe 金团表格插件 设置60秒拍卖装备时间 ALT 鼠标左键&#xff0c;点击装备&#xff0c;弹出对话框&#xff0c;填写 1&#xff09;拍卖时间默认60秒&#xff0c;起拍价&#xff0c; 2&#xff09;点击【开始拍卖】 团队所有安装了…
阅读更多...
Docker和DockerCompose基础教程及安装教程

Docker和DockerCompose基础教程及安装教程

Docker的应用场景 Web 应用的自动化打包和发布。自动化测试和持续集成、发布。在服务型环境中部署和调整数据库或其他的后台应用。从头编译或者扩展现有的 OpenShift 或 Cloud Foundry 平台来搭建自己的 PaaS 环境。 CentOS Docker 安装 使用官方安装脚本自动安装 安装命令…
阅读更多...
题解：洛谷 AT_dp_c Vacation

题解：洛谷 AT_dp_c Vacation

题目https://www.luogu.com.cn/problem/AT_dp_c设 表示对于前 天&#xff0c;以 项目结尾能获得的最大价值。 则&#xff1a; 答案为&#xff1a;。 实现 #include<bits/stdc.h> using namespace std; #define int long long int n,dp[100005][3]; signed main(){i…
阅读更多...
通义万相2.1：开启视频生成新时代

通义万相2.1：开启视频生成新时代

文章摘要&#xff1a;通义万相 2.1 是一款在人工智能视频生成领域具有里程碑意义的工具&#xff0c;它通过核心技术的升级和创新&#xff0c;为创作者提供了更强大、更智能的创作能力。本文详细介绍了通义万相 2.1 的背景、核心技术、功能特性、性能评测、用户反馈以及应用场景…
阅读更多...
ubuntu 20.04 C++ 源码编译 cuda版本 opencv4.5.0

ubuntu 20.04 C++ 源码编译 cuda版本 opencv4.5.0

前提条件是安装好了cuda和cudnn 点击下载&#xff1a; opencv_contrib4.5.0 opencv 4.5.0 解压重命名后 进入opencv目录&#xff0c;创建build目录 “CUDA_ARCH_BIN ?” 这里要根据显卡查询一下,我的cuda是11&#xff0c;显卡1650&#xff0c;所以是7.5 查询方法1&#xff1…
阅读更多...
【人工智能】Open WebUI+ollama+deepSeek-r1 本地部署大模型与知识库

【人工智能】Open WebUI+ollama+deepSeek-r1 本地部署大模型与知识库

目录 一 、命令行下载安装 二、运行 三、添加开机自启服务 ollama serve 四、重新加载配置、重启ollama server 五、查看模型文件信息 六、 添加open-webui 七、 配置open webui 八、创建自己知识库 九、网络加密优化 十、大工告成&#xff0c;大家如果有问题可以私信…
阅读更多...
DeepSeek R1-7B 医疗大模型微调实战全流程分析（全码版）

DeepSeek R1-7B 医疗大模型微调实战全流程分析（全码版）

DeepSeek R1-7B 医疗大模型微调实战全流程指南 目录 环境配置与硬件优化医疗数据工程微调策略详解训练监控与评估模型部署与安全持续优化与迭代多模态扩展伦理与合规体系故障排除与调试行业应用案例进阶调优技巧版本管理与迭代法律风险规避成本控制方案文档与知识传承1. 环境配…
阅读更多...
Android Studio右上角Gradle 的Task展示不全

Android Studio右上角Gradle 的Task展示不全

Android Studio 版本如下&#xff1a;Android Studio lguana|2023.21, 发现Gradle 的Tasks阉割严重&#xff0c;如下图&#xff0c;只显示一个other 解决方法如下&#xff1a;**Setting>Experimental>勾选Configure all gradle tasks during Gradle Sync(this can make…
阅读更多...
[HTTP协议]应用层协议HTTP从入门到深刻理解并落地部署自己的云服务(2)

[HTTP协议]应用层协议HTTP从入门到深刻理解并落地部署自己的云服务(2)

标题&#xff1a;[HTTP协议]应用层协议HTTP从入门到深刻理解并落地部署自己的云服务(2) 水墨不写bug 文章目录 一、无法拷贝类(class uncopyable)的设计解释&#xff1a;重要思想&#xff1a;使用示例 二、锁的RAII设计解释重要考虑使用示例 三、基于RAII模式和互斥锁的的日志…
阅读更多...
YOLOv8改进SPFF-LSKA大核可分离核注意力机制

YOLOv8改进SPFF-LSKA大核可分离核注意力机制

YOLOv8改进------------SPFF-LSKA 1、LSAK.py代码2、添加YAML文件yolov8_SPPF_LSKA.yaml3、添加SPPF_LSKA代码4、ultralytics/nn/modules/__init__.py注册模块5、ultralytics/nn/tasks.py注册模块6、导入yaml文件训练 1、LSAK.py代码 论文 代码 LSKA.py添加到ultralytics/nn/…
阅读更多...
系统架构设计师—系统架构设计篇—特定领域软件体系结构

系统架构设计师—系统架构设计篇—特定领域软件体系结构

文章目录 概述领域分类垂直域水平域 系统模型基本活动参与角色 概述 特定领域软件架构&#xff08;Domain Specific Software Architecture&#xff0c;DSSA&#xff09;是在一个特定应用领域中&#xff0c;为一组应用提供组织结构参考的标准团建体系结构。 领域分类 垂直域…
阅读更多...
最新文章

Copyright @ 2022~2023