【数据结构与算法】——二叉树

本文所用的的代码都在本人的gitee中mozhengy
本文代码使用多文件结构，如图

1. 树

1.1 树的概念与结构

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

• 有一个特殊的结点，称为根结点，根结点没有前驱结点。
• 每棵子树的根结点有且只有一个前驱，可以有0个或多个后继。因此，树是递归定义的。

树形结构中，子树之间不能有交集，否则就不是树形结构。子树是不相交的（如果存在相交就是图了，图以后的课程会有讲解）。

• 除了根结点外，每个结点有且仅有一个父结点。
• 一棵N个结点的树有N-1条边。

1.2 树相关术语🌲

• 父结点/双亲结点：若一个结点含有子结点，则这个结点称为其子结点的父结点；如上图：A是B的父结点。
• 子结点/孩子结点：一个结点含有的子树的根结点称为该结点的子结点；如上图：B是A的孩子结点。
• 结点的度：一个结点有几个孩子，它的度就是多少；比如A的度为6，F的度为2，K的度为0。
• 树的度：一棵树中，最大的结点的度称为树的度；如上图：树的度为6。
• 叶子结点/终端结点：度为0的结点称为叶结点；如上图：B、C、H、I…等结点为叶结点。
• 分支结点/非终端结点：度不为0的结点；如上图：D、E、F、G…等结点为分支结点。
• 兄弟结点：具有相同父结点的结点互称为兄弟结点（亲兄弟）；如上图：B、C是兄弟结点。
• 结点的层次：从根开始定义起，根为第1层，根的子结点为第2层，以此类推。
• 树的高度或深度：树中结点的最大层次；如上图：树的高度为4。
• 结点的祖先：从根到该结点所经分支上的所有结点；如上图：A是所有结点的祖先。
• 路径：一条从树中任意节点出发，沿父节点-子节点连接，达到任意节点的序列；比如A到Q的路径为：A-E-J-Q；H到Q的路径H-D-A-E-J-Q。
• 子孙：以某结点为根的子树中任一结点都称为该结点的子孙；如上图：所有结点都是A的子孙。
• 森林：由m(m>0)棵互不相交的树的集合称为森林。

1.3 树的表示

树结构相对线性表比较复杂，有很多种表示方式如：双亲表示法，孩子表示法、孩子双亲表示法以及孩子兄弟表示法等。我们这里就简单的了解其中最常用的孩子兄弟表示法。

struct TreeNode 
{ 
    struct Node* child; // 左边开始的第一个孩子结点 
    struct Node* brother; // 指向其右边的下一个兄弟结点
    int data; // 结点中的数据域 
}; 

如下图所示

2. 二叉树

2.1 概念与结构

在树形结构中，我们最常用的就是二叉树，一棵二叉树是结点的一个有限集合，该集合由一个根结点加上两棵别称为左子树和右子树的二叉树组成或者为空。

从上图可以看出二叉树具备以下特点：

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

注意：对于任意的二叉树都是由以下几种情况复合而成的：空树、只有根节点、只有左子树、只有右子树、左右子树均存在。

2.2 特殊的二叉树

2.2.1 满二叉树

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

2.2.2 完全二叉树

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

2.3 二叉树存储结构

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

2.3.1 顺序结构

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

现实中我们通常把堆使用顺序结构的数组来存储，需要注意的是这里的堆和操作系统虚拟进程地址空间中的堆是两回事，一个是数据结构，一个是操作系统中管理内存的一块区域分段。

2.3.2 链式结构

二叉树的链式存储结构是指，用链表来表示一棵二叉树，链表中每个结点由三个域组成，数据域和左右指针域，左右指针分别用来给出该结点左孩子和右孩 子所在的链结点的存储地址。链式结构又分为二叉链和三叉链，当前我们学习中一般都是二叉链。后面课程学到高阶数据结构如红黑树等会用到三叉链（后面会以C++的结构写出来）。

3. 实现链式结构二叉树

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

typedef int BTDataType;
// 二叉链
typedef struct BinaryTreeNode
{
    struct BinTreeNode* left;  // 指向当前结点左孩子
    struct BinTreeNode* right; // 指向当前结点右孩子
    BTDataType val;            // 当前结点值域
}BTNode;

后文都是以这棵二叉树为例
下面是本文的详细定义和其他方法的头文件

Tree.h

#pragma once
#include<stdio.h>
#include<stdlib.h>

//定义链式结构的二叉树
typedef char BTDataType;
typedef struct BinaryTreeNode
{
	BTDataType data;
	struct BinaryTreeNode* left;
	struct BinaryTreeNode* right;
}BTNode;

//前序遍历——根左右
void preOrder(BTNode* root);
//中序遍历
void inOrder(BTNode* root);
//后序遍历
void postOrder(BTNode* root);


// ⼆叉树结点个数
int BinaryTreeSize1(BTNode* root, int* psize);
int BinaryTreeSize2(BTNode* root);
//int BinaryTreeSize(BTNode* root,int* psize);
// ⼆叉树叶⼦结点个数
int BinaryTreeLeafSize(BTNode* root);
// ⼆叉树第k层结点个数
int BinaryTreeLevelKSize(BTNode* root, int k);
//⼆叉树的深度/⾼度
int BinaryTreeDepth(BTNode* root);
// ⼆叉树查找值为x的结点
BTNode* BinaryTreeFind(BTNode* root, BTDataType x);
// ⼆叉树销毁
void BinaryTreeDestory(BTNode** root);


//层序遍历
void leverOrder(BTNode* root);

3.1 前中后序遍历

3.1.1 遍历规则

• 前序遍历（Preorder Traversal 亦称先序遍历）：访问根结点的操作发生在遍历其左右子树之前，访问顺序为：根结点、左子树、右子树。

#include"Tree.h"
#include"Queue.h"
//前序遍历——根左右
void preOrder(BTNode * root)
{
	if (root == NULL)
	{
		printf("NULL ");
		return;
	}
	//先遍历根节点，再左右
	printf("%c ", root->data);
	preOrder(root->left);
	preOrder(root->right);
}

• 中序遍历（Inorder Traversal）：访问根结点的操作发生在遍历其左右子树之中（间），访问顺序为：左子树、根结点、右子树。

//中序遍历--左根右
void inOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("NULL ");
		return;
	}
	inOrder(root->left);
	printf("%c ", root->data);
	inOrder(root->right);
}

• 后序遍历（Postorder Traversal）：访问根结点的操作发生在遍历其左右子树之后，访问顺序为：左子树、右子树、根结点。

//后序遍历--左右根
void postOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("NULL ");
		return;
	}
	postOrder(root->left);
	postOrder(root->right);
	printf("%c ", root->data);
}

3.2 求二叉树相关概念个数问题

二叉树结点个数：
方法一：函数体定义一个形参传递地址，每递归一次+1，注意一定要采用指针的形式传地址，负责每次递归psize将被销毁

int BinaryTreeSize1(BTNode* root, int* psize)
{
	if (root == NULL)
	{
		return 0;
	}
	//结点非空，+1
	(*psize)++;
	BinaryTreeSize1(root->left, psize);
	BinaryTreeSize1(root->right, psize);

	return *psize;
}

方法二:结点个数 = 根节点个数（1）+左子树节点个数+右子树结点个数，采用递归的方法（优先采用👍）

int BinaryTreeSize2(BTNode* root)
{
	if (root == NULL)
	{
		return 0;
	}
	return 1 + BinaryTreeSize2(root->left)+ BinaryTreeSize2(root->right);

二叉树叶节点的个数
叶节点通俗来讲是没有孩子的结点，即以此节点为根，左右结点为NULL，仍然是递归的方法，

• 如果当前节点的左子节点指针 root->left 和右子节点指针 root->right 都为 NULL，说明该节点是叶子节点。此时函数返回 1，表示找到了一个叶子节点。
• 若当前节点不是叶子节点，函数会递归调用自身来分别计算左子树和右子树中的叶子节点数量。然后将这两部分的叶子节点数量相加并返回。

// ⼆叉树叶⼦结点个数
int BinaryTreeLeafSize(BTNode* root)
{
	if (root == NULL)
	{
		return 0;
	}
	if (root->left == NULL && root->right == NULL)
	{
		return 1;
	}
	return BinaryTreeLeafSize(root->left)+ BinaryTreeLeafSize(root->right);
}

⼆叉树第k层结点个数
当 k 等于 1 时，意味着已经递归到目标层级，此时当前节点就是第 k 层的一个节点，所以返回 1。
如果当前节点不是第 k （k>1）层的节点，那么需要递归地在左子树和右子树中继续寻找第 k 层的节点。递归调用时将 k 减 1，表示向下一层继续查找。最后将左子树和右子树中第 k 层的节点数量相加并返回。

// ⼆叉树第k层结点个数
int BinaryTreeLevelKSize(BTNode* root, int k)
{
	if (root == NULL)
	{
		return 0;
	}
	if (k == 1)
	{
		return 1;
	}
	return BinaryTreeLevelKSize(root->left, k - 1)+ BinaryTreeLevelKSize(root->right, k - 1);
}

⼆叉树的深度/⾼度
递归调用 BinaryTreeDepth 函数，计算当前节点左子树的深度，并将结果存储在 leftDep 变量中。
递归调用 BinaryTreeDepth函数，计算当前节点右子树的深度，并将结果存储在 rightDep 变量中。
使用三目运算符比较左子树深度 leftDep 和右子树深度 rightDep，取其中较大的值。
最大值+头结点 = 深度

//⼆叉树的深度/⾼度
int BinaryTreeDepth(BTNode* root)
{
	if (root == NULL)
	{
		return 0;
	}
	int leftDep = BinaryTreeDepth(root->left);
	int rightDep = BinaryTreeDepth(root->right);

	return 1 + (leftDep > rightDep ? leftDep : rightDep);
}

3.3 查找

分别递归左右子树，遍历查找，如果找到，返回该节点，未找到返回NULL

// ⼆叉树查找值为x的结点
BTNode* BinaryTreeFind(BTNode* root, BTDataType x)
{
	if (root == NULL)
	{
		return NULL;
	}
	if (root->data == x)
	{
		return root;
	}
	BTNode* leftFind = BinaryTreeFind(root->left, x);
	if (leftFind)
	{
		return leftFind;
	}
	BTNode* rightFind = BinaryTreeFind(root->right, x);
	if (rightFind)
	{
		return rightFind;
	}
	return NULL;
}

3.4 层序遍历

除了先序遍历、中序遍历、后序遍历外，还可以对二叉树进行层序遍历。设二叉树的根结点所在层数为1，层序遍历就是从所在二叉树的根结点出发，首先访问第一层的树根结点，然后从左到右访问第2层上的结点，接着是第三层的结点，以此类推，自上而下，自左至右逐层访问树的结点的过程就是层序遍历。
（队列的代码见本文我的giteeTree或前面的博客队列）
注意 Queue.h与Queue.c

void leverOrder(BTNode* root)
{
	Queue q;
	QueueInit(&q);
	QueuePush(&q, root);
	while (!QueueEmpty(&q))
	{
		//取队头，出队头
		BTNode* top = QueueFront(&q);
		QueuePop(&q);
		printf("%c ", top->data);
		//将队头非空左右孩子入队列
		if (top->left)
			QueuePush(&q, top->left);
		if (top->right)
			QueuePush(&q, top->right);
	}
	QueueDestroy(&q);
}

3.5 二叉树的销毁

• 递归销毁左子树：BinaryTreeDestory(&((*root)->left)); 以当前节点的左子节点为根，递归调用 BinaryTreeDestory 函数来销毁左子树。这里使用&((*root)->left)是为了将左子节点指针的地址传递给函数，以便在销毁过程中可以正确修改左子节点指针。
• 递归销毁右子树：BinaryTreeDestory(&((*root)->right)); 同理，以当前节点的右子节点为根，递归调用 BinaryTreeDestory 函数来销毁右子树。
  遍历左右结点，最后释放头结点

void BinaryTreeDestory(BTNode** root)
{
	if (*root == NULL)
	{
		return;
	}
	BinaryTreeDestory(&((*root)->left));
	BinaryTreeDestory(&((*root)->right));
	free(*root);
	*root = NULL;
}

test.c

#include"Tree.h"



BTNode* buyNode(char x)
{
	BTNode* node = (BTNode*)malloc(sizeof(BTNode));
	node->data = x;
	node->left = node->right = NULL;

	return node;
}
BTNode* createBinaryTree()
{
	BTNode* nodeA = buyNode('A');
	BTNode* nodeB = buyNode('B');
	BTNode* nodeC = buyNode('C');
	BTNode* nodeD = buyNode('D');
	BTNode* nodeE = buyNode('E');
	BTNode* nodeF = buyNode('F');

	nodeA->left = nodeB;
	nodeA->right = nodeC;
	nodeB->left = nodeD;
	nodeC->left = nodeE;
	nodeC->right = nodeF;

	return nodeA;
}

void test()
{
	BTNode* root = createBinaryTree();
	printf("前序遍历\n");
	preOrder(root);
	printf("\n");
	printf("后序遍历\n");
	inOrder(root);
	printf("\n");
	printf("中序遍历\n");
	postOrder(root);
	printf("\n");


	printf("size1:%d\n", BinaryTreeSize2(root));
	int size = 0;
	printf("size2:%d\n", BinaryTreeSize1(root, &size));

	int leaf = BinaryTreeLeafSize(root);
	printf("叶子结点的个数为：%d\n", leaf);

	int loc = BinaryTreeLevelKSize(root, 3);
	printf("第%d层结点个数为%d\n", 3, loc);

	int depth = BinaryTreeDepth(root);
	printf("二叉树的深度：%d\n", depth);

	if (BinaryTreeFind(root, 'D'))
	{
		printf("找到了！\n");
	}
	else
	{
		printf("没找到！\n");
	}

	//层序遍历
	leverOrder(root);
}

int main()
{
	test();
	return 0;
}

结语

如有错误，请多多指正，共同进步