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

     一、树的概念及结构

    1.树的概念

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

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

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

    ●  因此，树是递归定义

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

    2.树的相关概念

    3.树的表示

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

    1. typedef int DataType;
    2. struct Node
    3. {
    4.  struct Node* firstChild1; // 第一个孩子结点
    5.  struct Node* pNextBrother; // 指向其下一个兄弟结点
    6.  DataType data; // 结点中的数据域
    7. };

    二、二叉树的概念及结构

    1.概念

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

    2.或者为空

    由上图可知：

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

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

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

    2.特殊的二叉树 

    (1)满二叉树：一个二叉树，如果每一层的结点数都要达到最大值，则这个二叉树就是满二叉树。也就是说，如果一个二叉树的层数为K，且总结点数是2k−1" role="presentation" style="position: relative;">2k−1，则它就是满二叉树。

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

    3.二叉树的性质

    (1)若规定根结点的层数为1，则一颗树非空二叉树的第i层上最多有2i−1" role="presentation" style="position: relative;">2i−1个结点。

    (2)若规定根结点的层数为1，则深度为h的二叉树的最大结点数是2h−1" role="presentation" style="position: relative;">2h−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=log⁡2n+1" role="presentation" style="position: relative;">h=log⁡2n+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. 1. 某二叉树共有 399 个结点，其中有 199 个度为 2 的结点，则该二叉树中的叶子结点数为（B）
    2. A 不存在这样的二叉树
    3. B 200
    4. C 198
    5. D 199

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

    1. 2.在具有 2n 个结点的完全二叉树中，叶子结点个数为（A）
    2. A n
    3. B n+1
    4. C n-1
    5. 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

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

    5.二叉树的存储结构 

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

    (1)顺序结构

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

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

    (2)链式存储

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

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

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

    1.堆的概念及结构

    如果有一个关键码的集合K={ K0" role="presentation" style="position: relative;">K0，K1" role="presentation" style="position: relative;">K1，K2" role="presentation" style="position: relative;">K2，……，Kn−1" role="presentation" style="position: relative;">Kn−1 }，把它的所有元素按完全二叉树的顺序存储方式存储在一个一维数组中，并满足：Ki" role="presentation" style="position: relative;">Ki ≤" role="presentation" style="position: relative;">≤K2i+1" role="presentation" style="position: relative;">K2i+1且Ki≤K2i+2" role="presentation" style="position: relative;">Ki≤K2i+2（Ki≥K2i+1" role="presentation" style="position: relative;">Ki≥K2i+1 且 Ki≥K2i+2" role="presentation" style="position: relative;">Ki≥K2i+2）i = 0 , 1 , 2……，则称为小堆（大堆）。将根结点最大的堆交租最大堆或大根堆，根结点最小的堆叫做最小堆会小根堆。

    2.堆的性质

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

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

    3.堆的实现

    <1>堆的创建图示

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

    <2>Heap.h

    1. #include
    2. #include
    3. #include
    4. #include
    5.  
    6.  
    7. typedef int HPDateType;
    8. typedef struct Heap
    9. {
    10. 	HPDateType* a;
    11. 	int size;
    12. 	int capacity;
    13. }HP;
    14.  
    15. //交换函数
    16. void swap(HPDateType* p1, HPDateType* p2);
    17.  
    18. //初始化和销毁
    19. void HPInit(HP* php);
    20. void HPDestory(HP* php);
    21.  
    22. //向上调整算法
    23. void AdjustUp(HPDateType* a, int child);
    24. //插入数据
    25. void HPPush(HP* php, HPDateType x);
    26.  
    27. void AdjustDown(HPDateType* a, int n, int parent);
    28. //删除数据
    29. void HPPop(HP* php);
    30. //返回堆顶的元素
    31. HPDateType HPTop(HP* php);
    32. //判空
    33. bool HPEmpty(HP* php);

    <3>Heap.c

    (1)交换函数
    1. //交换函数
    2. void swap(HPDateType* p1, HPDateType* p2)
    3. {
    4. 	HPDateType tmp = *p1;
    5. 	*p1 = *p2;
    6. 	*p2 = tmp;
    7. }
    (2)初始化
    1. void HPInit(HP* php)
    2. {
    3. 	assert(php);
    4. 	php->a = NULL;
    5. 	php->capacity = php->size = 0;
    6. }
    (3)销毁
    1. void HPDestory(HP* php)
    2. {
    3. 	assert(php);
    4. 	free(php);
    5. 	php->a = NULL;
    6. 	php->capacity = php->size = 0;
    7. }
    (4)向上调整算法
    1. //向上调整算法
    2. void AdjustUp(HPDateType* a, int child)
    3. {
    4. 	int parent = (child - 1) / 2;//堆的父子关系
    5. 	while (child > 0)
    6. 	{
    7. 		if (a[child] < a[parent])//向上调整
    8. 		{
    9. 			swap(&a[child], &a[parent]);//交换位置
    10. 			child = parent;//最初的parent赋值给child
    11. 			parent = (child - 1) / 2;//重新规划parent
    12. 		}
    13. 		else
    14. 		{
    15. 			break;
    16. 		}
    17. 	}
    18. }
    (5)插入数据（建堆）

     堆的创建过程图示：

    时间复杂度为：logN 

     

    1. //插入数据
    2. void HPPush(HP* php, HPDateType x)
    3. {
    4. 	assert(php);
    5. 	//空间不够
    6. 	if (php->size == php->capacity)
    7. 	{
    8. 		int newcapacity = php->capacity == 0 ? 4 : php->capacity * 2;
    9. 		HPDateType* tmp = (HPDateType*)realloc(php->a, newcapacity * sizeof(HPDateType));
    10. 		if (tmp == NULL)
    11. 		{
    12. 			perror("realloc fail!");
    13. 			return;
    14. 		}
    15. 		php->a = tmp;
    16. 		php->capacity = newcapacity;
    17. 	}
    18. 	php->a[php->size] = x;//插在数组的结尾
    19. 	php->size++;
    20. 	AdjustUp(php->a, php->size - 1);//传的是下标，用来找父子关系
    21. }
    (6)向下调整算法

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

    1. //向下调整算法(前提：左右字树是小堆/左右子树是大堆)
    2. void AdjustDown(HPDateType* a,int n,int parent)
    3. {
    4. 	//假设法：先假设左孩子小
    5. 	int child = parent * 2 + 1;
    6.  
    7. 	//child >= n说明孩子已经不存在了，超出二叉树范围了(叶子)
    8. 	while (child < n)  
    9. 	{
    10. 		//找出小的那个孩子
    11. 		if (a[child] > a[child + 1] && child +1 < n)
    12. 		{
    13. 			++child;//让右孩子成为小的
    14. 		}
    15. 		if (a[child] < a[parent])
    16. 		{
    17. 			swap(&a[child], &a[parent]);
    18. 			parent = child;
    19. 			child = parent * 2 + 1;
    20. 		}
    21. 		else
    22. 		{
    23. 			break;
    24. 		}
    25. 	}
    26. }
    (7)删除数据

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

    1. //删除数据(堆顶的数据)
    2. //不能挪动数据，覆盖删除堆顶数据—>关系错乱
    3. //堆顶数据交换到最后一个数据，再删除最后一个数据，在进行向下调整算法
    4. void HPPop(HP* php)
    5. {
    6. 	assert(php);
    7. 	assert(php->size > 0);
    8. 	swap(&php->a[0], &php->a[php->size - 1]);
    9. 	php->size--;//先size--了，缩小数组大小
    10.  
    11. 	//所以调用完AdjustDown()函数后，交换到最后一位的堆顶元素就已经被删除了
    12. 	AdjustDown(php->a, php->size, 0);
    13.  
    14. }
    (8)返回栈顶元素
    1. //返回堆顶的元素
    2. HPDateType HPTop(HP* php)
    3. {
    4. 	assert(php);
    5. 	assert(php->size > 0);
    6.  
    7. 	return php->a[0];
    8. }
    (9)判空
    1. //判空
    2. bool HPEmpty(HP* php)
    3. {
    4. 	assert(php);
    5. 	return php->size == 0;
    6. }

    <4>test.c

    1. void TestHeap1()
    2. {
    3. 	int a[ ] = { 2,4,5,6,1,7,8,9 };
    4. 	HP hp;
    5. 	HPInit(&hp);
    6. 	for (size_t i = 0; i < sizeof(a) / sizeof(int); i++)
    7. 	{
    8. 		HPPush(&hp, a[i]);
    9. 	}
    10. 	while (!HPEmpty(&hp))
    11. 	{
    12. 		printf("%d ", HPTop(&hp));
    13. 		HPPop(&hp);
    14. 	}
    15. } 
    16. int main()
    17. {
    18.     TestHeap1();
    19. 	return 0;
    20. }

    4.堆的应用 

    <1>堆排序 

    (1)建堆

    升序：建大堆

    降序：建小堆

     (2)排序

    ● 向上调整建堆思想：

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

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

    1. void swap(int* p1, int* p2)
    2. {
    3. 	int tmp = *p1;
    4. 	*p1 = *p2;
    5. 	*p2 = tmp;
    6. }
    7. void AdjustUp(int* a, int child)
    8. {
    9. 	int parent = (child - 1) / 2;//堆的父子关系
    10. 	while (child > 0)
    11. 	{
    12. 		if (a[child] < a[parent])//向上调整
    13. 		{
    14. 			swap(&a[child], &a[parent]);//交换位置
    15. 			child = parent;//最初的parent赋值给child
    16. 			parent = (child - 1) / 2;//重新规划parent
    17. 		}
    18. 		else
    19. 		{
    20. 			break;
    21. 		}
    22. 	}
    23. }
    24.  
    25. //堆排序
    26. //->时间复杂度：O(N* logN)
    27. //这里我们把数组当做完全二叉树
    28. void HeapSort(int* a, int n)
    29. {
    30.     //向上调整建堆
    31. 	//降序，建小堆 (升序,建大堆)
    32. 	for (int  i = 0; i < n; i++)
    33. 	{
    34. 		AdjustUp(a, i);
    35. 	}
    36.  
    37. 	int end = n - 1;
    38. 	while (end > 0)
    39. 	{
    40. 		//把最大的数换到最后一位
    41. 		swap(&a[0], &a[end]);
    42. 		//在将第一个数向下调整，选出次大的数
    43. 		AdjustDown(a, end, 0);
    44.         //最后一位数据被固定，数组的范围缩小
    45. 		--end;
    46. 	}
    47. }
    48.  
    49. void TestHeap3()
    50. {
    51. 	int a[] = { 5,4,3,16,17,20 };
    52. 	HeapSort(a, sizeof(a) / sizeof(int));
    53. }
    54. int main()
    55. {
    56. 	TestHeap3();
    57. 	return 0;
    58. }

    ● 向下调整建堆思想 

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

     

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

    1.  
    2. #include<stdio.h>
    3. #include<stdlib.h>
    4. void swap(int* p1, int* p2)
    5. {
    6. 	int tmp = *p1;
    7. 	*p1 = *p2;
    8. 	*p2 = tmp;
    9. }
    10.  
    11. void AdjustDown(int* a, int n,int parent)
    12. {//建小堆
    13. 	int child = 2 * parent + 1;//先假设左孩子小
    14. 	while (child < n)
    15. 	{
    16. 		if (a[child] > a[child + 1])
    17. 		{
    18. 			child++;
    19. 		}
    20. 		if (a[child] < a[parent])
    21. 		{
    22. 			swap(&a[child], &a[parent]);
    23. 			parent = child;
    24. 			child = 2 * parent + 1;
    25. 		}
    26. 		else
    27. 		{
    28. 			break;
    29. 		}
    30. 	}
    31. }
    32.  
    33. void HPSort(int* a, int n)
    34. {
    35.     //向下调整建堆(从最后一个有子树的元素开始向上建)->666	
    36.     //数组最后一个元素的小标为n-1
    37. 	for (int i = (n - 1 - 1) / 2; i >= 0; i--)
    38. 	{
    39. 		AdjustDown(a, n, i);
    40. 	}
    41. }
    42.  
    43.  
    44. int main()
    45. {
    46. 	int a[] = { 5,6,2,3,7,8,9,1,4 };
    47. 	int n = sizeof(a) / sizeof(a[0]);
    48. 	HPSort(a, n);
    49. 	for (int i = 0; i < n; i++)
    50. 	{
    51. 		printf("%d ",a[i]);
    52. 	}
    53. 	return 0;
    54. }

    <2>Top—K问题

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

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

    1. void TestHeap2()
    2. {
    3. 	int a[] = { 27,15,19,18,28,34,65,49,25,37 };
    4. 	HP hp;
    5. 	HPInit(&hp);
    6. 	for (size_t i = 0; i < sizeof(a) / sizeof(int); i++)
    7. 	{
    8. 		HPPush(&hp, a[i]);
    9. 	}
    10. 	//找出最小的前k个
    11. 	int k = 0;
    12. 	scanf("%d", &k);
    13. 	while (k--)
    14. 	{
    15. 		printf("%d ", HPTop(&hp));
    16. 		HPPop(&hp);
    17. 	}
    18. 	printf("\n");
    19. }
    20.  
    21. int main()
    22. {
    23. 	TestHeap2();
    24. 	return 0;
    25. }

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

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

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

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

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

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

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

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

    1. #include<stdio.h>
    2. #include<stdlib.h>
    3. #include<time.h>
    4.  
    5. void swap(int* p1, int* p2)
    6. {
    7. 	int tmp = *p1;
    8. 	*p1 = *p2;
    9. 	*p2 = tmp;
    10. }
    11.  
    12. void AdjustDown(int* a, int n,int parent)
    13. {//建小堆
    14. 	int child = 2 * parent + 1;//先假设左孩子小
    15. 	while (child < n)
    16. 	{
    17. 		if (a[child] > a[child + 1])
    18. 		{
    19. 			child++;
    20. 		}
    21. 		if (a[child] < a[parent])
    22. 		{
    23. 			swap(&a[child], &a[parent]);
    24. 			parent = child;
    25. 			child = 2 * parent + 1;
    26. 		}
    27. 		else
    28. 		{
    29. 			break;
    30. 		}
    31. 	}
    32. }
    33.  
    34. void PrintTopK(int* a, int n, int k)
    35. {
    36. 	// 1. 建堆--用a中前k个元素建堆
    37. 	for (int i = (k - 1 - 1) / 2; i >= 0; i--)
    38. 	{
    39. 		AdjustDown(a, n, i);//小堆
    40. 	}
    41. 	// 2. 将剩余n-k个元素依次与堆顶元素交换，不满则则替换
    42. 	for (int j = k; j < n-1; j++)
    43. 	{
    44. 		if (a[0] < a[j])
    45. 		{
    46. 			a[0] = a[j];
    47. 			AdjustDown(a, n, 0);
    48. 		}
    49. 	}
    50. 	
    51. 	for (int s = 0; s < k - 1; s++)
    52. 	{
    53. 		printf("%d ", a[s]);
    54. 	}
    55. 	printf("\n");
    56. }
    57. void TestTopk()
    58. {
    59. 	int n = 10000;
    60. 	int* a = (int*)malloc(sizeof(int) * n);
    61. 	srand(time(0));
    62. 	for (size_t i = 0; i < n; ++i)
    63. 	{
    64. 		a[i] = rand() % 1000000;
    65. 	}
    66. 	a[5] = 1000000 + 1;
    67. 	a[1231] = 1000000 + 2;
    68. 	a[531] = 1000000 + 3;
    69. 	a[5121] = 1000000 + 4;
    70. 	a[115] = 1000000 + 5;
    71. 	a[2335] = 1000000 + 6;
    72. 	a[9999] = 1000000 + 7;
    73. 	a[76] = 1000000 + 8;
    74. 	a[423] = 1000000 + 9;
    75. 	a[3144] = 1000000 + 10;
    76. 	printf("最大的前k个数\n");
    77. 	int k;
    78. 	scanf("%d", &k);
    79. 	PrintTopK(a, n, k);
    80. }
    81. int main()
    82. {
    83. 	TestTopk();
    84. 	return 0;
    85. }

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

    1. void CreateNDate()
    2. {
    3. 	// 造数据
    4. 	int n = 10000;
    5. 	srand(time(0));
    6. 	const char* file = "data.txt";
    7. 	FILE* fin = fopen(file, "w");
    8. 	if (fin == NULL)
    9. 	{
    10. 		perror("fopen error");
    11. 		return;
    12. 	}
    13.  
    14. 	for (size_t i = 0; i < n; ++i)
    15. 	{
    16. 		int x = rand() % 1000000;
    17. 		fprintf(fin, "%d\n", x);
    18. 	}
    19.  
    20. 	fclose(fin);
    21. }
    22.  
    23. void HeapTest()
    24. {
    25. 	int k;
    26.     printf("请输入K:");
    27. 	scanf("%d", &k);
    28. 	int* a = (int*)malloc(sizeof(int) * k);
    29. 	if (a == NULL)
    30. 	{
    31. 		perror("malloc error");
    32. 		return;
    33. 	}
    34.  
    35. 	//打开文件，读前k个数
    36. 	const char* file = "data.txt";
    37. 	FILE* fout = fopen(file, "r");
    38. 	if (fout == NULL)
    39. 	{
    40. 		perror("fopen error");
    41. 		return;
    42. 	}
    43. 	for (int i = 0; i < k; i++)
    44. 	{
    45. 		fscanf(fout,"%d", &a[i]);
    46. 	}
    47. 	//建有k个数的小堆
    48. 	for (int i = (k - 1 - 1) / 2; i >= 0; i--)
    49. 	{
    50. 		AdjustDown(a, k, i);
    51. 	}
    52. 	//读取剩下的N-K个
    53. 	int x = 0;
    54. 	while (fscanf(fout,"%d", &x) > 0)
    55. 	{
    56. 		if (a[0] < x)
    57. 		{
    58. 			a[0] = x;
    59. 			AdjustDown(a, k, 0);
    60. 		}
    61. 	}
    62. 	//打印
    63. 	for (int i = 0; i < k; i++)
    64. 	{
    65. 		printf("%d ", a[i]);
    66. 	}
    67. 	printf("\n");
    68. }
    69.  
    70. int main()
    71. {
    72.     CreateNDate();
    73. 	HeapTest();
    74. 	return 0;
    75. }
  • 相关阅读:
    部署LVS-DR集群
    Word控件Spire.Doc 【文本】教程(12) ；新方法在 C# 中获取 Word 文档中内容控件的别名、标签和 ID
    云原生之深入解析Prometheus Pushgetway的原理分析和实战操作
    一文看懂推荐系统：排序09：Field-aware Factorization Machines（FFM），从FM改进来的，效果不咋地
    git常用命令学习笔记
    C进阶-自定义类型：结构体、枚举、联合
    夏日漫步（BFS）-- 2023百度之星初赛第二场
    如何使用 Hotshot 通过文字生成 GIF 动画
    JAVA医药进销存管理系统（附源码+调试）
    【多目标优化算法】基于帕累托包络（PESA-II）的选择算法（Matlab代码实现）
  • 原文地址：https://blog.csdn.net/2401_83431652/article/details/139012536