【数据结构初阶】树&&二叉树

大家好我是沐曦希💕

---

1.树

1.1 树的概念

树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。
1.有一个特殊的结点，称为根结点，根节点没有前驱结点。
2.除根节点外，其余结点被分成M(M>0)个互不相交的集合T1、T2、……、Tm，其中每一个集合Ti(1<= i<= m)又是一棵结构与树类似的子树。每棵子树的根结点有且只有一个前驱，可以有0个或多个后继。
3.因此，树是递归定义的。


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

任何一个节点，有0~N个孩子，A可以看成是根，BCD看成A的孩子或者子树，B可以看成是E和F的的根，E和F可以看成是B的子树或者孩子。

1.2 树的相关概念

树的概念可以看成是树+人类的亲缘关系来理解。

1.节点的度：一个节点含有的子树的个数称为该节点的度； 如上图：A的为6，B和C的度为0，D和G的度为1…
2.叶节点或终端节点：度为0的节点称为叶节点； 如上图：B、C、H、I…等节点为叶节点。
3.非终端节点或分支节点：度不为0的节点； 如上图：A、D、E、F、G…等节点为分支节点。
4.双亲节点或父节点：若一个节点含有子节点，则这个节点称为其子节点的父节点； 如上图：A是B的父节点…
5.孩子节点或子节点：一个节点含有的子树的根节点称为该节点的子节点； 如上图：B是A的孩子节点…
6.兄弟节点(亲兄弟)：具有相同父节点的节点互称为兄弟节点； 如上图：B、C是兄弟节点…
7.树的度：一棵树中，最大的节点的度称为树的度； 如上图：树的度为6。
8.节点的层次：从根开始定义起，根为第1层，根的子节点为第2层，以此类推；
9.树的高度或深度：树中节点的最大层次； 如上图：树的高度为4。
10.堂兄弟节点：双亲在同一层的节点互为堂兄弟；如上图：H、I互为兄弟节点…
11.节点的祖先：从根到该节点所经分支上的所有节点；如上图：A是所有节点的祖先…
12.子孙：以某节点为根的子树中任一节点都称为该节点的子孙。如上图：所有节点都是A的子孙…
13.森林：由m（m>0）棵互不相交的树的集合称为森林。

树的高度或深度中计算根为第一层，还是计算根为第零层，没有明确规定。
如果根为第一层，那么空树的高度为零；如果根为第零层，那么空树的高度为负一层。
至于数组中为什么从零开始表示：因为arr[i] == *(a+i)，而i=0,相当于访问数组名，而数组名表示首元素地址。数组从零开始表示所以是为了数组访问的方便。

1.3 树的表示

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

#include
typedef int DataType;
typedef struct Node
{
	struct Node* child;     //左边第一个孩子的节点，无则指向空
	struct Node* brother;   //指向其下一个兄弟(亲兄弟)节点，无则指向空
	DataType val;           //结点中的数据域
}TreeNode;
1
2
3
4
5
6
7
8

父亲指向左边的第一个孩子，孩子之间用兄弟指针链接起来。

而要打印树呢：

typedef int DataType;
typedef struct Node
{
	struct Node* child;     //左边第一个孩子的节点，无则指向空
	struct Node* brother;   //指向其下一个兄弟(亲兄弟)节点，无则指向空
	DataType val;           //结点中的数据域
}TreeNode;
void PrinTree(TreeNode* parent)
{
	if (parent == NULL)
	{
		return;
	}
	printf("%d ", parent->val);
	TreeNode* cur = parent->child;
	while (cur)
	{
		cur = cur->brother;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

循环中用printf(%d ",cur)可以打印子树。
在学习并查集时，所用的是双亲表示法：

1.4 树在实际中的运用（表示文件系统的目录树结构）

树的现实运用：比如我们电脑中的目录文件：

Linux中的：

而下面学的二叉树就是树中一种特殊情况。

2.二叉树

2.1概念

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

1. 或者为空
2. 由一个根节点加上两棵别称为左子树和右子树的二叉树组成
   
   可以看出：
   /1. 二叉树不存在度大于2的结点
   /2. 二叉树的子树有左右之分，次序不能颠倒，因此二叉树是有序树。
   注意：对于任意的二叉树都是由以下几种情况复合而成的：
   

2.2 现实中的二叉树

2.3 特殊的二叉树

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

完全二叉树中如果一个节点没有左孩子，则一定没有右孩子，必定为一个叶子节点，最后一层一定为叶子节点，但是倒数第二层也可能存在叶子节点。

2.4 二叉树的性质💥

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

选择题

选择题1

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

因为任何一棵二叉树, 如果度为0其叶结点个数为n0 , 度为2的分支结点个数为 n2,则有 n0＝ n2＋1.，所以有200个度为0的结点即叶子节点。
答案：B

选择题2

2.下列数据结构中，不适合采用顺序存储结构的是（ ）
A 非完全二叉树
B 堆
C 队列
D 栈
1
2
3
4
5

虽然队列和非完全二叉树都不适合采用顺序存储结构，但是非完全二叉树更加不适合采用顺序存储结构。
答案是：A

选择题3

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

因为n0+n1+n2 = 2n,n0 = n2 + 1;而完全二叉树中度为1的节点数最多为1。
所以2*n0 - 1 + n1 = 2n;那么只有当n1为1时候符合条件，那么叶子节点个数是n
答案是：A

选择题4

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

h层的完全二叉树节点数的范围：[2^(h-1),2^h-1],故
2^(h-1)<531<2^h-1。
解得h=10
答案是：B

5.一个具有767个节点的完全二叉树，其叶子节点个数为（）
A 383
B 384
C 385
D 386
1
2
3
4
5

因为完全二叉树: 767=n0+n1+n2; n0=n2+1; 0<=n1<=1;
所以 2n0 - 1 + n1 = 767.
解的n0 = 384
答案是：B

3.二叉树的存储结构

二叉树一般可以使用两种结构存储，一种顺序结构，一种链式结构。
1.顺序存储
顺序结构存储就是使用数组来存储，一般使用数组只适合表示完全二叉树，因为不是完全二叉树会有空间的浪费。而现实中使用中只有堆才会使用数组来存储，关于堆我们后面的章节会专门讲解。二叉树顺序存储在物理上是一个数组，在逻辑上是一颗二叉树。

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

typedef int BTDataType;
// 二叉链
struct BinaryTreeNode
{
	struct BinTreeNode* _pLeft; // 指向当前节点左孩子
	struct BinTreeNode* _pRight; // 指向当前节点右孩子
	BTDataType _data; // 当前节点值域
}

// 三叉链
struct BinaryTreeNode
{
	struct BinTreeNode* _pParent; // 指向当前节点的双亲
	struct BinTreeNode* _pLeft; // 指向当前节点左孩子
	struct BinTreeNode* _pRight; // 指向当前节点右孩子
	BTDataType _data; // 当前节点值域
}；
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

4.二叉树的遍历

4.1 前序、中序以及后序遍历

学习二叉树结构，最简单的方式就是遍历。所谓二叉树遍历(Traversal)是按照某种特定的规则，依次对二叉树中的节点进行相应的操作，并且每个节点只操作一次。访问结点所做的操作依赖于具体的应用问题。 遍历是二叉树上最重要的运算之一，也是二叉树上进行其它运算的基础。

按照规则，二叉树的遍历有：前序/中序/后序的递归结构遍历：

1. 前序遍历(Preorder Traversal 亦称先序遍历)——访问根结点的操作发生在遍历其左右子树之前。
2. 中序遍历(Inorder Traversal)——访问根结点的操作发生在遍历其左右子树之中（间）。
3. 后序遍历(Postorder Traversal)——访问根结点的操作发生在遍历其左右子树之后。
   由于被访问的结点必是某子树的根，所以N(Node）、L(Left subtree）和R(Right subtree）又可解释为根、根的左子树和根的右子树。NLR、LNR和LRN分别又称为先根遍历、中根遍历和后根遍历。

4.1.1 前序遍历

void PreOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("NULL ");
		return;
	}
	printf("%d ", root->val);
	PreOrder(root->left);
	PreOrder(root->right);
}
1
2
3
4
5
6
7
8
9
10
11

4.1.2 中序遍历

// 二叉树中序遍历
void InOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("NULL ");
		return;
	}
	InOrder(root->left);
	printf("%d ", root->val);
	InOrder(root->right);
}
1
2
3
4
5
6
7
8
9
10
11
12

4.1.3 后序遍历

// 二叉树后序遍历
void PostOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("NULL ");
		return;
	}
	PostOrder(root->left);
	PostOrder(root->right);
	printf("%d ", root->val);
}
1
2
3
4
5
6
7
8
9
10
11
12

4.1.2 代码

#include
#include
#include
typedef int BTDataType;
typedef struct BinaryTreeNode
{
	BTDataType val;
	struct BinaryTreeNode* left;
	struct BinaryTreeNode* right;
}BTNode;
// 二叉树前序遍历
void PreOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("NULL ");
		return;
	}
	printf("%d ", root->val);
	PreOrder(root->left);
	PreOrder(root->right);
}
// 二叉树中序遍历
void InOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("NULL ");
		return;
	}
	InOrder(root->left);
	printf("%d ", root->val);
	InOrder(root->right);
}
// 二叉树后序遍历
void PostOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("NULL ");
		return;
	}
	PostOrder(root->left);
	PostOrder(root->right);
	printf("%d ", root->val);
}
int main()
{
	BTNode* n1 = (BTNode*)malloc(sizeof(BTNode));
	assert(n1);
	BTNode* n2 = (BTNode*)malloc(sizeof(BTNode));
	assert(n2);
	BTNode* n3 = (BTNode*)malloc(sizeof(BTNode));
	assert(n3);
	BTNode* n4 = (BTNode*)malloc(sizeof(BTNode));
	assert(n4);
	BTNode* n5 = (BTNode*)malloc(sizeof(BTNode));
	assert(n5);
	BTNode* n6 = (BTNode*)malloc(sizeof(BTNode));
	assert(n6);
	n1->val = 1;
	n2->val = 2;
	n3->val = 3;
	n4->val = 4;
	n5->val = 5;
	n6->val = 6;
	n1->left = n2;
	n1->right = n4;
	n2->left = n3;
	n2->right = NULL;
	n3->right = NULL;
	n3->left = NULL;
	n4->left = n5;
	n4->right = n6;
	n5->left = NULL;
	n5->right = NULL;
	n6->left = NULL;
	n6->right = NULL;
	PreOrder(n1);
	printf("\n");
	InOrder(n1);
	printf("\n");
	PostOrder(n1);
	printf("\n");
	free(n1);
	free(n2);
	free(n3);
	free(n4);
	free(n5);
	free(n6);
	n1 = NULL;
	n2 = NULL;
	n3 = NULL;
	n4 = NULL;
	n5 = NULL;
	n6 = NULL;
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

4.3 节点数

int TreeSize(BTNode* root)
{
	return root == NULL ? 0 : TreeSize(root->left) + TreeSize(root->right) + 1;
}
/*int TreeSize(BTNode* root)
{
	if (root == NULL)
		return 0;
	return TreeSize(root->left) + TreeSize(root->right) + 1;
}*/
1
2
3
4
5
6
7
8
9
10

4.4 叶子节点数

int TreeLeavesSize(BTNode* root)
{
	if (root == NULL)
		return 0;
	if (root->left == NULL && root->right == NULL)
		return 1;
	return TreeLeavesSize(root->left) + TreeLeavesSize(root->right);
}
1
2
3
4
5
6
7
8

4.5 树的高度

树的高度 = 左右子树大的那个+1。

int TreeHeight(BTNode* root)
{
	if (root == NULL)
		return 0;
	return TreeHeight(root->left) > TreeHeight(root->right) ? TreeHeight(root->left) + 1 : TreeHeight(root->right) + 1;
}
1
2
3
4
5
6

4.6 第K层节点的个数

//求第K层节点个数
int TreeKLevel(BTNode* root, int k)
{
	assert(k > 0);
	if (root == NULL)
		return NULL;
	if (k == 1)
		return 1;
	//转换成求子树第K-1层
	return TreeKLevel(root->left, k - 1) + TreeKLevel(root->right, k - 1);
}
1
2
3
4
5
6
7
8
9
10
11

4.7 二叉树查找

//二叉树的查找
BTNode* TreeFind(BTNode* root, BTDataType x)
{
	if (root == NULL)
		return NULL;
	if (root->val == x)
		return root;
	//先找左子树
	BTNode* lret = TreeFind(root->left, x);
	if (lret)
		return lret;
	//左子树没有，找右子树
	BTNode* rret = TreeFind(root->right, x);
	if (rret)
		return rret;
	return NULL;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

6.写在最后

那么二叉树的学习就到这里.。