devbox
盐析白兔
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

[数据结构1.0]二叉树

作者：盐析白兔 | 2024-05-20 16:02:08

赞

踩

[数据结构1.0]二叉树

各位读者老爷好，鼠鼠我现在浅浅介绍一些关于二叉树的知识点，在各位老爷茶余饭后的闲暇时光不妨看看，鼠鼠很希望得到各位老爷的指正捏！

开始介绍之前，给各位老爷看一张风景照，有读者老爷知道在哪里吗？

第一个在评论区答出正确答案的老爷鼠鼠会联系你，有惊喜捏！ 

目录

1.树

1.1.树的概念 

1.2.树的相关概念

2.二叉树

2.1.二叉树的概念

2.2.特殊的二叉树

2.3.二叉树的存储结构

3.堆

3.1.堆的概念及分类

3.2.堆的顺序存储的实现（二叉树的顺序存储的实现） 

3.2.1.堆（大堆）总览

3.2.2. 定义堆

3.2.3.堆的初始化

3.2.4.堆的插入

3.2.5.堆的删除 

3.2.6.获取堆顶的数据

3.2.7.堆的数据个数

3.2.8.堆的判空

3.2.9.堆的销毁

4.运行结构分析

好的，我们在介绍二叉树之前需要了解树的概念！

1.树

1.1.树的概念 

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

画个图给各位老爷看看：

我们可以看到：

1.有一个特殊的结点（A节点），称为根结点，根节点没有前驱结点。

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

3.因此，树是递归定义的。

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


树形结构除了根节点外，每个节点有且只有一个父节点。如图就不是一个树形结构。

1.2.树的相关概念

介绍下面相关概念鼠鼠以下面树形结构举例：

1.节点的度：一个节点含有的子树的个数称为该节点的度； 如上图：A节点的度为3，B节点的度为2。

2.叶节点或终端节点：度为0的节点称为叶节点； 如上图：G、H、I、J、K和L节点为叶节点。

3.非终端节点或分支节点：度不为0的节点； 如上图：B、C、D、E和F节点为分支节点。

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

5.孩子节点或子节点：一个节点含有的子树的根节点称为该节点的子节点； 如上图：B、C和D都是A的孩子节点。

6.兄弟节点：具有相同父节点的节点互称为兄弟节点； 如上图：J、K和L互为兄弟节点。

7.树的度：一棵树中，最大的节点的度称为树的度； 如上图：树的度为3。

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

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

10.堂兄弟节点：双亲节点在同一层的节点互为堂兄弟节点；如上图：F和G互为堂兄弟节点。

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

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

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

有了以上铺垫，我们来了解二叉树的概念！

2.二叉树

2.1.二叉树的概念

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

说简单点呢，二叉树是一颗特殊的树，这颗树的度最大为2，就像是对这颗树的节点进行了计划生育，最多只能生两个节点宝宝。 

从图可以看出：

1. 二叉树不存在度大于2的结点。
2. 二叉树的子树有左右之分，次序不能颠倒，因此二叉树是有序树。

3.二叉树的子树也都是二叉树，既然是二叉树就可以为空树。

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

2.2.特殊的二叉树

1. 满二叉树：一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树。

很容易知道，满二叉树各层的节点个数构成一个以1为首项，以2为公比的等比数列。如果一个二叉树的层数为K，用等比数列的求和公式或者错位相减法就能得到满二叉树节点的和为2^K-1。

那么反过来，如果知道了满二叉树的节点个数为N，那么它的层数就为log2（N+1），约等log2(N)。

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

说简单易懂的话呢，就是说完全二叉树如果有K层，那么前K-1层的节点数都达到最大值，第K层的节点数不一定达到最大值，但是最后一层的节点从左到右必须连续。

跟上面分析的一样，我们知道完全二叉树的前K-1层的节点数总和为2^(K-1)-1 。最后一层（第K层）的节点个数最少为1个，最多为2^(K-1)个。那么完全二叉树的节点总数范围就是2^(K-1)到2^K-1。

相同的，我们如果知道完全二叉树的节点个数为N，那么它的层数也大概是log2(N)。

2.3.二叉树的存储结构

二叉树一般可以使用两种结构存储，一种顺序结构，一种链式结构。

1. 顺序存储
顺序结构存储就是使用数组来存储，一般使用数组只适合表示完全二叉树，因为不是完全二叉树会有空间的浪费。而现实中使用中只有堆才会使用数组来存储，至于堆是什么鼠鼠下面会讲的捏！二叉树顺序存储在物理上是一个数组，在逻辑上是一颗二叉树。

也许各位老爷不明白为啥可以将二叉树存储到一个数组中呢？

其实我们将二叉树在逻辑上想象成一颗二叉树，在逻辑上我们将二叉树的节点一层一层按顺序存储到数组中。我们通过以下规律可以控制二叉树捏：

1.左孩子节点下标=父节点下标*2+1；

2.右孩子节点下标=父节点下标*2+2；

3.父节点下标=(左孩子节点下标-1)/2=(右孩子节点下标-1)/2； 

那么为什么只有完全二叉树适合用顺序存储捏？

因为用顺序存储（就是用数组存储）的话我们要保证父节点下标和孩子节点下标满足上面三条规律才能控制好二叉树。而非完全二叉树要想满足上面三条规律的话，我们会有空间浪费，如下图：

如果根据错误对应来存储二叉树节点的话，就不符合上面的三条规律了！ 所以顺序存储适合完全二叉树，非完全二叉树也可以存储但不适合！

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

本篇博客不细讲二叉树的链式存储，我们主要搞定顺序存储，链式存储后面博客再介绍！

既然介绍二叉树的顺序存储，而现实中使用中只有堆才会使用数组来存储，鼠鼠就要介绍堆这个概念并实现堆（也就是实现二叉树的顺序存储）捏 ！

3.堆

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

3.1.堆的概念及分类

简单讲，堆就是一颗完全二叉树，不过这颗完全二叉树对数据摆放有要求：

大堆：任意一个父节点数据要大于或等于它的任意孩子节点数据；

小堆：任意一个父节点数据要小于或等于它的任意孩子节点数据；

堆只有大堆和小堆之分，没有中堆这个说法！我们来看一道题，方便理解：

1.下列关键字序列为堆的是：（）
A 100,60,70,50,32,65
B 60,70,65,50,32,100
C 65,100,70,32,50,60
D 70,65,100,32,50,60
E 32,50,100,70,65,60
F 50,100,70,65,60,32

答案选A，为什么A是堆，其他不是捏？我们来看：

A选项：

 还原成逻辑结构的完全二叉树的话，很明显是一个大堆！

B选项：

 还原成逻辑结构的完全二叉树的话，很明显不是大堆也不是小堆，比如说60<65，符合小堆要求；但是70>32，又符合大堆要求；所以不是堆！

其他选项分析相同，鼠鼠就不解释了！

3.2.堆的顺序存储的实现（二叉树的顺序存储的实现） 

也许有读者老爷不明白为啥用堆的顺序存储的实现代表二叉树的顺序存储的实现？因为堆的顺序存储的实现是有意义的，它能很好的管理数据而并非单纯的存储数据。如果单纯存储数据我们大可不必用二叉树来存储！至于堆能实现什么功能，在下面的讲解和后面的博客中鼠鼠会浅谈。

因为堆有大堆和小堆之分，鼠鼠我实现大堆的顺序存储为例，小堆的实现相信老爷们可以举一反三自己搞定！

3.2.1.堆（大堆）总览

我们先总体看堆的顺序存储实现完的三个文件，有兴趣的老爷可以放到一个工程下面玩玩：

1.heap.h

  1. #pragma once
  2. #include<stdio.h>
  3. #include<assert.h>
  4. #include<stdlib.h>
  5. #include<stdbool.h>
  6.  
  7. //大堆
  8.  
  9.  
  10. typedef int HeapDataType;
  11.  
  12. typedef struct Heap
  13. {
  14. 	HeapDataType* a;
  15. 	int size;
  16. 	int capacity;
  17. }Heap;
  18.  
  19. //堆的初始化
  20. void HeapInit(Heap* HP);
  21.  
  22. //堆的插入
  23. void HeapPush(Heap* HP, HeapDataType x);
  24.  
  25. //堆的删除
  26. void HeapPop(Heap* Hp);
  27.  
  28. //取堆顶的数据
  29. HeapDataType HeapTop(Heap* HP);
  30.  
  31. //堆的数据个数
  32. int HeapSize(Heap* hp);
  33.  
  34. // 堆的判空
  35. bool HeapEmpty(Heap* hp);
  36.  
  37. //堆的销毁
  38. void HeapDestroy(Heap* HP);

2.heap.c 

  1. #define _CRT_SECURE_NO_WARNINGS
  2. #include"heap.h"
  3.  
  4. void HeapInit(Heap* HP)
  5. {
  6. 	assert(HP);
  7. 	HP->a = NULL;
  8. 	HP->capacity = HP->size = 0;
  9. }
  10.  
  11. void swap(HeapDataType* parent, HeapDataType* child)
  12. {
  13. 	HeapDataType tmp = *parent;
  14. 	*parent = *child;
  15. 	*child = tmp;
  16. }
  17.  
  18. void AdjustUp(HeapDataType* a, int childcoordinate)
  19. {
  20. 	int parentcoordinate = (childcoordinate - 1) / 2;
  21. 	while (childcoordinate > 0)
  22. 	{
  23. 		if (a[parentcoordinate] < a[childcoordinate])
  24. 		{
  25. 			swap(&a[parentcoordinate], &a[childcoordinate]);
  26. 			childcoordinate = parentcoordinate;
  27. 			parentcoordinate = (parentcoordinate - 1) / 2;
  28. 		}
  29. 		else
  30. 		{
  31. 			break;
  32. 		}
  33. 	}
  34. }
  35.  
  36. void HeapPush(Heap* HP, HeapDataType x)
  37. {
  38. 	assert(HP);
  39.  
  40. 	//扩容
  41. 	if (HP->capacity == HP->size)
  42. 	{
  43. 		int newcapacity = HP->capacity == 0 ? 4 : HP->capacity * 2;
  44. 		HeapDataType* tmp = (HeapDataType*)realloc(HP->a, sizeof(HeapDataType) * newcapacity);
  45. 		if (tmp == NULL)
  46. 		{
  47. 			perror("realloc fail");
  48. 			exit(-1);
  49. 		}
  50. 		HP->a = tmp;
  51. 		HP->capacity = newcapacity;
  52. 	}
  53. 	HP->a[HP->size++] = x;
  54.  
  55. 	//向上调整
  56. 	AdjustUp(HP->a, HP->size - 1);
  57. }
  58.  
  59. void AdjustDown(HeapDataType* a, int size, int parentcoordinate)
  60. {
  61. 	int childcoordinate = parentcoordinate * 2 + 1;
  62. 	
  63. 	while (childcoordinate < size)
  64. 	{
  65. 		if (a[childcoordinate] < a[childcoordinate + 1]&&childcoordinate+1<size)
  66. 		{
  67. 			childcoordinate++;
  68. 		}
  69. 		if (a[childcoordinate] > a[parentcoordinate])
  70. 		{
  71. 			swap(&a[childcoordinate], &a[parentcoordinate]);
  72. 			parentcoordinate = childcoordinate;
  73. 			childcoordinate = childcoordinate * 2 + 1;
  74. 		}
  75. 		else
  76. 		{
  77. 			break;
  78. 		}
  79. 	}
  80. }
  81.  
  82. void HeapPop(Heap* HP)
  83. {
  84. 	assert(HP);
  85. 	assert(HP->size > 0);
  86. 	swap(&HP->a[0], &HP->a[HP->size - 1]);
  87. 	HP->size--;
  88.  
  89. 	//向下调整
  90. 	AdjustDown(HP->a, HP->size,0);
  91. }
  92.  
  93. HeapDataType HeapTop(Heap* HP)
  94. {
  95. 	assert(HP->size > 0);
  96. 	return HP->a[0];
  97. }
  98.  
  99. int HeapSize(Heap* HP)
  100. {
  101. 	return HP->size;
  102. }
  103.  
  104. bool HeapEmpty(Heap* HP)
  105. {
  106. 	return HP->size == 0;
  107. }
  108.  
  109. void HeapDestroy(Heap* HP)
  110. {
  111. 	free(HP->a);
  112. 	HP->a = NULL;
  113. 	HP->capacity = HP->size = 0;
  114. }

3.test.c

  1. #define _CRT_SECURE_NO_WARNINGS
  2. #include"heap.h"
  3.  
  4. int main()
  5. {
  6. 	int a[] = { 100,90,80,110,75,3 };
  7. 	Heap p;
  8. 	HeapInit(&p);
  9. 	for (int i = 0; i < sizeof(a) / sizeof(a[0]); i++)
  10. 	{
  11. 		HeapPush(&p, a[i]);
  12. 	}
  13. 	for(int i=0;i<p.size;i++)
  14. 	{
  15. 		printf("%d ", p.a[i]);
  16. 	}
  17. 	printf("\n");
  18. 	while (!HeapEmpty(&p))
  19. 	{
  20. 		printf("%d ", HeapTop(&p));
  21. 		HeapPop(&p);
  22. 	}
  23. 	return 0;
  24. }

4.运行结果 

运行结果为啥是这样的，我们一会分析！ 

3.2.2. 定义堆
  1. typedef int HeapDataType;
  2.  
  3. typedef struct Heap
  4. {
  5. 	HeapDataType* a;
  6. 	int size;
  7. 	int capacity;
  8. }Heap;

这里重命名int为HeapDataType，大大方便后续代码的维护！用a指向后来动态开辟的连续内存，该连续内存用来存储堆的数据，size用来记录堆的数据个数或者指向堆最后一个数据的下一个，capacity用来记录连续内存可放入数据的容量。

这里用一个结构体来定义堆如代码所示，定义的跟顺序表一样，但是我们这里表示的堆对数据的摆放要求是大堆或者小堆，而顺序表就没有这个要求！ 

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

断言防止传入结构体变量地址为空（下面这点不在赘述。） 不妨将a置空，将capacity和size置0。

3.2.4.堆的插入
  1. void swap(HeapDataType* parent, HeapDataType* child)
  2. {
  3. 	HeapDataType tmp = *parent;
  4. 	*parent = *child;
  5. 	*child = tmp;
  6. }
  7.  
  8. void AdjustUp(HeapDataType* a, int childcoordinate)
  9. {
  10. 	int parentcoordinate = (childcoordinate - 1) / 2;
  11. 	while (childcoordinate > 0)
  12. 	{
  13. 		if (a[parentcoordinate] < a[childcoordinate])
  14. 		{
  15. 			swap(&a[parentcoordinate], &a[childcoordinate]);
  16. 			childcoordinate = parentcoordinate;
  17. 			parentcoordinate = (parentcoordinate - 1) / 2;
  18. 		}
  19. 		else
  20. 		{
  21. 			break;
  22. 		}
  23. 	}
  24. }
  25.  
  26. void HeapPush(Heap* HP, HeapDataType x)
  27. {
  28. 	assert(HP);
  29.  
  30. 	//扩容
  31. 	if (HP->capacity == HP->size)
  32. 	{
  33. 		int newcapacity = HP->capacity == 0 ? 4 : HP->capacity * 2;
  34. 		HeapDataType* tmp = (HeapDataType*)realloc(HP->a, sizeof(HeapDataType) * newcapacity);
  35. 		if (tmp == NULL)
  36. 		{
  37. 			perror("realloc fail");
  38. 			exit(-1);
  39. 		}
  40. 		HP->a = tmp;
  41. 		HP->capacity = newcapacity;
  42. 	}
  43. 	HP->a[HP->size++] = x;
  44.  
  45. 	//向上调整
  46. 	AdjustUp(HP->a, HP->size - 1);
  47. }

堆的插入我们表面上是在数组中（动态开辟的空间）尾插，但我们逻辑上要想象成数据插入在树的底层，并调整数据使其符合大堆要求。 这里的精髓是调整数据，也就是代码中的向上调整函数。关于向上调整函数，鼠鼠画一个图方便理解吧：

我们可以看到堆的插入代码中主要的时间消耗在向上调整函数上，而向上调整函数最多调整层数-1次，完全二叉树的层数前面算过大概是log2(N)，结合堆的插入代码分析，堆的插入时间复杂度是O(logN)。

3.2.5.堆的删除 
  1. void swap(HeapDataType* parent, HeapDataType* child)
  2. {
  3. 	HeapDataType tmp = *parent;
  4. 	*parent = *child;
  5. 	*child = tmp;
  6. }
  7.  
  8. void AdjustDown(HeapDataType* a, int size, int parentcoordinate)
  9. {
  10. 	int childcoordinate = parentcoordinate * 2 + 1;
  11. 	
  12. 	while (childcoordinate < size)
  13. 	{
  14. 		if (a[childcoordinate] < a[childcoordinate + 1]&&childcoordinate+1<size)
  15. 		{
  16. 			childcoordinate++;
  17. 		}
  18. 		if (a[childcoordinate] > a[parentcoordinate])
  19. 		{
  20. 			swap(&a[childcoordinate], &a[parentcoordinate]);
  21. 			parentcoordinate = childcoordinate;
  22. 			childcoordinate = childcoordinate * 2 + 1;
  23. 		}
  24. 		else
  25. 		{
  26. 			break;
  27. 		}
  28. 	}
  29. }
  30.  
  31. void HeapPop(Heap* HP)
  32. {
  33. 	assert(HP);
  34. 	assert(HP->size > 0);
  35. 	swap(&HP->a[0], &HP->a[HP->size - 1]);
  36. 	HP->size--;
  37.  
  38. 	//向下调整
  39. 	AdjustDown(HP->a, HP->size,0);
  40. }

 对于堆的删除来说，数据结构规定删除的是堆顶的数据（根节点数据），当然删除完堆顶数据后，我们必须将剩余数据再构成大堆。

为啥删除的是堆顶的数据捏？因为堆顶的数据是堆中所有数据中最大的，删除完堆顶数据后新的堆顶就是“次大的”，这样的话我们可以做到选数的功能，后面可以更好体会。如果简单删除数组尾部数据的话不能实现选数的功能，没有意义。

完成堆的删除，我们采取将堆顶的数据根最后一个数据一换，然后删除数组最后一个数据，再进行向下调整算法。堆的删除过程画图理解如下：

同样堆的删除主要的时间消耗在向下调整函数上，而向下调整函数最多也是调整层数-1次，那么堆的删除时间复杂度也是O(logN)。

完成堆的删除，我们为什么不采用跟顺序表头删一样的挪动覆盖方法呢？因为如果采用了挪动覆盖之后剩余的数据下标关系全乱了，不成堆了；且挪动覆盖的时间复杂度是O(N)。

3.2.6.获取堆顶的数据
  1. HeapDataType HeapTop(Heap* HP)
  2. {
  3. 	assert(HP->size > 0);
  4. 	return HP->a[0];
  5. }

简单，返回a[0]即可。

3.2.7.堆的数据个数
  1. int HeapSize(Heap* HP)
  2. {
  3. 	return HP->size;
  4. }

根据设定，返回size即可。

3.2.8.堆的判空
  1. bool HeapEmpty(Heap* HP)
  2. {
  3. 	return HP->size == 0;
  4. }

当堆为空返回真，堆不为空返回假，所以容知上面代码逻辑可以实现逻辑自恰 。

3.2.9.堆的销毁
  1. void HeapDestroy(Heap* HP)
  2. {
  3. 	free(HP->a);
  4. 	HP->a = NULL;
  5. 	HP->capacity = HP->size = 0;
  6. }

销毁动态开辟的空间并将a置成NULL，将capacity和size置成0即可。

4.运行结构分析

各位老爷先看结果如下：

第一条语句：定义一组数组a，元素为100、90、80、110、75和3。

第二条语句：定义一个结构体变量p（创建堆p）。

第三条语句：调用HeapInit函数初始化p。

接下来for循环语句：取数组a成员依次入堆。由HeapPush函数可知，执行完这个for循环语句后，a元素构成大堆！

接下来for循环语句：打印大堆，得出110 100 80 90 75 3。可以看出这样存储确实是大堆。

接下来while循环：当堆不为空时，打印堆顶数据并删除堆顶数据！得出结果为110 100 90 80 75 3，是递减的。

从这里我们可以看出一点堆的管理数据的能力：

删除堆顶数据就是删除了（大）堆中最大的数据并将剩下的数据再成（大）堆，这样新的（大）堆的新的堆顶数据就是“次大的”，再删除堆顶数据再成（大）堆…………这样出来的数据就是递减的（小堆同理成递增）。

感谢阅读，如有不足，恳请指正，谢谢！ 

本文内容由网友自发贡献，转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号