初阶数据结构：树---堆

目录

一、树的概念

二、树的构成

（一）、树的基本组成成分

（二）、树的实现方法

三、树的特殊结构------二叉树

（一）、二叉树的概念

（二）、二叉树的性质

（三）、特殊二叉树

1、满二叉树

2、完全二叉树

四、二叉树的结构------顺序存储------堆

（一）、二叉树的顺序存储

（二）、堆的概念

（三）、堆的实现

1、堆的构建

2、堆的插入

3、堆的删除

4、获取堆顶元素、堆的有效元素个数和堆的判空

（四）、堆排序

1、堆排序的概念

2、堆排序的实现

（五）、TOP-K问题

在数据结构的广阔领域中，树与堆犹如两颗璀璨的明星，散发着独特的魅力。它们不仅是计算机科学的基础，更是解决各种复杂问题的有力武器。树，以其独特的层次结构，模拟了现实世界中的众多场景，如文件系统的目录结构、公司的组织架构等，让我们能够清晰地梳理和管理复杂的数据关系。而堆，作为一种特殊的完全二叉树，凭借其高效的插入、删除和查找操作，在优先队列、排序算法等领域发挥着关键作用 。那树究竟是什么呢？

一、树的概念

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

树有一个特殊的结点，称为根结点，根节点没有前驱结点

任何一颗树都是由根和子树构成。

树中，子树是不相交的，除了根节点外，每个节点有且仅有一个父节点；

一颗有N个节点的树有N-1条边（根节点无前驱节点，故少一条）；

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

二、树的构成

（一）、树的基本组成成分

让我们来了解一下一颗树的组成结构吧。

  • 节点的度：一个节点含有的子树的个数称为该节点的度； 如上图：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）棵互不相交的树的集合称为森林(也即我们后续需要学到的并查集)；

（二）、树的实现方法

我们通过上述已经了解到树是递归式的，那我们如何实现上图所示的树呢？

看了上图后是不是一下子就想到了链表，链表是由一个一个的节点链接构成，上图所示的树也是由一个一个的节点构成，那我们能不能按实现链表的思想来实现树呢？

但问题是，链表是线性结构，每个节点只需要与一个节点链接即可，但树可不同，有的节点和一个节点链接，有的和几个节点链接，构成节点的结构体可不能随情况不同而变化。那我们能不能对链接不同个节点分别构建节点结构体呢？链接节点个数的情况可以是无限的，真这样做只能说吃力不讨好。这就不得不提到一个非常巧妙的方法--------左孩子右兄弟表示法。

先来看看它的概念:

树中的每个节点除了自身的数据域，还设置两个指针域，分别指向该节点的第一个孩子节点和它的右兄弟节点。节点的左指针指向其第一个孩子，右指针指向其紧邻的右兄弟。若节点没有孩子或右兄弟，则相应指针为 None 或 NULL 。

代码如下:

typedef struct TreeNode
{
   //存储数据
   int data;
   //存储左孩子指针
   struct TreeNode* left;
   //存储右兄弟地址
   struct TreeNode* right;
}TreeNode;

通过这个表示法，上图的树就变成了这样：

它将这样一棵普通树转化为一棵二叉树。这一转化意义非凡，因为二叉树的算法和操作相对成熟，我们可以借助二叉树的处理方式来解决普通树的问题，大大简化了操作难度。而且左孩子右兄弟表示法在空间利用上表现出色。它不再需要为每个节点预留大量不确定的子节点指针，节省了内存空间。在操作效率方面，基于二叉树的遍历算法，如前序遍历、中序遍历和后序遍历，都能直接应用到由左孩子右兄弟表示法转化而来的二叉树上，使得树的遍历、查找、插入和删除等操作都能以相对较低的时间复杂度完成。

对于当前的我们来说，我们对于树，只需要做到了解即可，我们的侧重点是树的一种特殊结构二叉树。

那什么是二叉树呢？重点在于二叉两个字。

三、树的特殊结构------二叉树

（一）、二叉树的概念

一棵二叉树是结点的一个有限集合，该集合:

1. 或者为空

2. 由一个根节点加上两棵别称为左子树和右子树的二叉树组成

二叉树并不是每一个节点都与另外两个节点链接。二叉树只是不存在度大于2的节点。且二叉树是有左右之分的，它的次序不能颠倒，故二叉树是有序的。如图所示：

上图所示皆为二叉树，因此在对待二叉树时，一定不要忘记NULL，且对于任意的二叉树都是由以下几种情况复合而成的：

（二）、二叉树的性质

  1.  若规定根节点的层数为1，则一棵非空二叉树的第i层上最多有（2^(i-1)） 个结点。
  2.  若规定根节点的层数为1，则深度为h的二叉树的最大结点数是(2^h-1)。
  3.  对任何一棵二叉树, 如果度为0其叶结点个数为 n， 度为2的分支结点个数为n-1。
  4. 若规定根节点的层数为1，具有n个结点的满二叉树的深度，h= log(n+1)。（log(n+1)是以2为底，(n+1)为对数）。
  5. 对于具有n个结点的完全二叉树，如果按照从上至下从左至右的数组顺序对所有节点从0开始编号，则对 于序号为i的结点有：  
  • 1. 若i>0，i位置节点的双亲序号：(i-1)/2；i=0，i为根节点编号，无双亲节点。
  • 2. 若2i+1=n否则无左孩子。
  • 3. 若2i+2=n否则无右孩子。

（三）、特殊二叉树

在二叉数中，有一些特殊的二叉树，分别是满二叉树和完全二叉树。同时，满二叉树也可以说是一种特殊的二叉树。

1、满二叉树

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

为什么说满二叉树的节点总数为（2^k-1）呢？

也即第k层节点个数为（2^(k-1))，构成了一个等比数列。使用等比数列求和公式可得（2^k-1)。

2、完全二叉树

完全二叉树：完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树而引出来的。对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树。 

完全二叉树其实就是前n-1层都是满的，最后一层要从左到右是连续的。

完全二叉树的节点范围为[2^(n-1),2^n-1]，高度范围为[logN+1,log(N+1)]。

四、二叉树的结构------顺序存储------堆

（一）、二叉树的顺序存储

二叉树有两种结构，分别是顺序存储和链式存储。从字面上看，我们就可以知道，分别是在数组上和链表上来存储二叉树。

二叉树的链式存储结构是指，用链表来表示一棵二叉树，即用链来指示元素的逻辑关系。 通常的方法是 链表中每个结点由三个域组成，数据域和左右指针域，左右指针分别用来给出该结点左孩子和右孩子所 在的链结点的存储地址 。链式结构又分为二叉链和三叉链，当前我们学习中一般都是二叉链，后面 如红黑树等会用到三叉链。

二叉树在数组上存储就构成了我们这次博客的主题------堆。

二叉树顺序存储的逻辑结构和物理结构是不一样的，我们需要通过数组去看到存储的二叉树是不容易的，因此，要想学好，还是要多画图。二叉树的顺序存储逻辑结构如下图所示：

二叉树顺序存储的物理结构如下图所示：

若想要学好堆，就不得不对父节点和子节点在顺序存储中的关系记忆深刻：

我们假设parent为父节点在数组中的下标，children为子节点在数组中的下标，则有：

  • parent=(children-1)/2;
  • leftchildren=parent*2+1;
  • rightchildren=parent*2+2;

注意：使用数组存储二叉树会不合适，因为会浪费很多空间。数组存储表示二叉树只适合完全二叉树。如图所示：

现实中我们通常把堆(一种二叉树)使用顺序结构的数组来存储，需要注意的是这里的堆和操作系统 虚拟进程地址空间中的堆是两回事，一个是数据结构，一个是操作系统中管理内存的一块区域分段。

（二）、堆的概念

堆是一种特殊的完全二叉树，它满足以下两个重要特性：

  • 结构性：堆是一棵完全二叉树，这意味着除了最后一层外，每一层的节点都是满的，且最后一层的节点从左到右依次排列 。这种规整的结构使得堆可以高效地使用数组进行存储。在一个包含 10 个元素的堆中，其完全二叉树结构可以清晰地映射到数组中，根节点存储在数组的第一个位置，根节点的左子节点存储在数组的第二个位置，右子节点存储在第三个位置，以此类推。通过这种方式，利用数组下标就能快速定位节点的父子关系，大大提高了操作效率。
  • 有序性：堆分为大顶堆(大根堆或大堆)和小顶堆(小根堆或小堆) 。在大顶堆中，每个节点的值都大于或等于其左右子节点的值，堆顶元素是堆中的最大值 。而在小顶堆中，每个节点的值都小于或等于其左右子节点的值，堆顶元素是堆中的最小值 。以一个存储学生成绩的大顶堆为例，堆顶元素就是所有学生中的最高成绩，通过这种有序性，在需要获取最大值或最小值时，能够快速定位到目标元素，节省查找时间。

堆的功能：

  • 堆的构建 void HeapCreate(Heap* hp, int* a, int n);此处堆的构建是对于一个存满数据的数组进行堆的构建，它是先申请空间，然后使用堆的插入函数将数组中的元素逐一插入来构建堆。
  •  堆的销毁 void HeapDestory(Heap* hp);
  •  堆的插入 void HeapPush(Heap* hp, HPDataType x);
  •  堆的删除 void HeapPop(Heap* hp);
  •  取堆顶的数据 HPDataType HeapTop(Heap* hp);
  • 堆的数据个数 int HeapSize(Heap* hp);
  • 堆的判空 int HeapEmpty(Heap* hp);

（三）、堆的实现

我们需要先定义一个结构体，结构体和顺序表一样，毕竟都是在数组上进行存储，代码如下：

typedef struct Heap
{
	int* data;//数组，方便扩容
	int size;//计数器
	int capicity;//容量大小
}Heap;

1、堆的构建

我们先来看如何对一个存满数据的数组进行堆的构建，也即建堆。代码如下：

//两数交换函数
void Swap(int* a, int* b)
{
	int c = *a;
	*a = *b;
	*b = c;
}
void HeapCreate(int* a, int n)
{
	//这里建的是大根堆，故父节点一定要比子节点大
	//循环遍历要建堆的数组的每一个数
	for (int i = 0; i < n; i++)
	{
		int children = i;
		int parent = (children - 1) / 2;
		//当子节点都小于0时，父节点一定小于0，如果用父节点>=0，来做
		//循环结束条件，会导致越界访问或者缺失比较数据
		while (children > 0)
		{
			//建的是大根堆
			if (a[parent] < a[children])
			{
				//父节点比子节点小，就互换，让大的来当父节点
				Swap(&a[parent], &a[children]);
				//循环的递近条件，让大的节点互换后与当前节点的父节点再度比较，直到小于
				children = parent;
				parent = (children - 1) / 2;
			}
			else
			{
				break;
			}
		}
	}
}
int main()
{
	int a[10] = { 1,0,5,6,3,2,4,9,8,7 };
	HeapCreate(a, 10);
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", a[i]);
	}
	return 0;
}

看图解释：

上述代码结果为：

教你一个简便的方法快速判断是否为堆：

开始时：

运用画图功能将其拼成一个二叉树，根据大根堆或者小根堆的概念进行判断，如下图就是一个大根堆。如果没有电脑这种方法就不可行吗？当然可行。我们可以直接看数组，运用堆的性质比较即可。

而另一种堆的构建，堆的初始化、堆的扩容，堆的销毁和顺序表一样。代码如下：

//堆的初始化
void HeapInte(Heap* hp)
{
	assert(hp);
	hp->data = (int*)malloc(sizeof(int) * 4);
	if (hp->data == NULL)
	{
		perror("Inte::malloc");
		return;
	}
	hp->size = 0;
	hp->capicity = 4;
}
//动态空间扩容
void HeapCapicity(Heap* hp)
{
	assert(hp);
	if (hp->capicity == hp->size)
	{
		hp->data = (int*)realloc(hp->data, hp->capicity * 2 * sizeof(int));
		if (hp->data == NULL)
		{
			perror("Capicity::realloc");
			return;
		}
		hp->capicity *= 2;
		printf("扩容成功\n");
	}
}
//堆的销毁
void HeapDestory(Heap* hp)
{
	assert(hp);
	free(hp->data);
	hp->data = NULL;
	hp->capicity =hp->size=0;
	printf("销毁成功\n");
}

2、堆的插入

堆的插入类似于顺序表的尾删，只是再插入后还需通过向上调整建堆使得数组上的数据始终符合堆的性质。

什么是向上调整建堆呢？

向上调整建堆是一种构建堆的方法，通常用于在已有部分堆结构的基础上插入新元素时维护堆的性质，也可以用来从零开始构建堆。对于大顶堆，堆中每个节点的值都大于或等于其子节点的值；对于小顶堆，堆中每个节点的值都小于或等于其子节点的值。

向上调整的核心思想是：从当前节点开始，将其与父节点比较，如果不满足堆的性质（例如在大顶堆中当前节点的值大于父节点的值），则交换当前节点和父节点，然后继续向上比较，直到满足堆的性质或者到达根节点。

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

而上述我们直接对数组进行建堆操作，而不另开辟空间的代码中使用的就是向上调整建堆。代码如下：

void HeapPush(Heap* hp, int x)
{
	assert(hp);
	//检查空间是否充足，不足则扩容
	HeapCapicity(hp);
	//插入数据
	hp->data[hp->size] = x;
	//我们不能确定插入后是否符合，故采用向上调整法。
	int chile = hp->size;
	int parent = (chile - 1) / 2;
	//和之前直接对数组操作建堆一样
	while (chile > 0)
	{
		if (hp->data[chile] > hp->data[parent])
		{
			Swap(&hp->data[chile], &hp->data[parent]);
			chile = parent;
			parent = (chile - 1) / 2;
		}
		else
		{
			break;
		}
	}
	hp->size++;
}

看到这，你是不是有一个疑惑，既然有向上调整建堆，那是不是还有向下调整建堆呢？

当然是有的，而且向下调整建堆比向上调整建堆效率更高。那向下调整建堆又该如何做呢？

向下调整建堆是一种高效的建堆算法，其核心思想是从最后一个非叶子节点开始，依次对每个节点进行向下调整操作，使得每个子树都满足堆的性质，最终整个树成为一个堆。

对于一个包含 n个元素的数组表示的完全二叉树，最后一个非叶子节点的索引是 (n-2)/2。也可以直接找最后一个元素的父节点，也即最后一个非叶子节点。从这个节点开始，依次向前遍历每个非叶子节点，对其进行向下调整操作，将以该节点为根的子树调整为堆。

向下调整操作是指：比较当前节点与其左右子节点的值，如果不满足堆的性质（对于大顶堆，当前节点的值应大于等于其子节点的值；对于小顶堆，当前节点的值应小于等于其子节点的值），则将当前节点与值最大（大顶堆）或最小（小顶堆）的子节点交换，然后继续对交换后的子节点进行向下调整，直到满足堆的性质或者到达叶子节点。

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

以下图为例：

代码如下：

//n-1为最后一个元素的下标，（下标-1）/2得到父节点
for (int i = (n - 2) / 2; i >= 0; i--)
{
	int parent = i;
	//因为父节点的左右子节点始终在一起，故右子节点下标为左子节点下标加1
	//因此只需一个变量
	int child = parent * 2 + 1;
	//向下调整操作，左孩子下标不要超过数组元素个数并且右孩子下标也不要超过
	while (child<n)
	{
		//因为是建大堆，故父节点要和子节点大的比较
		//如果是建小堆，则父节点要和子节点小的比较
		if ((child + 1) < n && a[child] < a[child + 1])
		{
			child++;
		}
		if (a[parent] < a[child])
		{
			Swap(&a[parent], &a[child]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

3、堆的删除

堆的删除如果只是删除堆底的话那就没什么好说的，只需要计数器size减一即可，且不会破坏堆的结构，但如果是删除堆顶元素呢？

如果删除堆顶元素，那么不但要将堆顶元素后的所有元素往前移一下，而且堆的结构也被破坏了，需要重新构建堆。这样的话过于麻烦。有没有什么更好的办法呢？

我们可以让堆顶元素和堆底元素互换，然后像删除堆底元素一样删除，最后使用向下调整法重构堆，以此来达到删除堆顶元素的操作，且效率很高。代码如下：

void HeapPop(Heap* hp)
{
	assert(hp);
	if (hp->size == 0)
	{
		printf("无数据\n");
		return;
	}
	//先交换堆顶元素和堆底元素
	Swap(&hp->data[0], &hp->data[hp->size - 1]);
	hp->size--;
	int parent = 0;
	int leftchile = parent * 2 + 1;
	//向下调整建堆
	while ((leftchile+1)<hp->size && leftchile < hp->size)
	{
		if (hp->data[leftchile] > hp->data[leftchile + 1])
		{
			if (hp->data[parent] < hp->data[leftchile])
			{
				Swap(&hp->data[parent],&hp->data[leftchile]);
				parent = leftchile;
				leftchile = leftchile * 2 + 1;
			}
			else
			{
				return;
			}
		}
		else
		{
			if (hp->data[parent] < hp->data[leftchile+1])
			{
				Swap(&hp->data[parent], &hp->data[leftchile+1]);
				parent = leftchile+1;
				leftchile = (leftchile+1) * 2 + 1;
			}
			else
			{
				return;
			}
		}
	}
}

4、获取堆顶元素、堆的有效元素个数和堆的判空

这三个功能的实现比较简单，因为堆就是存储在数组上的。因此代码如下：

int HeapTop(Heap* hp)
{
	assert(hp);
	return hp->data[0];
}
int HeapSize(Heap* hp)
{
	assert(hp);
	return hp->size;
}
int HeapEmpty(Heap* hp)
{
	assert(hp);
	return hp->size;
}

自此，一个堆就完成了。那么堆有什么用处呢？毕竟我们不会学一个没有用处的结构。我们或许都听过在排序中有一个堆排序。堆可以用来排序吗？

当然可以，而且它的速度还是比较快的。那我们如何去实现堆排序呢？

（四）、堆排序

1、堆排序的概念

堆排序（Heap Sort）是一种基于堆这种数据结构设计的高效排序算法，它利用堆的特性进行排序，时间复杂度为 O(N*longN)，且是一种不稳定的排序算法。

堆排序的基本思想是利用堆的特性，先将待排序的数组构建成一个堆，然后不断地将堆顶元素（最大值或最小值）与堆的最后一个元素交换，再对剩余的元素重新调整为堆，重复这个过程直到整个数组有序。

它的排序步骤只有两步：

  1. 建堆：将待排序的数组构建成一个堆。可以使用向上调整建堆或向下调整建堆的方法，其中向下调整建堆的时间复杂度为O(N)，更为常用。
  2. 排序：将堆顶元素与堆的最后一个元素交换，然后对剩余的元素重新调整为堆，重复这个过程直到整个数组有序。

注意：排升序建大堆，排降序建小堆。

2、堆排序的实现

代码如下：

建大堆排升序，使用向下调整建堆法。（这是指下图代码）

//堆排序
void Swap(int* a, int* b)
{
	int c = *a;
	*a = *b;
	*b = c;
}
void HeapSortdown(int* a, int n)
{
	//先建堆(向下调整建堆)
	//n-1为最后一个元素的下标，（下标-1）/2得到父节点
	for (int i = (n - 2) / 2; i >= 0; i--)
	{
		int parent = i;
		//因为父节点的左右子节点始终在一起，故右子节点下标为左子节点下标加1
		//因此只需一个变量
		int child = parent * 2 + 1;
		//向下调整操作，左孩子下标不要超过数组元素个数并且右孩子下标也不要超过
		while (child<n)
		{
			//因为是建大堆，故父节点要和子节点大的比较
			//如果是建小堆，则父节点要和子节点小的比较
			if ((child + 1) < n && a[child] < a[child + 1])
			{
				child++;
			}
			if (a[parent] < a[child])
			{
				Swap(&a[parent], &a[child]);
				parent = child;
				child = parent * 2 + 1;
			}
			else
			{
				break;
			}
		}
	}
	//向下调整
	for (int i = n-1; i >0; i--)
	{
		Swap(&a[0], &a[i]);
		int parent = 0;
		int child = parent * 2 + 1;
		while ( child <i)
		{
			if ((child + 1) < i && a[child] < a[child + 1])
			{
				child++;
			}
			if (a[parent] < a[child])
			{
				Swap(&a[parent], &a[child]);
				parent = child;
				child = parent * 2 + 1;
			}
			else
			{
				break;
			}
		}
	}
}

建小堆排降序，使用向上调整建堆法。（这是指下图代码）

void HeapSortup(int* a, int n)
{

	//先建堆(向上调整建堆,建小堆)
	for (int i = 1; i < n; i++)
	{
		int chile = i;
		int parent = (chile - 1) / 2;
		while (chile > 0)
		{
			if (a[chile] < a[parent])
			{
				Swap(&a[chile], &a[parent]);
				chile = parent;
				parent = (chile - 1) / 2;
			}
			else
			{
				break;
			}
		}
	}
	//向下调整
	for (int i = n-1; i>0;i--)
	{
		Swap(&a[0], &a[i]);
		int parent = 0;
		int child = parent * 2 + 1;
		while (child <i)
		{
			if ((child + 1) < i && a[child] > a[child + 1])
			{
				child++;
			}
			if (a[parent] > a[child])
			{
				Swap(&a[parent], &a[child]);
				parent = child;
				child = parent * 2 + 1;
			}
			else
			{
				break;
			}
		}
	}
}

同时，堆不仅仅只用于排序，它还涉及到一个问题------TOP-K问题。

（五）、TOP-K问题

TOP-K问题：即求数据结合中前K个最大的元素或者最小的元素，一般情况下数据量都比较大。 比如：专业前10名、世界500强、富豪榜、游戏中前100的活跃玩家等。

对于Top-K问题，能想到的最简单直接的方式就是排序，但是：如果数据量非常大，排序就不太可取了(可能数据都不能一下子全部加载到内存中)。最佳的方式就是用堆来解决。

我们怎么利用堆来解决TOP-K问题呢？

我们知道大堆堆顶是最大的元素，小堆堆顶是最小元素，我们如果要求n个数的前50，那我们就建一个小堆，先存储n个数中的50个数，此时堆顶元素就是这50个元素中最小的，我们再遍历除这50个数外的所有数，让这些数都与堆顶元素比较，如果大于，则让大于的数和堆顶元素互换，并使用向下调整法保持堆为小堆状态，当遍历结束后，堆中的元素就为n个数中前50的数。

同理，求n个数中后50的数，只需建大堆重复上述步骤即可。这里代码就不给出了，大家可以自己尝试一下，如果逻辑依旧想不通，一定要画图，一定要画图，一定要画图，重要的事说三遍！！！

如果代码出现了问题，一定要灵活的使用调试功能！！！

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

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

相关文章

学习笔记：机器学习中的数学原理（一）

学习笔记：机器学习中的数学原理（一）

1. 集合 集合分为有限集和无限集&#xff1b; 对于有限集&#xff0c;两集合元素数相等即为等势&#xff1b; 对于无限集&#xff0c;两集合元素存在一一映射关系即为等势&#xff1b; 无限集根据是否与正整数集等势分为可数集和不可数集。 2. sigmoid函数&#xff08;也叫…
阅读更多...
音频进阶学习十一——离散傅里叶级数DFS

音频进阶学习十一——离散傅里叶级数DFS

文章目录 前言一、傅里叶级数1.定义2.周期信号序列3.表达式DFSIDFS参数含义 4.DFS公式解析1&#xff09;右边解析 T T T、 f f f、 ω \omega ω的关系求和公式N的释义求和公式K的释义 e j ( − 2 π k n N ) e^{j(\frac{-2\pi kn}{N})} ej(N−2πkn​)的释义 ∑ n 0 N − 1 e…
阅读更多...
互联网分布式ID解决方案

互联网分布式ID解决方案

业界实现方案 1. 基于UUID 2. 基于DB数据库多种模式(自增主键、segment) 3. 基于Redis 4. 基于ZK、ETCD 5. 基于SnowFlake 6. 美团Leaf(DB-Segment、zkSnowFlake) 7. 百度uid-generator() 基于UUID生成唯一ID UUID生成策略 推荐阅读 DDD领域驱动与微服务架构设计设计模…
阅读更多...
BUU28 [GXYCTF2019]BabySQli1

BUU28 [GXYCTF2019]BabySQli1

常规万能密码&#xff0c;发现登不上去 过滤掉了or&#xff0c;&#xff0c;当尝试了n种方法以后&#xff0c;最关键的是发现()居然也被过滤了 哈哈&#xff0c;那玩个淡&#xff0c; 再搜wp&#xff01;&#xff01; 当输入admin的时候&#xff0c;提示密码错误&#xff0…
阅读更多...
数据分析：企业数字化转型的金钥匙

数据分析：企业数字化转型的金钥匙

引言&#xff1a;数字化浪潮下的数据金矿 在数字化浪潮席卷全球的背景下&#xff0c;有研究表明&#xff0c;只有不到30%的企业能够充分利用手中掌握的数据&#xff0c;这是否让人深思&#xff1f;数据已然成为企业最为宝贵的资产之一。然而&#xff0c;企业是否真正准备好从数…
阅读更多...
git SourceTree 使用

git SourceTree 使用

Source Tree 使用原理 文件的状态 创建仓库和提交 验证 再克隆的时候发发现一个问题&#xff0c;就是有一个 这个验证&#xff0c;起始很简单 就是 gitee 的账号和密码&#xff0c;但是要搞清楚的是账号不是名称&#xff0c;我之前一直再使用名称登录老是出问题 这个很简单的…
阅读更多...
485网关数据收发测试

485网关数据收发测试

目录 1.UDP SERVER数据收发测试 使用产品&#xff1a; || ZQWL-GW1600NM 产品||【智嵌物联】智能网关型串口服务器 1.UDP SERVER数据收发测试 A&#xff08;TX&#xff09;连接RX B&#xff08;RX&#xff09;连接TX 打开1个网络调试助手&#xff0c;模拟用户的UDP客户端设…
阅读更多...
xinference 安装（http导致错误解决）

xinference 安装（http导致错误解决）

为什么要使用xinference 安装xinference 环境 1&#xff09;conda create -n Xinference python3.11 注意&#xff1a;3.9 3.10均可能出现xinference 安装时候出现numpy兼容性&#xff0c;以及无法安装all版本 错误&#xff1a; error while attempting to bind on address&am…
阅读更多...
路由器如何进行数据包转发？

路由器如何进行数据包转发？

路由器进行数据包转发的过程是网络通信的核心之一&#xff0c;主要涉及以下几个步骤&#xff1a; 接收数据包&#xff1a;当一个数据包到达路由器的一个接口时&#xff0c;它首先被暂时存储在该接口的缓冲区中。 解析目标地址&#xff1a;路由器会检查数据包中的目标IP地址。…
阅读更多...
集合类不安全问题

集合类不安全问题

ArrayList不是线程安全类&#xff0c;在多线程同时写的情况下&#xff0c;会抛出java.util.ConcurrentModificationException异常 解决办法&#xff1a; 1.使用Vector&#xff08;ArrayList所有方法加synchronized&#xff0c;太重&#xff09; 2.使用Collections.synchronized…
阅读更多...
Windows Docker笔记-安装docker

Windows Docker笔记-安装docker

安装环境 操作系统&#xff1a;Windows 11 家庭中文版 docker版本&#xff1a;Docker Desktop version: 4.36.0 (175267) 注意&#xff1a; Docker Desktop 支持以下Windows操作系统&#xff1a; 支持的版本&#xff1a;Windows 10&#xff08;家庭版、专业版、企业版、教育…
阅读更多...
docker /var/lib/docker/overlay2目录把磁盘空间占满问题

docker /var/lib/docker/overlay2目录把磁盘空间占满问题

1、查看服务器磁盘空间 df -h果然100%了,docker系统文件把磁盘空间占满了。 2、进入overlay2目录&#xff0c;查找那个容器工作目录占用最高 cd /var/lib/docker/overlay2du -h --max-depth1详见下图 好家伙占用110G&#xff01;复制目录名称2c3c48ccac533c5d4a366d45a19bb9…
阅读更多...
【python】简单的flask做页面。一组字母组成的所有单词。这里的输入是一组字母，而输出是所有可能得字母组成的单词列表

【python】简单的flask做页面。一组字母组成的所有单词。这里的输入是一组字母，而输出是所有可能得字母组成的单词列表

目录结构如下&#xff1a; . ├── static │ ├── css │ │ └── styles.css │ └── js │ └── scripts.js ├── templates │ ├── base.html │ ├── case_converter.html │ ├── index.html │ └── word_finder.html ├── app.py ├── tree.py…
阅读更多...
吴恩达深度学习——卷积神经网络实例分析

吴恩达深度学习——卷积神经网络实例分析

内容来自https://www.bilibili.com/video/BV1FT4y1E74V&#xff0c;仅为本人学习所用。 文章目录 LeNet-5AlexNetVGG-16ResNets残差块 1*1卷积 LeNet-5 输入层&#xff1a;输入为一张尺寸是 32 32 1 32321 32321的图像&#xff0c;其中 32 32 3232 3232是图像的长和宽&…
阅读更多...
利用 IMU 估计人体关节轴向和位置 —— 论文推导

利用 IMU 估计人体关节轴向和位置 —— 论文推导

Title: 利用 IMU 估计人体关节轴向和位置 —— “Joint axis and position estimation from inertial measurement data by exploiting kinematic constraints” —— 论文推导 文章目录 I. 论文回顾II. 铰接关节的约束1. 铰接关节约束的原理2. 铰接关节约束的梯度3. 铰接关节约…
阅读更多...
oracle ORA-27054报错处理

oracle ORA-27054报错处理

现象 在oracle执行expdp&#xff0c;rman备份&#xff0c;xtts的时候,由于没有足够的本地空间&#xff0c;只能使用到NFS的文件系统但有时候会出现如下报错 ORA-27054: NFS file system where the file is created or resides is not mounted with correct options根据提示信…
阅读更多...
python模拟键盘输入（可视化界操作面）

python模拟键盘输入（可视化界操作面）

因为受到一些限制&#xff0c;无法在输入框进行文本的复制粘贴&#xff0c;这时我们便需要模拟键盘输入一些文本内容&#xff0c;话不多说&#xff0c;直接上干货&#xff08;文末附成品工具&#xff0c;需要自取&#xff0c;操作简单无脑&#xff0c;工具功能&#xff1a;将粘…
阅读更多...
k8s部署go-fastdfs

k8s部署go-fastdfs

前置环境：已部署k8s集群，ip地址为 192.168.10.1~192.168.10.5，总共5台机器。 1. 创建provisioner制备器（如果已存在，则不需要） 制备器的具体部署方式可参考我的上一篇文章： k8s部署rabbitmq-CSDN博客文章浏览阅读254次，点赞3次，收藏5次。k8s部署rabbitmqhttps://blo…
阅读更多...
DeepSeek在FPGA/IC开发中的创新应用与未来潜力

DeepSeek在FPGA/IC开发中的创新应用与未来潜力

随着人工智能技术的飞速发展&#xff0c;以DeepSeek为代表的大语言模型&#xff08;LLM&#xff09;正在逐步渗透到传统硬件开发领域。在FPGA&#xff08;现场可编程门阵列&#xff09;和IC&#xff08;集成电路&#xff09;开发这一技术密集型行业中&#xff0c;DeepSeek凭借其…
阅读更多...
（一）DeepSeek大模型安装部署-Ollama安装

（一）DeepSeek大模型安装部署-Ollama安装

大模型deepseek安装部署 (一)、安装ollama curl -fsSL https://ollama.com/install.sh | sh sudo systemctl start ollama sudo systemctl enable ollama sudo systemctl status ollama(二)、安装ollama遇到网络问题&#xff0c;请手动下载 ollama-linux-amd64.tgz curl -L …
阅读更多...
最新文章

Copyright @ 2022~2023