二叉树—堆（C语言实现）

 一、树的概念及结构

1.树的概念

树是一种非线性的数据结构，它是有n（n > 0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一颗倒挂的树，也就是说它是根朝上，而叶朝下。

●  有一个特殊的结点，成为根结点，根结点没有前驱结点

●  除根节点外，其余节点被分成M（M > 0）个互不相交的集合T1、T2、......、Tm，其中每个集合Ti(1 <= i <= m)又是一颗结构与树相类似的子树。每棵子树的根结点有且只有一个前驱，可以有0个或多个后继

●  因此，树是递归定义

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

2.树的相关概念

3.树的表示

树结构相对线性表就比较复杂，要存储表示起来就比较麻烦，既然保存值域，也要保存结点和结点之间的关系，实际上数有很多表示方式比如：双亲表示法，孩子表示法，孩子双亲表示法以及孩子兄弟表示法等。我们这里就简单的理解其中最常用的孩子兄弟表示法。

typedef int DataType;
struct Node
{
 struct Node* firstChild1; // 第一个孩子结点
 struct Node* pNextBrother; // 指向其下一个兄弟结点
 DataType data; // 结点中的数据域
};

二、二叉树的概念及结构

1.概念

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

2.或者为空

由上图可知：

1.二叉树不存在度大于2的结点

2.二叉树的子树有左右之分，次序不能颠倒，因此二叉树是有序树

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

2.特殊的二叉树 

(1)满二叉树：一个二叉树，如果每一层的结点数都要达到最大值，则这个二叉树就是满二叉树。也就是说，如果一个二叉树的层数为K，且总结点数是2^{k}-1，则它就是满二叉树。

(2)完全二叉树：完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树印出来的。对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点——对应时称之为完全二叉树。要注意的是满二叉树是一种特殊的完全二叉树。

3.二叉树的性质

(1)若规定根结点的层数为1，则一颗树非空二叉树的第i层上最多有2^{i-1}个结点。

(2)若规定根结点的层数为1，则深度为h的二叉树的最大结点数是2^{h}-1。

(3)对任何一颗二叉树，如果度为0其叶结点个数为n0，度为2的分支结点个数为n2，则有n0=n2+1 

<1>类比归纳（图解） ：

<2>定义推导：

假设二叉树有N个结点

从总结点数角度考虑：N = n0 + n1 + n2   ①

从边的角度考虑，N个结点的任意二叉树，总共有N-1条边

因为二叉树中每一个结点都有双亲，根结点没有双亲，每个结点向上与其双亲之间存在一条边，因此N个结点的二叉树总共有N-1条边。

因为度为0的节点没有孩子，故度为0的节点不产生边；度为1的结点只有一个孩子。故每个度为1的结点产生一条边；度为2的结点有两个孩子，故每个度为2的结点产生两条边，所以总边数为：n1 + 2*n2

故从边的角度考虑：N-1 = n1 + 2*n2   ②

结合①和②得：n0 + n1 + n2 = n1 + 2*n2 - 1

即n0 = n2 + 1

(4)若规定根结点的层数为1，具有n个结点的满二叉树的深度，h =\log2^{^{n+1}}（是log以2为底,n+1为对数）

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

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

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

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

4.题目 

1. 某二叉树共有 399 个结点，其中有 199 个度为 2 的结点，则该二叉树中的叶子结点数为（B）
A 不存在这样的二叉树
B 200
C 198
D 199

 由性质3：n0 = n2 + 1 = 199 + 1 = 200

2.在具有 2n 个结点的完全二叉树中，叶子结点个数为（A）
A n
B n+1
C n-1
D n/2

度为0 —> n0个，度为1 —> n1个，度为2 —> n2个

因为n0 + n1 + n2 = 2N，n0 = n2 + 1

则2n0 + n1 - 1 = 2N

因为完全二叉树的n1的数量是0 or 1，为了保证等号左侧与等号右侧统一成偶数，此时，n1 = 0

所以n0 = N

3.一棵完全二叉树的结点数位为531个，那么这棵树的高度为（B）
A 11
B 10
C 8
D 12

5.二叉树的存储结构 

二叉树一般有两个结构，一种是顺序结构，一种是链式结构。

(1)顺序结构

顺序结构存储就是使用数组来存储，一般使用数字只适合表示完全二叉树，因为不是完全二叉树会有空间的浪费。而现实中使用中只有堆才会使用数组来存储。

二叉树顺序存储在物理上是一个数组，在逻辑上是一颗二叉树。

(2)链式存储

二叉树的链式存储结构是指，用链表来表示一棵二叉树，即用链来表示元素的逻辑关系。通常的方法是链表中每个结点右三个域组成，数据域和左右指针域，左右指针分别表示用来给出结点左孩子和右孩子所在的链节点的存储地址。

三、二叉树的顺序结构及实现

普通的二叉树是不适合用数组来存储的，因为可能会存在大量的空间浪费。而完全二叉树更适合使用顺序结构存储。现实中我们通常把堆（完全二叉树）使用顺序结构的数组来存储，需要注意的是这里的堆和操作系统虚拟进程地址空间中的堆是两回事，一个是数据结构，一个是操作系统中管理内存的一块区域分段。

1.堆的概念及结构

如果有一个关键码的集合K={ K_{0}，K_{1}，K_{2}，……，K_{n-1} }，把它的所有元素按完全二叉树的顺序存储方式存储在一个一维数组中，并满足：K_{i} \leqK_{2i+1}且K_{i} \leq K_{2i+2}（K_{i}\geq K_{2i+1} 且 K_{i}\geq K_{2i+2}）i = 0 , 1 , 2……，则称为小堆（大堆）。将根结点最大的堆交租最大堆或大根堆，根结点最小的堆叫做最小堆会小根堆。

2.堆的性质

（1）堆中某个结点的值总是不大于或不小于其父亲结点的值

（2）堆总是一颗完全二叉树

3.堆的实现

<1>堆的创建图示

通过插入数据和向上调整算法实现，后面会有解释

<2>Heap.h

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>


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

//交换函数
void swap(HPDateType* p1, HPDateType* p2);

//初始化和销毁
void HPInit(HP* php);
void HPDestory(HP* php);

//向上调整算法
void AdjustUp(HPDateType* a, int child);
//插入数据
void HPPush(HP* php, HPDateType x);

void AdjustDown(HPDateType* a, int n, int parent);
//删除数据
void HPPop(HP* php);
//返回堆顶的元素
HPDateType HPTop(HP* php);
//判空
bool HPEmpty(HP* php);

<3>Heap.c

(1)交换函数
//交换函数
void swap(HPDateType* p1, HPDateType* p2)
{
	HPDateType tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}
(2)初始化
void HPInit(HP* php)
{
	assert(php);
	php->a = NULL;
	php->capacity = php->size = 0;
}
(3)销毁
void HPDestory(HP* php)
{
	assert(php);
	free(php);
	php->a = NULL;
	php->capacity = php->size = 0;
}
(4)向上调整算法
//向上调整算法
void AdjustUp(HPDateType* 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
			parent = (child - 1) / 2;//重新规划parent
		}
		else
		{
			break;
		}
	}
}
(5)插入数据（建堆）

 堆的创建过程图示：

时间复杂度为：logN 

 

//插入数据
void HPPush(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 fail!");
			return;
		}
		php->a = tmp;
		php->capacity = newcapacity;
	}
	php->a[php->size] = x;//插在数组的结尾
	php->size++;
	AdjustUp(php->a, php->size - 1);//传的是下标，用来找父子关系
}
(6)向下调整算法

我们通过从根结点开始的向下调整算法可以把它调整成一个小堆。向下调整算法的前提：左右子树必须是一堆，才能调整。 

//向下调整算法(前提：左右字树是小堆/左右子树是大堆)
void AdjustDown(HPDateType* a,int n,int parent)
{
	//假设法：先假设左孩子小
	int child = parent * 2 + 1;

	//child >= n说明孩子已经不存在了，超出二叉树范围了(叶子)
	while (child < n)  
	{
		//找出小的那个孩子
		if (a[child] > a[child + 1] && child +1 < n)
		{
			++child;//让右孩子成为小的
		}
		if (a[child] < a[parent])
		{
			swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}
(7)删除数据

删除堆是删除堆顶的数据，将堆顶的数据根最后一个数据交换，然后删除数组最后一个数据，在进行向下调整算法

//删除数据(堆顶的数据)
//不能挪动数据，覆盖删除堆顶数据—>关系错乱
//堆顶数据交换到最后一个数据，再删除最后一个数据，在进行向下调整算法
void HPPop(HP* php)
{
	assert(php);
	assert(php->size > 0);
	swap(&php->a[0], &php->a[php->size - 1]);
	php->size--;//先size--了，缩小数组大小

	//所以调用完AdjustDown()函数后，交换到最后一位的堆顶元素就已经被删除了
	AdjustDown(php->a, php->size, 0);

}
(8)返回栈顶元素
//返回堆顶的元素
HPDateType HPTop(HP* php)
{
	assert(php);
	assert(php->size > 0);

	return php->a[0];
}
(9)判空
//判空
bool HPEmpty(HP* php)
{
	assert(php);
	return php->size == 0;
}

<4>test.c

void TestHeap1()
{
	int a[ ] = { 2,4,5,6,1,7,8,9 };
	HP hp;
	HPInit(&hp);
	for (size_t i = 0; i < sizeof(a) / sizeof(int); i++)
	{
		HPPush(&hp, a[i]);
	}
	while (!HPEmpty(&hp))
	{
		printf("%d ", HPTop(&hp));
		HPPop(&hp);
	}
} 
int main()
{
    TestHeap1();
	return 0;
}

4.堆的应用 

<1>堆排序 

(1)建堆

升序：建大堆

降序：建小堆

 (2)排序

● 向上调整建堆思想：

例如，我们想得到升序，先建好大堆，再将堆的最后一个元素与栈顶元素交换，此时数组的最后一个空间存储的就是集合中的最大元素（位置锁定了），然后对新的堆顶元素进行向下调整之后，栈顶元素就是集合中第二大的元素。再将栈顶元素与数组的倒数第二个位置进行交换，逐此往复。直到所有元素都锁定了。

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

void swap(int* p1, int* p2)
{
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}
void AdjustUp(int* 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
			parent = (child - 1) / 2;//重新规划parent
		}
		else
		{
			break;
		}
	}
}

//堆排序
//->时间复杂度：O(N* logN)
//这里我们把数组当做完全二叉树
void HeapSort(int* a, int n)
{
    //向上调整建堆
	//降序，建小堆 (升序,建大堆)
	for (int  i = 0; i < n; i++)
	{
		AdjustUp(a, i);
	}

	int end = n - 1;
	while (end > 0)
	{
		//把最大的数换到最后一位
		swap(&a[0], &a[end]);
		//在将第一个数向下调整，选出次大的数
		AdjustDown(a, end, 0);
        //最后一位数据被固定，数组的范围缩小
		--end;
	}
}

void TestHeap3()
{
	int a[] = { 5,4,3,16,17,20 };
	HeapSort(a, sizeof(a) / sizeof(int));
}
int main()
{
	TestHeap3();
	return 0;
}

● 向下调整建堆思想 

以最后一个有子树的元素为根结点所形成的树开始建堆（向下调整算法），下来是以倒数第二个有子树的元素为根节点所形成的树建堆，直到以栈顶元素为根结点所形成的树建堆完成。

 

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


#include<stdio.h>
#include<stdlib.h>
void swap(int* p1, int* p2)
{
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

void AdjustDown(int* a, int n,int parent)
{//建小堆
	int child = 2 * parent + 1;//先假设左孩子小
	while (child < n)
	{
		if (a[child] > a[child + 1])
		{
			child++;
		}
		if (a[child] < a[parent])
		{
			swap(&a[child], &a[parent]);
			parent = child;
			child = 2 * parent + 1;
		}
		else
		{
			break;
		}
	}
}

void HPSort(int* a, int n)
{
    //向下调整建堆(从最后一个有子树的元素开始向上建)->666	
    //数组最后一个元素的小标为n-1
	for (int i = (n - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(a, n, i);
	}
}


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

<2>Top—K问题

即求数据集合中前K个最大的元素或最小的元素，一般情况下数据量都比较大。

对于Top—K问题，能想到的最简单直接的方式就是排序

void TestHeap2()
{
	int a[] = { 27,15,19,18,28,34,65,49,25,37 };
	HP hp;
	HPInit(&hp);
	for (size_t i = 0; i < sizeof(a) / sizeof(int); i++)
	{
		HPPush(&hp, a[i]);
	}
	//找出最小的前k个
	int k = 0;
	scanf("%d", &k);
	while (k--)
	{
		printf("%d ", HPTop(&hp));
		HPPop(&hp);
	}
	printf("\n");
}

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

但是：如果数据量非常大，排序就不太可取了（可能数据都不能快速全部加载到内存中）。

最佳的方式就是用堆来解决。

(1)用数据集合中前K个元素来建堆——>O(K)

求前K个最大的元素，则建小堆

求前K个最小的元素，则建大堆

(2)用剩余的N-K个元素一次与堆顶元素进行比较，不满足则替换堆顶元素——>O((N-K)*logN)

将剩余的N-K个元素一次与对顶元素比较完后，堆中剩余的K歌元素就是所求的前K个最小的或最大的元素。

合计时间复杂度是O(N)

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

void swap(int* p1, int* p2)
{
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

void AdjustDown(int* a, int n,int parent)
{//建小堆
	int child = 2 * parent + 1;//先假设左孩子小
	while (child < n)
	{
		if (a[child] > a[child + 1])
		{
			child++;
		}
		if (a[child] < a[parent])
		{
			swap(&a[child], &a[parent]);
			parent = child;
			child = 2 * parent + 1;
		}
		else
		{
			break;
		}
	}
}

void PrintTopK(int* a, int n, int k)
{
	// 1. 建堆--用a中前k个元素建堆
	for (int i = (k - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(a, n, i);//小堆
	}
	// 2. 将剩余n-k个元素依次与堆顶元素交换，不满则则替换
	for (int j = k; j < n-1; j++)
	{
		if (a[0] < a[j])
		{
			a[0] = a[j];
			AdjustDown(a, n, 0);
		}
	}
	
	for (int s = 0; s < k - 1; s++)
	{
		printf("%d ", a[s]);
	}
	printf("\n");
}
void TestTopk()
{
	int n = 10000;
	int* a = (int*)malloc(sizeof(int) * n);
	srand(time(0));
	for (size_t i = 0; i < n; ++i)
	{
		a[i] = rand() % 1000000;
	}
	a[5] = 1000000 + 1;
	a[1231] = 1000000 + 2;
	a[531] = 1000000 + 3;
	a[5121] = 1000000 + 4;
	a[115] = 1000000 + 5;
	a[2335] = 1000000 + 6;
	a[9999] = 1000000 + 7;
	a[76] = 1000000 + 8;
	a[423] = 1000000 + 9;
	a[3144] = 1000000 + 10;
	printf("最大的前k个数\n");
	int k;
	scanf("%d", &k);
	PrintTopK(a, n, k);
}
int main()
{
	TestTopk();
	return 0;
}

另一种写法，在文件中生成： 

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() % 1000000;
		fprintf(fin, "%d\n", x);
	}

	fclose(fin);
}

void HeapTest()
{
	int k;
    printf("请输入K:");
	scanf("%d", &k);
	int* a = (int*)malloc(sizeof(int) * k);
	if (a == NULL)
	{
		perror("malloc error");
		return;
	}

	//打开文件，读前k个数
	const char* file = "data.txt";
	FILE* fout = fopen(file, "r");
	if (fout == NULL)
	{
		perror("fopen error");
		return;
	}
	for (int i = 0; i < k; i++)
	{
		fscanf(fout,"%d", &a[i]);
	}
	//建有k个数的小堆
	for (int i = (k - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(a, k, i);
	}
	//读取剩下的N-K个
	int x = 0;
	while (fscanf(fout,"%d", &x) > 0)
	{
		if (a[0] < x)
		{
			a[0] = x;
			AdjustDown(a, k, 0);
		}
	}
	//打印
	for (int i = 0; i < k; i++)
	{
		printf("%d ", a[i]);
	}
	printf("\n");
}

int main()
{
    CreateNDate();
	HeapTest();
	return 0;
}

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

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

相关文章

【SQL学习进阶】从入门到高级应用（六）

【SQL学习进阶】从入门到高级应用（六）

文章目录 ✨数据处理函数✨数字相关✨rand()和rand(x)✨round(x)和round(x,y)四舍五入✨truncate(x, y)舍去✨ceil与floor ✨空处理✨日期和时间相关函数✨获取当前日期和时间✨获取当前日期✨获取当前时间✨获取单独的年、月、日、时、分、秒✨date_add函数✨date_format日期格…
阅读更多...
Netty SSL双向验证

Netty SSL双向验证

Netty SSL双向验证 1. 环境说明2. 生成证书2.1. 创建根证书 密钥证书2.2. 生成请求证书密钥2.3. 生成csr请求证书2.4. ca证书对server.csr、client.csr签发生成x509证书2.5. 请求证书PKCS#8编码2.6. 输出文件 3. Java代码3.1. Server端3.2. Client端3.3. 证书存放 4. 运行效果4…
阅读更多...
C++ 多重继承的内存布局和指针偏移

C++ 多重继承的内存布局和指针偏移

在 C 程序里&#xff0c;在有多重继承的类里面。指向派生类对象的基类指针&#xff0c;其实是指向了派生类对象里面&#xff0c;该基类对象的起始位置&#xff0c;该位置相对于派生类对象可能有偏移。偏移的大小&#xff0c;等于派生类的继承顺序表里面&#xff0c;排在该类前面…
阅读更多...
Python中Web开发-Django框架

Python中Web开发-Django框架

大家好&#xff0c;本文将带领大家进入 Django 的世界&#xff0c;探索其强大的功能和灵活的开发模式。我们将从基础概念开始&#xff0c;逐步深入&#xff0c;了解 Django 如何帮助开发人员快速构建现代化的 Web 应用&#xff0c;并探讨一些最佳实践和高级技术。无论是初学者还…
阅读更多...
SM2259XT2、SM2259XT3量产工具开启“调整不对称CH/CE组态”功能

SM2259XT2、SM2259XT3量产工具开启“调整不对称CH/CE组态”功能

自己摸索的SM2259XT2、SM2259XT3量产工具开启“调整不对称CH/CE组态”功能。在量产部落下载SM2259XT2量产工具后&#xff0c;解压量产工具压缩包&#xff0c;找到并打开量产工具文件夹中的“UFD_MP”文件夹&#xff0c;用记事本或者Notepad打开“Setting.set”文件&#xff0c;…
阅读更多...
Vue3实战笔记（53）—奇怪+1，VUE3实战模拟股票大盘工作台

Vue3实战笔记（53）—奇怪+1，VUE3实战模拟股票大盘工作台

文章目录 前言一、实战模拟股票大盘工作台二、使用步骤总结 前言 实战模拟股票大盘工作台 一、实战模拟股票大盘工作台 接上文&#xff0c;这两天封装好的组件直接应用,上源码&#xff1a; <template><div class"smart_house pb-5"><v-row ><…
阅读更多...
Docker管理工具Portainer忘记admin登录密码

Docker管理工具Portainer忘记admin登录密码

停止Portainer容器 docker stop portainer找到portainer容器挂载信息 docker inspect portainer找到目录挂载信息 重置密码 docker run --rm -v /var/lib/docker/volumes/portainer_data/_data:/data portainer/helper-reset-password生成新的admin密码&#xff0c;使用新密…
阅读更多...
若依分页问题排查

若依分页问题排查

无限分页数据返回 一、问题排查1.1 代码排查1.2 sql排查1.3 原因分析 二、问题修复 项目使用了 若依的框架&#xff0c;前端反馈了一个问题&#xff0c;总记录条数只有 48条的情况下&#xff0c;传入的 页数时从6~~无穷大&#xff0c;每页大小为10, 此时还能返回数据&#xff0…
阅读更多...
SpringMVC框架学习笔记（四）：模型数据 以及 视图和视图解析器

SpringMVC框架学习笔记（四）：模型数据 以及 视图和视图解析器

1 模型数据处理-数据放入 request 说明&#xff1a;开发中, 控制器/处理器中获取的数据如何放入 request 域&#xff0c;然后在前端(VUE/JSP/...)取出显 示 1.1 方式 1: 通过 HttpServletRequest 放入 request 域 &#xff08;1&#xff09;前端发送请求 <h1>添加主人…
阅读更多...
浅谈线性化

浅谈线性化

浅谈线性化 原文&#xff1a;浅谈线性化 - 知乎 (zhihu.com) All comments and opinions expressed on Zhihu are mine alone and do not necessarily reflect those of my employers, past or present. 本文内容所有内容仅代表本人观点&#xff0c;和Mathworks无关 (这里所说…
阅读更多...
视频汇聚EasyCVR视频监控云平台对接GA/T 1400视图库对象和对象集合XMLSchema描述

视频汇聚EasyCVR视频监控云平台对接GA/T 1400视图库对象和对象集合XMLSchema描述

GA/T 1400协议主要应用于公安系统的视频图像信息应用系统&#xff0c;如警务综合平台、治安防控系统、交通管理系统等。在城市的治安监控、交通管理、案件侦查等方面&#xff0c;GA/T 1400协议都发挥着重要作用。 以视频汇聚EasyCVR视频监控资源管理平台为例&#xff0c;该平台…
阅读更多...
探索UWB模块的多功能应用——UWB技术赋能智慧生活

探索UWB模块的多功能应用——UWB技术赋能智慧生活

超宽带&#xff08;Ultra-Wideband, UWB&#xff09;技术&#xff0c;凭借其高精度、低功耗和强抗干扰能力&#xff0c;正在成为智能家居领域的一项关键技术。UWB模块的应用不仅提高了智能家居设备的性能&#xff0c;还为家庭安全、设备管理和用户体验带来了显著的改善。 UWB模…
阅读更多...
java基础-chapter15（io流）

java基础-chapter15（io流）

io流&#xff1a;存储和读取数据的解决方案 I:input O:output io流的作用&#xff1a;用于读写数据&#xff08;本地文件,网络&#xff09; io流按照流向可以分为&#xff1a; 输出流&#xff1a;程序->文件 输入流&#xff1a;文件->程序 io流按照操作文件…
阅读更多...
Qt Creator（Qt 6.6）拷贝一行

Qt Creator（Qt 6.6）拷贝一行

Edit - Preference - Environment&#xff1a; 可看到&#xff0c;拷贝一行的快捷键是&#xff1a; ctrl Ins
阅读更多...
使用KEPServer连接欧姆龙PLC获取对应标签数据（标签值类型改为字符串型）

使用KEPServer连接欧姆龙PLC获取对应标签数据（标签值类型改为字符串型）

1.创建通道&#xff08;通道&#xff09;&#xff0c;&#xff08;选择对应的驱动&#xff0c;跟当前型号PLC型号对应&#xff09;。 2.创建设备&#xff0c;&#xff08;填入IP地址以及欧姆龙的默认端口号&#xff1a;44818&#xff09; 3.创建对应的标签。这里关键讲诉下字…
阅读更多...
医院该如何应对网络安全?

医院该如何应对网络安全?

在线医生咨询受到很多人的关注&#xff0c;互联网医疗行业的未来发展空间巨大&#xff0c;但随着医院信息化建设高速发展 医院积累了大量的患者基本信息、化验结果、电子处方、生产数据和运营信息等数据 这些数据涉及公民隐私、医院运作和发展等多因素&#xff0c;医疗行业办…
阅读更多...
[C/C++]_[初级]_[在Windows平台上导出DLL函数接口的一些疑问]

[C/C++]_[初级]_[在Windows平台上导出DLL函数接口的一些疑问]

场景 最近看了《COM本质论》里关于如何设计基于抽象基类作为二进制接口，把编译器和链接器的实现隐藏在这个二进制接口中，从而使用该DLL时不需要重新编译。在编译出C接口时，发现接口名直接是函数名，比如BindNativePort,怎么不是_BindNativePort?说明 VC++导出的函数默认是使…
阅读更多...
Notepad++ 常用

Notepad++ 常用

File Edit search view Encoding Language Settings Tools Macro Run Plugins Window 文件 编辑 搜索 视图 编码 语言 设置 工具 宏 运行 插件 窗口 快捷方式 定位行 &#xff1a;CTRL g查找&#xff1a; CTRL F替换&am…
阅读更多...
精准检测，安全无忧：安全阀检测实践指南

精准检测，安全无忧：安全阀检测实践指南

安全阀作为一种重要的安全装置&#xff0c;在各类工业系统和设备中发挥着举足轻重的作用。 它通过自动控制内部压力&#xff0c;有效防止因压力过高而引发的设备损坏和事故风险&#xff0c;因此&#xff0c;对安全阀进行定期检测&#xff0c;确保其性能完好、工作可靠&#xf…
阅读更多...
Ubuntu安装GCC编译器

Ubuntu安装GCC编译器

GCC编译器安装 GCC编译器安装切换软件源（换成国内的服务器）1 、创建一个文本文档并命名为“sources.list”2 、复制软件源列表清华源：阿里源：3 、把修改之后的.list 文件覆盖原有的文件4 、更新软件列表5 、安装6 、检查是否安装成功7、GCC 编译器：GCC编译器安装 这里演示…
阅读更多...
最新文章

Copyright @ 2022~2023