【数据结构初阶】7. 二叉树

1. 二叉树的性质

对于任何二叉树 ，增加1个度为1的叶子结点 n0 和 n2 都不会发生变化
增加1个度为2的叶子结点 n0++,n2++
构建二叉树 ，一开始只有一个叶子结点 n0 = 1 n2 = 0 ，所以n0 = n2 + 1

习题：运用二叉树性质

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

答案：B n0=n2+1
n2 = 199则n0 =200

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

答案：A(/C) 顺序存储结构：数组，不完全二叉树，因为很多分支没有，会导致很多数组位置空缺，浪费空间
队列，因为是先入先出的结构，对于队头的操作频繁，适合使用链表，使用数组要频繁挪动数据
这里A选项最明显，选A

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

答案：A 对于完全二叉树，度为1的叶子结点 n1 最多只有1个 N = n0+n1+n2 又因为 n0 = n2+1
所以2n0 -1 + n1 = N = 2n ，所以n0 = n

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

答案：B 节点个数：531 对于完全二叉树 ：2^(h-1) <= N <= 2^h
解得：h = 10

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

答案：A n0+n1+n2 完全二叉树 n1 = 1/0 n0 = n2-1 2n0+n1-1 = 767
解得：n0 = 384

2. 二叉树的存储结构

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

1. 顺序存储
   顺序结构存储就是使用数组来存储，一般使用数组只适合表示完全二叉树，因为不是完全二叉树会有空间的浪费。
   堆就是用数组实现的完全二叉树
   
2. 链式存储
   二叉树的链式存储结构是指，用链表来表示一棵二叉树，即用链来指示元素的逻辑关系。 通常的方法是链表中每个结点由三个域组成，数据域和左右指针域，左右指针分别用来给出该结点左孩子和右孩子所在的链结点的存储地址 。
   链式结构又分为二叉链和三叉链
   

3. 二叉树链式结构的实现

创建二叉树（伪版）

typedef int BTDataType;

typedef struct BTNode
{
	BTDataType data;
	struct BTNode* left;
	struct BTNode* right;
}BTNode;

BTNode* CreatTree()
{
	//创建6个二叉树结点
	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->data = 1;
	n2->data = 2;
	n3->data = 3;
	n4->data = 4;
	n5->data = 5;
	n6->data = 6;

	// 根据二叉树结构将结点链接起来
	n1->left = n2;
	n1->right = n4;
	n2->left = n3;
	n2->right = NULL;
	n3->left = NULL;
	n3->right = NULL;
	n4->left = n5;
	n4->right = n6;
	n5->left = NULL;
	n5->right = NULL;
	n6->left = NULL;
	n6->right = NULL;
	return n1;
}

注意：上述代码并不是创建二叉树的方式，真正创建二叉树方式将在后续博客展开（重点）
再看二叉树基本操作前，再回顾下二叉树的概念，二叉树是：

1. 空树
2. 非空：根节点，根节点的左子树、根节点的右子树组成的。
   
   从概念中可以看出，二叉树定义是递归式的

4. 二叉树的遍历

前序、中序以及后序遍历
所谓二叉树遍历(Traversal)是按照某种特定的规则，依次对二叉树中的节点进行相应的操作，并且每个节点只操作一次。访问结点所做的操作依赖于具体的应用问题。 遍历是二叉树上最重要的运算之一，也是二叉树上进行其它运算的基础。
按照规则，二叉树的遍历有：前序/中序/后序的递归结构遍历：

1. 前序遍历(Preorder Traversal 亦称先序遍历)——访问根结点的操作发生在遍历其左右子树之前。
2. 中序遍历(Inorder Traversal)——访问根结点的操作发生在遍历其左右子树之中（间）。
3. 后序遍历(Postorder Traversal)——访问根结点的操作发生在遍历其左右子树之后。

4.1 前序遍历/中序遍历/后序遍历

// 二叉树前序遍历
void PreOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("NULL ");
		return;
	}
	printf("%d ", root->data);
	PreOrder(root->left);
	PreOrder(root->right);
}

// 二叉树中序遍历
void InOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("NULL ");
		return;
	}

	InOrder(root->left);
	printf("%d ", root->data);
	InOrder(root->right);
}

// 二叉树后序遍历
void PostOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("NULL ");
		return;
	}

	PostOrder(root->left);
	PostOrder(root->right);
	printf("%d ", root->data);
}

所以三种遍历方式的代码实现基本一致：区别只在于根节点访问的位置

4.2 结点个数

方案1：遍历二叉树求个数

// 方案1:遍历二叉树 计数++
void TreeSize(BTNode* root)
{
	int count = 0;
	if (root == NULL)
	{
		return 0;
	}
	count++;
	TreeSize(root->left);
	TreeSize(root->right);
}

在递归遍历二叉树的过程中 count放在函数体内部，每次递归调用该函数都会将count初始化为0 ，而且count计数的值无法带出（void）

优化1：static 修饰 count

该方式行不通

优化2：将count变为全局变量

方案2：递归分治子问题

4.3 叶子结点个数

int TreeLeafSize(BTNode* root)
{
	if (root == NULL)
	{
		return 0;
	}
	//叶子结点的特征
	if (root->left == NULL && root->right == NULL)
	{
		return 1;
	}
	return TreeLeafSize(root->left) + TreeLeafSize(root->right);
}

同样是采用递归分治的思想解决，递归分成左子树和右子树

4.4 树的高度

int TreeHeight(BTNode* root)
{
	if (root == NULL)
		return 0;
	//左子树高度
	int left_height = TreeHeight(root->left);
	//右子树高度
	int right_height = TreeHeight(root->right);
	return left_height > right_height ? left_height + 1 : right_height + 1;
}

4.5 第K层的结点个数

4.6 查找结点是否存在

BTNode* TreeFind(BTNode* root,BTDataType x)
{
	if (root == NULL)
		return NULL;
	if (root->data == x)
	{
		return root;
	}
	// 先去左树找
	BTNode* ret = TreeFind(root->left, x);
	if (ret != NULL)
	{
		return ret;
	}
	// 左树找不到，再到右树找
	ret = TreeFind(root->right, x);
	if ( ret != NULL)
	{
		return ret;
	}
	return NULL;
}

4.7 销毁二叉树

void BinaryTreeDestroy(BTNode* root)
{
	if (root == NULL)
		return;

	//类似于前序遍历的方法销毁结点
	BinaryTreeDestroy(root->left);
	BinaryTreeDestroy(root->right);
	free(root);
}

5. 二叉树例题

5.1 单值二叉树

5.2 相同的树

5.3 另一棵树的子树

bool isSameTree(struct TreeNode* p, struct TreeNode* q) {
    if (p == NULL && q == NULL)
        return true;

    //其中一个为空，另一个不为空
    if (p == NULL || q == NULL)
        return false;

    //都不为空
    if (p->val != q->val)
        return false;

    return isSameTree(p->left, q->left)
        && isSameTree(p->right, q->right);
}
bool isSubtree(struct TreeNode* root, struct TreeNode* subRoot){
    if(root == NULL)
        return false;
    // 终止条件为true（找到），否则就找到最后一个结点NULL 返回false
    if(root->val == subRoot->val && isSameTree(root,subRoot) == true)
        return true;
    // 左树找不到，再到右树找
    return isSubtree(root->left,subRoot)
        || isSubtree(root->right,subRoot);
}

要判断一棵树是否为另一棵树的子树 与 相同的树 的方法类似，只是增加一个遍历，到底从哪个结点开始判断是否是子树

5.4 二叉树的前序遍历

那么如何解决该问题呢？

5.5 二叉树遍历

首先通过先序遍历构建出二叉树的结构：

关键点：如何通过代码实现二叉树的创建，下述的代码才是真正版的二叉树创建（上面博客为伪版）

画递归展开图进一步理解

6. 层序遍历

**层序遍历：**除了先序遍历、中序遍历、后序遍历外，还可以对二叉树进行层序遍历。
设二叉树的根节点所在层数为1，层序遍历就是从所在二叉树的根节点出发，首先访问第一层的树根节点，然后从左到右访问第2层上的节点，接着是第三层的节点，以此类推，自上而下，自左至右逐层访问树的结点的过程就是层序遍历。

层序遍历的代码思路：
通过队列实现：若存在孩子结点，在该结点出队列的同时再将孩子结点入队列

6.1 合并队列和二叉树

将Queue.c 和Queue.h 加入该文件：

解决方案：将BTNode的定义也加入到Queue.h当中

这样Queue.c 和 Test.c 的问题都解决了

6.2 层序遍历的代码

// 层序遍历
void TreeLevelOrder(BTNode* root)
{
	Queue q;
	QueueInit(&q);
	if (root)
		// 首元素入队列
		QueuePush(&q, root);

	// 循环出队列，孩子结点入队列
	while (!QueueEmpty(&q))
	{
		//队首元素
		BTNode* front = QueueFront(&q);
		// 打印层序遍历结果
		printf("%d ", front->data);
		QueuePop(&q);
		if (front->left)
			QueuePush(&q, front->left);
		if (front->right)
			QueuePush(&q, front->right);
	}
	QueueDestroy(&q);
}

6.3 完全二叉树的判断

6.3.1 方法

6.3.2 代码实现

7. 深度优先遍历和广度优先遍历

通过前序和中序、中序和后序即可确定唯一二叉树，但是前序和后序无法确定唯一二叉树