• C语言描述数据结构 —— 二叉树(1)

    1.树

    在学习二叉树之前，先浅浅的了解一下基本的树的概念以及基本结构。

    树是一种非线性的数据结构。它是由n(n>=0)个有限结点组成的一个具有层次关系的集合。把它叫做树是因为它看起来像一颗倒挂的树。

     那么树有这么几个特征：

    • 有一个特殊的结点，称为根结点，根结点没有前驱结点。

    • 除根结点外，其余结点被分成M(M>0)个互不相交的集合T1、T2、……Tm，其中每一个集合又是一颗结构与树类似的子树。每颗子树的根结点有且只有一个前驱，可以0个或多个后继。

    • 树可以递归定义的。

    我们需要注意的是，在树形结构当中，子树之间不能存在交集。

    接下来就是树的一些重要的名词：

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

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

    父节点或双亲节点：若一个节点含有子节点，那么这个节点称为其子节点的父节点；例如A是B、C、D……的父节点。

    子节点或孩子节点：一个节点在子树当中的根节点称为该节点的子节点；例如B、C、D是A的子节点。

    兄弟节点：具有相同的父节点的节点互相称为兄弟节点；B、C、D、E都可以互相称为兄弟节点。

    树的度：某个节点最大的度。

    节点的层次：从根开始定义，根为第一层，往下为第二层，以此类推。

    树的高度或深度：树中节点的最大层次；上图最大层次为4，所以树的高度为4。

    那么树的实际运用最典型的就是树状目录：

     2.二叉树

    2.1二叉树的概念

    我们先观察一下二叉树的结构：

     可以发现，二叉树不存在度大于2的节点；二叉树的子树有左右之分，次序不能颠倒，因此二叉树是有序树。对于任意的二叉树都是由以下几种情况复合而成的：

    2.2特殊的二叉树

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

    2.完全二叉树：完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树引出来的。用易于理解的话说就是，二叉树的最后一层可以只有一个节点或者多个节点，但节点都必须从左到右按顺序来。

     那么二叉树具有什么性质呢？在我们没有真正实现这个数据结构的时候是非常不容易记住的，甚至有些难以理解。那么接下来就是要实现数据结构了，在打代码的过程当中，我们是可以体会到二叉树的一些性质的。

    2.3二叉树的存储结构

    二叉树可以使用两种存储结构，一种是顺序结构，一种是链式结构。这里我们只介绍顺序存储，因为本篇只会使用顺序结构来实现二叉树。

    顺序存储：顺序结构就是使用数组来存储。但在现实中只有堆才会使用数组来存储，堆在下面将会做出解释。二叉树的顺序结构在物理上是一个数组，在逻辑上一颗二叉树。下面这幅图也表示，顺序结构的存储方式只能存储完全二叉树。

     2.4堆的概念以及结构

    如果有一组数据，把它的所有元素按完全二叉树的顺序结构存储方式存储在一个一维数组中，并满足所有的父节点的值大于或等于(小于或等于)所有子节点的值，那么就称为大堆(小堆)。也就是说，满足这个条件，那么根节点存储的数据一定是这颗二叉树中最大或最小的值。

    由此我们可以推出堆的性质：

    • 堆中所有父节点的值总是大于等于(小于等于)其所有子节点的值；
    • 堆总是一颗完全二叉树

    3.堆的实现

    3.1堆的声明

    堆是通过顺序结构存储的，所以我们使用顺序表来完成这个数据结构。

    1. typedef int HeapData;
    2. typedef struct Heap
    3. {
    4. 	HeapData* a;
    5. 	int size;
    6. 	int  capacity;
    7. }Heap;

    3.2堆初始化

    1. //初始化
    2. void HeapInit(Heap* ph)
    3. {
    4. 	assert(ph);
    5. 	ph->a = NULL;
    6. 	ph->size = ph->capacity = 0;
    7. }

    3.2堆插入

    在这个步骤中，就要进行建堆了，我们回想一下顺序表的数据尾插，然后将物理结构转换为逻辑结构。在逻辑结构当中分析建堆的过程是非常简单的，当然这里涉及一个算法，具体如下图。

     现在我们用代码描述插入和向上调整：

    1. //交换
    2. static void  Swap(HeapData* p1, HeapData* p2)
    3. {
    4. 	assert(p1 && p2);
    5. 	HeapData tmp = *p1;
    6. 	*p1 = *p2;
    7. 	*p2 = tmp;
    8. }
    9. //向上调整
    10. static void AdjustUp(Heap* ph, int child)
    11. {
    12. 	assert(ph);
    13. 	//找到父节点下标
    14. 	int parent = (child - 1) / 2;
    15. 	while (child > 0)
    16. 	{
    17. 		//假设建立小堆
    18. 		if (ph->a[child] < ph->a[parent])
    19. 		{
    20. 			Swap(&ph->a[child], &ph->a[parent]);
    21. 			child = parent;
    22. 			parent = (child - 1) / 2;
    23. 		}
    24. 		else
    25. 		{
    26. 			break;
    27. 		}
    28. 	}
    29. }
    30. //插入
    31. void HeapPush(Heap* ph,HeapData x)
    32. {
    33. 	assert(ph);
    34. 	//是否需要扩容
    35. 	if (ph->size == ph->capacity)
    36. 	{
    37. 		int newcapacity = ph->capacity == 0 ? 4 : ph->capacity * 2;
    38. 		HeapData* tmp = (HeapData*)realloc(ph->a, newcapacity * sizeof(HeapData));
    39. 		assert(tmp);
    40. 		ph->capacity = newcapacity;
    41. 		ph->a = tmp;
    42. 	}
    43. 	ph->a[ph->size] = x;
    44. 	ph->size++;
    45. 	//向上调整
    46. 	AdjustUp(ph,  ph->size - 1);
    47. }

    3.3堆打印

    1. //打印
    2. void HeapPrint(Heap* ph)
    3. {
    4. 	assert(ph);
    5. 	for (int i = 0; i < ph->size; i++)
    6. 	{
    7. 		printf("%d ", ph->a[i]);
    8. 	}
    9. 	printf("\n");
    10. }

     3.3堆删除

    我们不能想当然的认为与顺序表一样删除很简单。我们一定要注意，在添加和删除元素的时候必须要保证我们的结构是个堆，这时候就涉及到专属与堆的删除方法，具体如图。

    删除做好了，如何做到保证堆的数据结构合法呢？此时又涉及到一个算法，向下调整算法。

     画图只能描述清楚我们的代码思路，那么现在附上实现这个算法的代码，再通过自己画图来深度理解这个算法：

    1. //向下调整
    2. void AdjustDown(Heap* ph, int n, int parent)
    3. {
    4. 	assert(ph);
    5. 	int minchild = parent * 2 + 1;
    6. 	while (minchild < n)
    7. 	{
    8. 		if (minchild + 1 < n && ph->a[minchild + 1] < ph->a[minchild])
    9. 		{
    10. 			minchild++;
    11. 		}
    12. 		if (ph->a[minchild] < ph->a[parent])
    13. 		{
    14. 			Swap(&ph->a[minchild], &ph->a[parent]);
    15. 			parent = minchild;
    16. 			minchild = parent * 2 + 1;
    17. 		}
    18. 		else
    19. 		{
    20. 			break;
    21. 		}
    22. 	}
    23. }
    24. //删除堆顶
    25. void HeapPop(Heap* ph)
    26. {
    27. 	assert(ph);
    28. 	Swap(&ph->a[0], &ph->a[ph->size - 1]);
    29. 	ph->size--;
    30. 	AdjustDown(ph, ph->size, 0);
    31. }

    3.4判空

    1. //判空
    2. bool HeapEmpty(Heap* ph)
    3. {
    4. 	assert(ph);
    5. 	return ph->size == 0;
    6. }

    3.5返回堆顶元素

    1. //返回堆顶元素
    2. HeapData HeapTop(Heap* ph)
    3. {
    4. 	assert(ph);
    5. 	assert(!HeapEmpty(ph));
    6. 	return ph->a[0];
    7. }

    3.6返回堆元素个数

    1. //返回堆元素个数
    2. int HeapSize(Heap* ph)
    3. {
    4. 	assert(ph);
    5. 	return ph->size;
    6. }

    3.7堆销毁

    1. //堆销毁
    2. void HeapDestroy(Heap* ph)
    3. {
    4. 	assert(ph);
    5. 	free(ph->a);
    6. 	ph->a = NULL;
    7. 	ph->size = ph->capacity = 0;
    8. }

    3.8完整代码

    Heap.h

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. typedef int HeapData;
    6. typedef struct Heap
    7. {
    8. 	HeapData* a;
    9. 	int size;
    10. 	int  capacity;
    11. }Heap;
    12.  
    13. void HeapInit(Heap* ph);//初始化
    14. void HeapPush(Heap* ph,HeapData x);//插入
    15. void HeapPrint(Heap* ph);//打印
    16. void HeapPop(Heap* ph);//删除
    17. bool HeapEmpty(Heap* ph);//判空
    18. HeapData HeapTop(Heap* ph);//返回堆顶元素
    19. int HeapSize(Heap* ph);//返回堆元素个数
    20. void HeapDestroy(Heap* ph);//堆销毁

     Heap.c

    1. //初始化
    2. void HeapInit(Heap* ph)
    3. {
    4. 	assert(ph);
    5. 	ph->a = NULL;
    6. 	ph->size = ph->capacity = 0;
    7. }
    8. //交换
    9. static void  Swap(HeapData* p1, HeapData* p2)
    10. {
    11. 	assert(p1 && p2);
    12. 	HeapData tmp = *p1;
    13. 	*p1 = *p2;
    14. 	*p2 = tmp;
    15. }
    16. //向上调整
    17. static void AdjustUp(Heap* ph, int child)
    18. {
    19. 	assert(ph);
    20. 	//找到父节点下标
    21. 	int parent = (child - 1) / 2;
    22. 	while (child > 0)
    23. 	{
    24. 		//假设建立小堆
    25. 		if (ph->a[child] < ph->a[parent])
    26. 		{
    27. 			Swap(&ph->a[child], &ph->a[parent]);
    28. 			child = parent;
    29. 			parent = (child - 1) / 2;
    30. 		}
    31. 		else
    32. 		{
    33. 			break;
    34. 		}
    35. 	}
    36. }
    37. //插入
    38. void HeapPush(Heap* ph,HeapData x)
    39. {
    40. 	assert(ph);
    41. 	//是否需要扩容
    42. 	if (ph->size == ph->capacity)
    43. 	{
    44. 		int newcapacity = ph->capacity == 0 ? 4 : ph->capacity * 2;
    45. 		HeapData* tmp = (HeapData*)realloc(ph->a, newcapacity * sizeof(HeapData));
    46. 		assert(tmp);
    47. 		ph->capacity = newcapacity;
    48. 		ph->a = tmp;
    49. 	}
    50. 	ph->a[ph->size] = x;
    51. 	ph->size++;
    52. 	//向上调整
    53. 	AdjustUp(ph,  ph->size - 1);
    54. }
    55. //打印
    56. void HeapPrint(Heap* ph)
    57. {
    58. 	assert(ph);
    59. 	for (int i = 0; i < ph->size; i++)
    60. 	{
    61. 		printf("%d ", ph->a[i]);
    62. 	}
    63. 	printf("\n");
    64. }
    65. //向下调整
    66. void AdjustDown(Heap* ph, int n, int parent)
    67. {
    68. 	assert(ph);
    69. 	int minchild = parent * 2 + 1;
    70. 	while (minchild < n)
    71. 	{
    72. 		if (minchild + 1 < n && ph->a[minchild + 1] < ph->a[minchild])
    73. 		{
    74. 			minchild++;
    75. 		}
    76. 		if (ph->a[minchild] < ph->a[parent])
    77. 		{
    78. 			Swap(&ph->a[minchild], &ph->a[parent]);
    79. 			parent = minchild;
    80. 			minchild = parent * 2 + 1;
    81. 		}
    82. 		else
    83. 		{
    84. 			break;
    85. 		}
    86. 	}
    87. }
    88. //删除堆顶
    89. void HeapPop(Heap* ph)
    90. {
    91. 	assert(ph);
    92. 	Swap(&ph->a[0], &ph->a[ph->size - 1]);
    93. 	ph->size--;
    94. 	AdjustDown(ph, ph->size, 0);
    95. }
    96. //判空
    97. bool HeapEmpty(Heap* ph)
    98. {
    99. 	assert(ph);
    100. 	return ph->size == 0;
    101. }
    102. //返回堆顶元素
    103. HeapData HeapTop(Heap* ph)
    104. {
    105. 	assert(ph);
    106. 	assert(!HeapEmpty(ph));
    107. 	return ph->a[0];
    108. }
    109. //返回堆元素个数
    110. int HeapSize(Heap* ph)
    111. {
    112. 	assert(ph);
    113. 	return ph->size;
    114. }
    115. //堆销毁
    116. void HeapDestroy(Heap* ph)
    117. {
    118. 	assert(ph);
    119. 	free(ph->a);
    120. 	ph->a = NULL;
    121. 	ph->size = ph->capacity = 0;
    122. }

    test.c

    1. //个人测试，仅测试部分功能
    2. void TestHeap()
    3. {
    4. 	int a[] = { 12,45,62,56,2,67,89,1,46,21 };
    5. 	Heap p;
    6. 	HeapInit(&p);
    7. 	for (int i = 0; i < sizeof(a) / sizeof(int); i++)
    8. 	{
    9. 		HeapPush(&p, a[i]);
    10. 	}
    11. 	HeapPush(&p, 10);
    12. 	HeapPrint(&p);
    13.  
    14. 	HeapPop(&p);
    15. 	HeapPrint(&p);
    16.  
    17.  
    18. }
    19. int main()
    20. {
    21. 	TestHeap();
    22.  
    23. 	return 0;
    24. }

    4.堆的实际运用 

    我们可以运用堆来完成一个排序算法，那么这个算法优势就在于它的实现复杂度达到了O(logN)。如果我们直接有一个数组，我们如何让它变成堆？

    1. int main()
    2. {
    3. 	int a[] = { 21,2,34,12,54,62,76,25,77 };
    4. 	return 0;
    5. }

    大家或许通过观察实现堆的代码得出这样一个思路：我同样建立一个堆变量，然后把数组的数据插入到堆变量里面，调整完成后再导回到数组里面。这个办法的效率确实是不错的，不过浪费了很多空间。

    我们也可以直接通过向上调整算法直接操作数组，就少了一步导入的环节。我们用循环的方法来代替插入(HeapPush接口)。 

    1. void HeapSort(int* a, int n)
    2. {
    3. 	assert(a);
    4.     //用循环的方式来模拟HeapPush
    5. 	for (int i = 0; i < n; i++)
    6. 	{
    7. 		AdjustUp(a, i);
    8. 	}
    9.  
    10. }
    11. int main()
    12. {
    13. 	int a[] = { 21,2,34,12,54,62,76,25,77 };
    14. 	HeapSort(a, sizeof(a) / sizeof(int));
    15. 	return 0;
    16. }

    第二种便是向下调整法，我们首先要找到最后一个叶节点的父节点，然后依次调整：

    1. void HeapSort(int* a, int n)
    2. {
    3. 	assert(a);
    4. 	//用循环的方法来模拟HeapPush
    5. 	//for (int i = 0; i < n; i++)
    6. 	//{
    7. 	//	AdjustUp(a, i);
    8. 	//}
    9. 	
    10. 	//向下调整建堆
    11. 	//n-2 的目的是万一没有右孩子
    12. 	for (int i = (n - 1 - 1) / 2; i >= 0; i--)
    13. 	{
    14. 		AdjustDown(a, n, i);
    15. 	}
    16.  
    17. }
    18. int main()
    19. {
    20. 	int a[] = { 21,2,34,12,54,62,76,25,77 };
    21. 	HeapSort(a, sizeof(a) / sizeof(int));
    22. 	return 0;
    23. }

     堆建好了之后，现在就要实现排序了。我们直到，堆顶的元素是最大或最小的，那如果我们要排升序的话是建小堆还是大堆？有人会想的是建小堆，思路是这样的：拿出堆顶的元素，然后删除，然后再拿出堆顶的元素，如此往复就得到了升序的序列。但是这样有一个非常的大的问题，每拿出一个元素，就又得重新建一次堆，这样的话就没有堆排序的实质意义了。所以，我们给的思路是，升序建大堆，降序建小堆。为什么？我们看图：

    我们用代码实现我们的思路：

    1. #include 
    2. #include 
    3. void Swap(int* p1, int* p2)
    4. {
    5. 	assert(p1 && p2);
    6. 	int tmp = *p1;
    7. 	*p1 = *p2;
    8. 	*p2 = tmp;
    9. }
    10.  
    11. void AdjustDown(int* a, int n, int parent)
    12. {
    13. 	assert(a);
    14. 	int minchild = parent * 2 + 1;
    15. 	while (minchild < n)
    16. 	{
    17. 		if (minchild + 1 < n && a[minchild] > a[minchild + 1])
    18. 		{
    19. 			minchild++;
    20. 		}
    21. 		if (a[minchild] < a[parent])
    22. 		{
    23. 			Swap(&a[minchild], &a[parent]);
    24. 			parent = minchild;
    25. 			minchild = parent * 2 + 1;
    26. 		}
    27. 		else
    28. 		{
    29. 			break;
    30. 		}
    31. 	}
    32. }
    33. void HeapSort(int* a, int n)
    34. {
    35. 	assert(a);
    36. 	
    37. 	//向下调整建堆
    38. 	//n-2 的目的是万一没有右孩子
    39. 	for (int i = (n - 1 - 1) / 2; i >= 0; i--)
    40. 	{
    41. 		AdjustDown(a, n, i);
    42. 	}
    43. 	//排序
    44. 	while (n)
    45. 	{
    46. 		Swap(&a[0], &a[n - 1]);
    47. 		AdjustDown(a, n - 1, 0);
    48. 		n--;
    49. 	}
    50. }
    51. int main()
    52. {
    53. 	int a[] = { 21,2,34,12,54,62,76,25,77 };
    54. 	HeapSort(a, sizeof(a) / sizeof(int));
    55. 	for (int i = 0; i < sizeof(a) / sizeof(int); i++)
    56. 	{
    57. 		printf("%d ", a[i]);
    58. 	}
    59. 	return 0;
    60. }

    可以看到，用到向下调整的算法的地方是非常多的，这也是一个淘汰向上调整的理由，还有一个理由便是向上调整的效率没有向下调整的效率高。在我们设计代码时，尽量使接口能被复用，这样可以降低代码的冗余程度。 

  • 相关阅读:
    真人陪聊解忧，暖心的虚拟恋人尽在烟雨树洞
    java线程池
    【小专题】正交试验法设计测试用例
    设计模式-创建型模式
    ceph 认证
    基于Spring Boot的ERP仓储管理信息系统设计与实现毕业设计源码150958
    线上服务发布抖动，该怎么解决呢
    Java访问控制修饰符详解（public、 private、protected 和 friendly）
    关于使用Linkage mapper 构建生态网络的数据说明
    thinkphp5 redis使用
  • 原文地址：https://blog.csdn.net/weixin_59913110/article/details/126444279