数据结构~~二叉树-堆

目录

一、基本概念

树的概念

二叉树-堆的概念

二、堆的结构

 三、堆排序

向上调整建堆

向下调整建堆 

 四、TOP-K

五、完整代码

 六、总结

一、基本概念

树的概念

树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因 为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。 有一个特殊的结点，称为根结点，根节点没有前驱结点 除根节点外，其余结点被分成M(M>0)个互不相交的集合T1、T2、……、Tm，其中每一个集合Ti(1<=i=M),又是一棵结构与树类似的子树。每棵子树的根结点有且只有一个前驱，可以有0个或多个后继 因此，树是递归定义的。

树形结构中，子树之间不能有交集，否则就不是树形结构

 1.2树的相关概念： 

度节点的：一个节点含有的子树的个数称为该节点的度； 如上图：A的为6

叶节点或终端节点：度为0的节点称为叶节点； 如上图：B、C、H、I...等节点为叶节点

非终端节点或分支节点：度不为0的节点； 如上图：D、E、F、G...等节点为分支节点

双亲节点或父节点：若一个节点含有子节点，则这个节点称为其子节点的父节点； 如上图：A是B的父节点

孩子节点或子节点：一个节点含有的子树的根节点称为该节点的子节点； 如上图：B是A的孩子节点

兄弟节点：具有相同父节点的节点互称为兄弟节点； 如上图：B、C是兄弟节点

树的度：一棵树中，最大的节点的度称为树的度； 如上图：树的度为6

节点的层次：从根开始定义起，根为第1层，根的子节点为第2层，以此类推；

树的高度或深度：树中节点的最大层次； 如上图：树的高度为4

堂兄弟节点：双亲在同一层的节点互为堂兄弟；如上图：H、I互为兄弟节点

节点的祖先：从根到该节点所经分支上的所有节点；如上图：A是所有节点的祖先

子孙：以某节点为根的子树中任一节点都称为该节点的子孙。如上图：所有节点都是A的子孙

森林：由m（m>0）棵互不相交的树的集合称为森林；

二叉树-堆的概念

一棵二叉树是结点的一个有限集合，该集合: 1. 或者为空 2. 由一个根节点加上两棵别称为左子树和右子树的二叉树组成

从上图可以看出：1. 二叉树不存在度大于2的结点 2. 二叉树的子树有左右之分，次序不能颠倒，因此二叉树是有序树

对于任意的二叉树都是由以下几种情况复合而成的：

 2.二叉树的性质 

1. 若规定根节点的层数为1，则一棵非空二叉树的第i层上最多有 个结点.

2. 若规定根节点的层数为1，则深度为h的二叉树的最大结点数是 .

3. 对任何一棵二叉树, 如果度为0其叶结点个数为 , 度为2的分支结点个数为 ,则有 ＝ ＋1

4. 若规定根节点的层数为1，具有n个结点的满二叉树的深度，h= . (ps： 是log以2 为底，n+1为对数)

5. 对于具有n个结点的完全二叉树，如果按照从上至下从左至右的数组顺序对所有节点从0开始编号，则对 于序号为i的结点有：

1. 若i>0，i位置节点的双亲序号：(i-1)/2；i=0，i为根节点编号，无双亲节点

2. 若2i+1，左孩子序号：2i+1，2i+1>=n否则无左孩子

3. 若2i+2，右孩子序号：2i+2，2i+2>=n否则无右孩子

3.堆的概念

如果有一个关键码的集合K = { ， ， ，…， }，把它的所有元素按完全二叉树的顺序存储方式存储 在一个一维数组中，并满足： 且 = 且 >= ) i = 0，1， 2…，则称为小堆(或大堆)。将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。 堆的性质： 堆中某个节点的值总是不大于或不小于其父节点的值； 堆总是一棵完全二叉树。  

二、堆的结构

typedef int HPDateType;
typedef struct Heap
{
	HPDateType* a;  
	int size;
	int capacity;
}HP;

初始化堆

void HeapInit(HP* php)
{
	assert(php);
	php->a = NULL;
	php->capacity = 0;
	php->size = 0;
}

 摧毁堆

void HeapDestroy(HP* php)
{
	assert(php);
	free(php->a);
	php->a = NULL;
	php->capacity = php->size = 0;
}

向上调整

void AdjustUP(HPDateType* a, int child)
{
	int parent = (child - 1) / 2;
	while (child>0)
	{
		if (a[parent] > a[child])
		{
			HPDateType tmp = a[child];
			a[child] = a[parent];
			a[parent] = tmp;

			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

向下调整

void AdjustDown(int* a,int n,int parent)
{
	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[parent],&a[child]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

 插入数据

void HeapPush(HP* php, HPDateType x) 
{
	assert(php);
	if (php->size == php->capacity)
	{
		int newCapacity = php->capacity == 0 ? 4 : php->capacity * 2;
		HPDateType* tmp = (HPDateType*)realloc(php->a, newCapacity * sizeof(HPDateType));
		if (tmp == NULL)
		{
			perror("realloc err");
			return;
		}
		php->a = tmp;
		php->capacity = newCapacity;
	}
	php->a[php->size] = x;
	php->size++;
	AdjustUP(php->a,php->size-1);
}

删除数据

void HeapPop(HP* php)
{
	assert(php);
	assert(!HeapEmpty(php));
	Swap(&php->a[0], &php->a[php->size-1]);
	php->size--;
	AdjustDown(php->a,php->size,0);

}

获取堆顶元素 

HPDateType HeapTop(HP* php)
{
	assert(php);
	assert(!HeapEmpty(php));
	return php->a[0];
}

判断堆是否为空

bool HeapEmpty(HP* php)
{
	assert(php);
	return php->size == 0;
}

获取堆的长度 

int HeapSize(HP* php)
{
	assert(php);
	assert(!HeapEmpty(php));
	return php->size;
}

 三、堆排序

向上调整建堆

1.升序建大堆

// 对数组进行堆排序
void AdjustUP(HPDateType* a, int child)
{
	int parent = (child - 1) / 2;
	while (child>0)
	{
		if (a[parent] > a[child])
		{
			HPDateType tmp = a[child];
			a[child] = a[parent];
			a[parent] = tmp;

			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}
void HeapSort(int* a, int n)
{
	//建堆小堆
	for (int i = 1; i < n; i++)
	{
		AdjustUP(a, i);
	}
	int end = n - 1;
	//排序升序
	while (end > 0)
	{
		Swap(&a[0],&a[end]);
		AdjustDown(a, end, 0);
		end--;
	}
}
void test()
{
	int arr[] = { 58,5,28,95,62,65,89,85,61,88,90,78,86,87 ,236,1 };
	HeapSort(arr, sizeof(arr) / sizeof(arr[0]));
	for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
	{
		printf("%d ",arr[i]);
	}
}
int main()
{
   test();
}

建堆后：

排序后 ：

 2.降序建小堆

// 对数组进行堆排序
void AdjustDown(int* a,int n,int parent)
{
	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[parent],&a[child]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}
void AdjustUP(HPDateType* a, int child)
{
	int parent = (child - 1) / 2;
	while (child>0)
	{
		if (a[parent] > a[child])
		{       //控制建大小堆
			HPDateType tmp = a[child];
			a[child] = a[parent];
			a[parent] = tmp;

			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}
void HeapSort(int* a, int n)
{
	for (int i = 1; i < n; i++)
	{
		AdjustUP(a, i);
	}
	int end = n - 1;
	while (end > 0)
	{
		Swap(&a[0], &a[end]);
		AdjustDown(a, end, 0);
		end--;
	}
}
void test()
{
	int arr[] = { 58,5,28,95,62,65,89,85,61,88,90,78,86,87 ,236,1 };
	HeapSort(arr, sizeof(arr) / sizeof(arr[0]));
	for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
	{
		printf("%d ",arr[i]);
	}
}
int main()
{
   test();
}

建堆后 :

排序后： 

向下调整建堆 

void AdjustDown(int* a,int n,int parent)
{
	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[parent],&a[child]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}
void HeapSort(int* a, int n)
{
	for (int i = (n - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(a, n, i);
	}
	int end = n - 1;
	while (end > 0) //n*logn
	{
		Swap(&a[0], &a[end]);
		AdjustDown(a, end, 0);
		end--;
	}
}
void test()
{
	int arr[] = { 58,5,28,95,62,65,89,85,61,88,90,78,86,87 ,236,1 };
	HeapSort(arr, sizeof(arr) / sizeof(arr[0]));
	for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
	{
		printf("%d ", arr[i]);
	}
}
int main()
{ 
    test();
}

建堆：

排序后：

向上调整建堆和向下调整建堆的时间复杂度有所不同。

向上调整建堆的时间复杂度为。O(N*logN)

向下调整建堆的时间复杂度为。O(N)

在实际应用中，通常采用向下调整建堆的方式，因为它的时间复杂度较低。但在某些特定情况下，向上调整建堆也可能会被使用。

 四、TOP-K

思路：

topk 问题是指在一组数据中，找出前 k 个最大或最小的元素。以下是解决 topk 问题的思路和算法： 

建立最小堆或最大堆：使用堆数据结构来解决 topk 问题。可以先建立一个大小为 k 的最小堆或最大堆，然后依次将剩余的元素与堆顶元素进行比较。如果元素大于或小于堆顶元素，则将其替换堆顶元素，并重新调整堆。最后，堆中的元素就是前 k 个最大或最小的元素。这种方法的时间复杂度为O(NlogK)

当N远比K大是时间复杂度为O(N)

在实际应用中，需要根据具体情况选择合适的算法来解决 topk 问题。如果数据量较小，可以使用简单的排序算法或堆算法

typedef int HPDateType;
void Swap(HPDateType* p1, HPDateType* p2)
{
	HPDateType tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}
//向下调整
void AdjustDown(int* a, int n, int parent)
{
	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[parent], &a[child]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}
void CreateNDate()
{
	// 造数据
	int n = 10000;
	srand(time(0));
	const char* file = "data.txt";
	FILE* fin = fopen(file, "w");
	if (fin == NULL)
	{
		perror("fopen error");
		return;
	}

	for (size_t i = 0; i < n; ++i)
	{
		int x = (rand()+i) % 1000000;
		fprintf(fin, "%d\n", x);
	}

	fclose(fin);
}

void PrintTopK()
{
	int k = 0;
	printf("请输入k的值:");
	scanf("%d", &k);
	int* kminheap = (int*)malloc(sizeof(int) * k);
	if (kminheap == NULL)
	{
		perror("malloc file");
		return;
	}      
	const char* file = "data.txt";
	FILE* fout = fopen(file, "r");
	if (fout == NULL)
	{
		perror("fopen error");
		return;
	}
	for (int i = 0; i < k; i++)  //写前k个数据
	{
		fscanf(fout,"%d", &kminheap[i]);
	}
	           //最后的结点的根
	for (int i = (k - 1 - 1) / 2; i >= 0; i--)  //建堆
	{
		AdjustDown(kminheap,k,i);
	}
	int x = 0;
	while (fscanf(fout,"%d", &x) > 0)
	{
		if (x > kminheap[0])
		{
			kminheap[0] = x;
			AdjustDown(kminheap,k,0);
		}
	}
	printf("最大的前k个是：");
	for (int i = 0; i < k; i++)
	{
		printf("%d ",kminheap[i]);
	}
}
int main()
{
    CreateNDate();
	PrintTopK();
}

void CreateNDate()在这个函数生成完一百万个数据时可以在手动添加最大数据，检查代码是否正确

五、完整代码

Heap.h

#include<assert.h>
#include<stdbool.h>
typedef int HPDateType;
typedef struct Heap
{
	HPDateType* a;
	int size;
	int capacity;
}HP;


void HeapInit(HP* php);//初始化堆
void HeapDestroy(HP* php);//摧毁堆

void HeapPush(HP* php,HPDateType x);//插入堆
void HeapPop(HP* php);//删除堆

HPDateType HeapTop(HP* php);//获取堆顶的元素
bool HeapEmpty(HP* php);//堆是否为空
int HeapSize(HP* php);//堆的长度

void AdjustDown(int* a, int n, int parent);//向下调整
void AdjustUP(HPDateType* a, int child);//向上调整

Heap.c 

#include"Heap.h"

void HeapInit(HP* php)
{
	assert(php);
	php->a = NULL;
	php->capacity = 0;
	php->size = 0;
}
void Swap(HPDateType* p1, HPDateType* p2)
{
	HPDateType tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}
void HeapDestroy(HP* php)
{
	assert(php);
	free(php->a);
	php->a = NULL;
	php->capacity = php->size = 0;
}
void AdjustDown(int* a,int n,int parent)
{
	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[parent],&a[child]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}
void AdjustUP(HPDateType* a, int child)
{
	int parent = (child - 1) / 2;
	while (child>0)
	{
		if (a[parent] > a[child])
		{
			HPDateType tmp = a[child];
			a[child] = a[parent];
			a[parent] = tmp;

			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}
void HeapPush(HP* php, HPDateType x) 
{
	assert(php);
	if (php->size == php->capacity)
	{
		int newCapacity = php->capacity == 0 ? 4 : php->capacity * 2;
		HPDateType* tmp = (HPDateType*)realloc(php->a, newCapacity * sizeof(HPDateType));
		if (tmp == NULL)
		{
			perror("realloc err");
			return;
		}
		php->a = tmp;
		php->capacity = newCapacity;
	}
	php->a[php->size] = x;
	php->size++;
	AdjustUP(php->a,php->size-1);
}
void HeapPop(HP* php)
{
	assert(php);
	assert(!HeapEmpty(php));
	Swap(&php->a[0], &php->a[php->size-1]);
	php->size--;
	AdjustDown(php->a,php->size,0);

}
HPDateType HeapTop(HP* php)
{
	assert(php);
	assert(!HeapEmpty(php));
	return php->a[0];
}
bool HeapEmpty(HP* php)
{
	assert(php);
	return php->size == 0;
}
int HeapSize(HP* php)
{
	assert(php);
	assert(!HeapEmpty(php));
	return php->size;
}

 六、总结

二叉树堆是一种特殊的二叉树，它具有以下性质：

1. 堆中某个节点的值总是不大于或不小于其父节点的值：如果父节点的值大于子节点的值，那么这是一个大顶堆；如果父节点的值小于子节点的值，那么这是一个小顶堆。

2. 堆总是一棵完全二叉树：即除了最后一层可能有部分节点空缺外，其他层的节点都是满的。

二叉树堆可以使用数组来存储，通过维护节点的父子关系和堆的性质，可以实现堆的基本操作，如插入、删除和排序等。常见的堆操作包括：

1. 建堆：将一个数组构建成堆。

2. 堆调整：在插入或删除节点后，对堆进行调整，以保持堆的性质。

3. 堆排序：利用堆的性质进行排序。

二叉树堆在很多领域都有广泛的应用，例如：

1. 优先队列：可以用于实现优先队列，按照优先级对元素进行排序和访问。

2. 数据筛选：从大量数据中快速筛选出前个最大或最小的元素。

3. 图的遍历：在某些图算法中，可以使用堆来优化遍历过程。

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

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

相关文章

在ubuntu中查询与某脚本或某设备相关的进程，ps，pgrep，lsof，fuser，pstree，htop命令的使用指南

在ubuntu中查询与某脚本或某设备相关的进程，ps，pgrep，lsof，fuser，pstree，htop命令的使用指南

一、查询与脚本有关的进程 1. 用ps命令 在 Ubuntu 系统中&#xff0c;如果你想查询与特定 Python 脚本 abc.py 相关的线程&#xff0c;你可以使用 ps 命令和 grep 命令结合来查找。ps 命令用于显示当前运行的进程状态&#xff0c;而 grep 命令可以帮助你过滤出包含指定字符串…
阅读更多...
（六）DockerCompose安装与配置

（六）DockerCompose安装与配置

DockerCompose简介 Compose 项目是 Docker 官方的开源项目&#xff0c;负责实现对 Docker 容器集群的快速编排。使用前面介绍的Dockerfile我们很容易定义一个单独的应用容器。然而在日常开发工作中&#xff0c;经常会碰到需要多个容器相互配合来完成某项任务的情况。例如要实现…
阅读更多...
Docker Desktop安装和如何在WSL2中使用Docker

Docker Desktop安装和如何在WSL2中使用Docker

最近在使用WSL的过程中&#xff0c;想使用docker遇到了一些问题&#xff0c;在WSL中安装Linux版本的docker&#xff0c;启动镜像之后不能从Windows机器的端口映射出来&#xff0c;查了一圈之后&#xff0c;发现应该使用Docker Desktop软件&#xff0c;下面是安装和使用的方式 …
阅读更多...
error1310 写入文件时发生错误,请确认您是否有访问权限 也可能出现error 1304 ：写入文件时出错

error1310 写入文件时发生错误,请确认您是否有访问权限 也可能出现error 1304 ：写入文件时出错

一般错误提示如下 error1310 Error writing to file 错误 1310 &#xff1a;写入文件时出错&#xff1a;请确认您有权访问该目录&#xff0c; error1304 Error writing to file 错误 1304 &#xff1a;写入文件时出错&#xff1a;请确认您有权访问该目录 1.首先我们退出所…
阅读更多...
揭秘齿轮加工工艺的选用原则：精准打造高效传动的秘密武器

揭秘齿轮加工工艺的选用原则：精准打造高效传动的秘密武器

在机械制造领域&#xff0c;齿轮作为传动系统中的重要组成部分&#xff0c;其加工工艺的选择至关重要。不同的齿轮加工工艺会影响齿轮的精度、耐用性和效率。本文将通过递进式结构&#xff0c;深入探讨齿轮加工工艺的选用原则&#xff0c;带您了解如何精准打造高效传动的秘密武…
阅读更多...
SpringBoot3.x + JDK21 整合 Mybatis-Plus

SpringBoot3.x + JDK21 整合 Mybatis-Plus

前言 SpringBoot3.0 开始最低要求 Java 17&#xff0c;虽然目前最新的版本为 JDK22&#xff0c;但是在官网上看到 JDK23 在今年9月又要发布了&#xff0c;感觉这 JDK 也有点太过于给力了 所以我们选择用目前的 LTS 版本 JDK21 就好了&#xff0c;不用追求最新的 springboot 版…
阅读更多...
DOM【事件、操作节点、DOM案例】--学习JavaEE的day49

DOM【事件、操作节点、DOM案例】--学习JavaEE的day49

day49 JS核心技术 DOM 继day48 事件 键盘事件 监听器&#xff1a;onkeydown、onkeypress、onkeyup <!DOCTYPE html> <html><head><meta charset"UTF-8"><title></title></head><body><input type"text&q…
阅读更多...
网站工作原理

网站工作原理

web发展史 1.0时代不可修改 2.0可修改&#xff0c;比如发微博 有以下问题&#xff1a; 课程2&#xff1a; 静态页面 html 动态页面 php 经过服务端的语言解释器&#xff0c;解析成html文件&#xff0c;剩下的就和静态流程一样 后面三个是web服务器&#xff0c;语言解释器&…
阅读更多...
恶劣天候鲁棒三维目标检测论文整理

恶劣天候鲁棒三维目标检测论文整理

恶劣天候鲁棒三维目标检测论文整理 Sunshine to Rainstorm: Cross-Weather Knowledge Distillation for Robust 3D Object DetectionRobo3D: Towards Robust and Reliable 3D Perception against CorruptionsLossDistillNet: 3D Object Detection in Point Cloud Under Harsh W…
阅读更多...
Android Low Storage机制之DeviceStorageMonitorService

Android Low Storage机制之DeviceStorageMonitorService

一、Android 版本 Android 13 二、low storage简介(DeviceStorageMonitorService) 设备存储监视器服务是一个模块&#xff0c;主要用来&#xff1a; 1.监视设备存储&#xff08;“/ data”&#xff09;。 2.每60秒扫描一次免费存储空间(谷歌默认值) 3.当设备的存储空间不足…
阅读更多...
prometheusgrafananode_export搭建监控平台

prometheusgrafananode_export搭建监控平台

一、环境要求 1、docker安装docker环境 2、docker安装prometheus 3、docker安装grafana 4、node-exportor(安装在被测服务器上) 5、我的服务器是Ubuntu 二、docker 安装prometheus 1、下载Prometheus镜像 docker pull prom/prometheus 2、检查端口是否被占用 安装netstat命…
阅读更多...
Vitis HLS 学习笔记--抽象并行编程模型-控制驱动与数据驱动

Vitis HLS 学习笔记--抽象并行编程模型-控制驱动与数据驱动

目录 1. 简介 2. Takeaways 3. Data-driven Task-level Parallelism 3.1 simple_data_driven 示例 3.2 分析 hls::task 类 3.3 分析通道(Channel) 3.4 注意死锁 4. Control-driven Task-level Parallelism 4.1 理解控制驱动的 TLP 4.2 simple_control_driven 示例 4…
阅读更多...
开源实用！猫抓媒体嗅探浏览器插件

开源实用！猫抓媒体嗅探浏览器插件

CatCatch&#xff1a;网络资源&#xff0c;一触即发 - 精选真开源&#xff0c;释放新价值。 概览 CatCatch是一个专为浏览器设计的资源嗅探扩展&#xff0c;旨在帮助用户轻松捕获和分析网页中的各种资源。无论是视频、音频还是其他类型的文件&#xff0c;猫爪都能提供直观的界…
阅读更多...
C++青少年简明教程：If选择语句

C++青少年简明教程：If选择语句

C青少年简明教程&#xff1a;If选择语句 C中选择语句的语法是&#xff1a; if (条件) { 条件成立时需要执行的语句... } [else { 条件不成立时需要执行的语句... }] 说明&#xff1a; if后面使用一个括号&#xff0c;括号里是条件——关系表达式。 所谓的关系表达式就是判…
阅读更多...
Java基础之异常（简单易懂）

Java基础之异常（简单易懂）

异常 1.JAVA异常体系 &#xff08;1&#xff09;Throwable类(表示可抛)是所有异常和错误的超类&#xff0c;两个直接子类为Error和Exception,分别表示错误和异常;其中异常类Exception又分为运行时异常和非运行时异常&#xff0c;这两个异常有很大区别&#xff0c;运行时异常也…
阅读更多...
生成式AI改变的不只是应用场景，而是要重塑整个行业

生成式AI改变的不只是应用场景，而是要重塑整个行业

即使是在各种创新技术不断涌现的IT行业&#xff0c;生成式AI也可以当之无愧地说是当前全球最受关注的焦点领域&#xff0c;没有之一。 那么对于企业来说&#xff0c;生成式AI技术究竟可以为他们带来怎样的变化和革新&#xff1f;企业又能从中获得怎样的收益&#xff1f; 作为一…
阅读更多...
靠着单干实现财富自由，可太爽了

靠着单干实现财富自由，可太爽了

这里所说的“单干”&#xff0c;并不是单打独斗的意思&#xff0c;而是一种商业认知&#xff0c;以及由这种认知衍生出来的商业模式、商业方法和商业实践。 之前提到单干&#xff0c;会本能地以为它是指脱离公司等组织形式&#xff0c;自己一个人做生意。现在单干有了更丰富的…
阅读更多...
医院门诊互联电子病历|基于SSM＋vue的医院门诊互联电子病历管理信息系统的设计与实现(源码+数据库+文档)

医院门诊互联电子病历|基于SSM＋vue的医院门诊互联电子病历管理信息系统的设计与实现(源码+数据库+文档)

医院门诊互联电子病历管理信息系统 目录 基于SSM&#xff0b;vue的医院门诊互联电子病历管理信息系统的设计与实现 一、前言 二、系统设计 三、系统功能设计 1系统功能模块 2后台登录模块 5.2.1管理员功能 5.2.2用户功能 5.2.3医生功能 四、数据库设计 五、核心代码…
阅读更多...
源网络地址转换SNAT

源网络地址转换SNAT

左上角的是访问互联网发送的数据包&#xff0c;第一个是访问&#xff0c;第二个是网页传回来的 3、4项是源端口号和目的端口号&#xff08;3是随机的&#xff08;1024-65535&#xff09;&#xff0c;那个是http的网页服务端口就是80&#xff09; 那么往回传数据的时候源和目的…
阅读更多...
[排序算法]2. 图解选择排序及其代码实现

[排序算法]2. 图解选择排序及其代码实现

选择排序 选择排序就是重复“从待排序的数据中寻找最小值&#xff0c;将其与序列最左边的数字进行交换”这一操作的算法。在序列中寻找最小值时使用的是线性查找。 算法步骤: 1.使用线性查找在数据中寻找最小值, 于是我们找到了最小值1 2.将最小值1与序列最左边的…
阅读更多...
最新文章

Copyright @ 2022~2023