Day6：数据结构之二叉树

Posted 2021-09-06 雨轩（小宇）

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Day6：数据结构之二叉树相关的知识，希望对你有一定的参考价值。

目录	目录
顺序表	单链表（不带附加头结点）
双链表（带附加头结点）	栈（顺序表实现）
队列（链式，不带附加头结点）	二叉树

前言

学习二叉树前，我们先来了解树的基本概念，为学习二叉树铺垫

由于二叉树是递归实现的，所以不懂递归的小伙伴先去看看递归
先学好递归，在学二叉树

树的基本概念

1、树的定义

树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。当 n = 0 时，T称为空树；否则，T是非空树，记作

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

2、树的相关术语

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

二叉树的基本概念

1、二叉树的定义

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

或者为空
或者由一个根节点加上两棵别称为左子树和右子树、互不相交的二叉树组成

二叉树的特点：

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

所以二叉树有下面几种复合情况：

2、二叉树的性质

二叉树具有如下性质：

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

3、特殊的二叉树

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

完全二叉树：完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树而引出来的。对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树。 其特点是：从上面第 1 层到第 k - 1层的所有各层的结点数都是满的，仅最下面第 k 层或是满的，或从右向左连续缺失若干结点。要注意的是满二叉树是一种特殊的完全二叉树。

二叉树的实现方式

二叉树一般有数组存储和链式存储两种方式：

普通的二叉树是不适合用数组来存储的，因为可能会存在大量的空间浪费。而完全二叉树更适合使用顺序结构存储。现实中我们通常把堆(一种二叉树)使用顺序结构的数组来存储，需要注意的是这里的堆和操作系统虚拟进程地址空间中的堆是两回事，一个是数据结构，一个是操作系统中管理内存的一块区域分段。

使用链表存储克服了数组存储浪费空间的缺点。链式存储二叉树的结点至少包含三个域，数据域data，左子女结点指针leftChild 和右子女结点指针 rightChild。这种链表称为二叉链表。

二叉树的基本操作

头文件

#pragma once // 防止头文件重复包含
#include<stdio.h> 
#include<stdlib.h> // 动态内存函数头文件
#include<stdbool.h> // bool 头文件
typedef char DataType; // char重命名
typedef struct Node
{
	DataType data; // 数据域
	struct Node* leftChild; // 左子女
	struct Node* rightChild; // 右子女
}BinTree;
void CreateBinTree(BinTree** T);
//BinTree* CreateBinTree();// 先序建立二叉树
void PreOrderTraverse(BinTree* T);// 先序遍历
void InOrderTraverse(BinTree* T);// 中序遍历
void PostOraderTraverse(BinTree* T);// 后序遍历
void PrintBinTree(BinTree* T);// 广义表打印
size_t BinTreeHeight(BinTree* T);// 树的深度/高度
size_t BinTreeSize(BinTree* T);// 树的结点个数
size_t BinTreeLeadCount(BinTree* T);// 叶子结点个数
bool BinTreeIsEmpty(BinTree* T); // 判断二叉树是否为空？
size_t BinTreeNode_1Size(BinTree* T);// 统计度为1的结点个数
size_t BinTreeNode_2Size(BinTree* T);// 度为2的结点个数
void PrintBinTreeNode_TPath(BinTree* T, char path[], int pathlen);//输出二叉树中从每个叶子结点到根结点的路径
void ChangeBinTreeLRNode(BinTree* T);// 交换左右结点
void DoubleOradeTraverse(BinTree* T);
// 双序遍历是指对于二叉树的每一个结点来说，先访问这个结点，再按双序遍历它的左子树，
// 然后再一次访问这个结点，接下来按双序遍历它的右子树
void Destory(BinTree* T); // 释放树结点

1、先序建立二叉树

形参采用二级指针的方式进行初始化，在里面进行创建数的结点，先创建根节点，在递归创建左子树和右子树。

void CreateBinTree(BinTree** T)
{
	DataType ch;
	scanf("%c", &ch); // 输入数据
	if (ch == '#') // #表示为空的结点
		*T = NULL;
	else
	{
		*T = (BinTree*)malloc(sizeof(BinTree));// 开辟内存
		if (*T == NULL)// 创建失败
		{
			perror("MALLOC T");// 错误报警信息
			exit(-1); // 退出
		}
		(*T)->data = ch; // 赋值
		CreateBinTree(&(*T)->leftChild); // 递归创建左子树
		CreateBinTree(&(*T)->rightChild); // 递归创建右子树
	}
}

2、先序遍历

先遍历根节点，在递归遍历左子树和右子树

void PreOrderTraverse(BinTree *T)
{
	if (T!=NULL)
	{
		printf("%c ", T->data);
		PreOrderTraverse(T->leftChild);
		PreOrderTraverse(T->rightChild);
	}
}

3、中序遍历

先递归遍历左子树，在遍历根节点，最后递归遍历右子树

void InOrderTraverse(BinTree* T)
{
	if (T != NULL)
	{
		InOrderTraverse(T->leftChild);
		printf("%c ", T->data);
		InOrderTraverse(T->rightChild);
	}
}

4、后序遍历

先递归遍历左子树，再递归遍历右子树，最后遍历根节点。

void PostOraderTraverse(BinTree* T)
{
	if (T != NULL)
	{
		PostOraderTraverse(T->leftChild);
		PostOraderTraverse(T->rightChild);
		printf("%c ", T->data);
	}
}

5、先序遍历（广义表）

在左子女不为空或者右子女不为空时，打印 ‘(’，在递归遍历左子树，左遍历完了，打印 ‘，’，在右子树不为空的情况下，递归遍历右子树，最后遍历完，打印 ‘）’。

void PrintBinTree(BinTree* T)
{
	if (T != NULL)
	{
		printf("%c", T->data);
		if (T->leftChild != NULL || T->rightChild != NULL)// 检查左子女或右子女是否为空
		{
			printf("("); // 有左子女或右子女打印 ( 进行闭合
			PrintBinTree(T->leftChild);// 递归遍历左子树
			printf(","); // 左遍历完了或者左子女为空，打印 ，
			if(T->rightChild != NULL) // 右子女不为空，在递归遍历右子树
				PrintBinTree(T->rightChild);
			printf(")"); // 右子女遍历完毕，打印 ）
		}
	}
}

6、二叉树的深度（高度）

递归遍历到左子树或者右子树的叶子结点，通过比较左子树和右子树的深度，取其最大值 + 1 即是树的深度。

size_t BinTreeHeight(BinTree* T)
{
	if (T == NULL) // 为空返回深度为0
		return 0;
	else
	{
		int m = BinTreeHeight(T->leftChild); // 递归左子树
		int n = BinTreeHeight(T->rightChild); // 递归右子树
		if (m > n)
			return m + 1; // 取其最大值 + 1 即上一层的深度
		else
			return n + 1;
	}
}

7、二叉树的结点数

分别递归求出左子树的结点个数和右子树的结点个数，在加结点个数即是整个二叉树的结点个数

size_t BinTreeSize(BinTree* T)
{
	if (T == NULL)
		return 0;
	else
		return BinTreeSize(T->leftChild) + BinTreeSize(T->rightChild) + 1;
}

8、二叉树的叶结点个数

叶结点是度为0的结点，所以判断其左子女和右子女为空时，计算其个数即可

size_t BinTreeLeadCount(BinTree* T)
{
	if (T == NULL)
		return 0;
		// 叶结点才返回 1
	if (T->leftChild == NULL && T->rightChild == NULL)
	{
		return 1;
	}
	else
		return BinTreeLeadCount(T->leftChild) + BinTreeLeadCount(T->rightChild);
		// 递归遍历左子树和右子树
}

9、度为1的结点个数

度为1的结点是指左右子女其中一个为空的结点，所以这里递归遍历整个二叉树，在度为1的条件下遍历，左子树 + 右子树即度为 1 的结点个数

size_t BinTreeNode_1Size(BinTree* T)
{
	if (!T)
		return 0;
	// 度为1的结点，左右必定有一个为空
	if ((!T->leftChild  && T->rightChild) || (T->leftChild && !T->rightChild))
		return 1 + BinTreeNode_1Size(T->leftChild) + BinTreeNode_1Size(T->rightChild);
		// 度为1的结点数
	else
		return BinTreeNode_1Size(T->leftChild) + BinTreeNode_1Size(T->rightChild);
		// 此结点不是度为1的结点，继续遍历下一个左子女和右子女
}

10、度为2的结点个数

跟求度为1的结点个数一样，左右子女都不为空的条件下遍历整个二叉树，左子树 + 右子树即度为 2 的结点个数

size_t BinTreeNode_2Size(BinTree* T)
{
	if (!T)
		return 0;
		// 度为2的结点个数左右子女都不为空（两条分支）
	if (T->leftChild && T->rightChild)
		return 1 + BinTreeNode_2Size(T->leftChild) + BinTreeNode_2Size(T->rightChild);
	else
		return BinTreeNode_2Size(T->leftChild) + BinTreeNode_2Size(T->rightChild);
		// 此结点不是度为2的结点，继续遍历下一个左子女和右子女
}

11、返回每条叶结点到根结点的路径

这里要用一个数组来保存路径，遍历到叶结点在循环打印路径

// 将路径保存在数组中
void PrintBinTreeNode_TPath(BinTree* T, char path[], int pathlen)
{
	if (T)
	{
		path[pathlen] = T->data; // 保存到数组
		// 遍历到叶结点，循环打印路径
		if (!T->leftChild && !T->rightChild)
		{
			for (int i = pathlen; i >= 0; i--)
				printf("%c ", path[i]);
			printf("\\n");
		}
		else // 继续递归遍历，直到叶结点
		{
			PrintBinTreeNode_TPath(T->leftChild, path, pathlen + 1);
			PrintBinTreeNode_TPath(T->rightChild, path, pathlen + 1);
		}
	}
}

12、交换左右结点

在结点不为空的情况下，创建临时数结点进行交换即可

void ChangeBinTreeLRNode(BinTree* T)
{
	BinTree* temp; // 临时交换结点
	if (T)
	{
		temp = T->leftChild;
		T->leftChild = T->rightChild;
		T->rightChild = temp;
		ChangeBinTreeLRNode(T->leftChild);
		ChangeBinTreeLRNode(T->rightChild);
	}
}

13、双序遍历

双序遍历是指对于二叉树的每一个结点来说，先访问这个结点，再按双序遍历它的左子树，然后再一次访问这个结点，接下来按双序遍历它的右子树

void DoubleOradeTraverse(BinTree* T)
{
	if (T)
	{
		printf("%c", T->data); 
		DoubleOradeTraverse(T->leftChild);
		printf("%c", T->data);
		DoubleOradeTraverse(T->rightChild);
	}
}

14、销毁树

先递归销毁左子树和右子树，最后在销毁根结点即可

void Destory(BinTree* T)
{
	if (T)
	{
		Destory(T->leftChild);
		Destory(T->rightChild);
		free(T);
	}
}

二叉树的注意事项

通过以上的学习，可以看出递归的重要性和难度

要注意先序，中序，后序，遍历的先后顺序，是先访问根结点，还是递归访问左子树，在递归访问右子树，这些逻辑需要读者自理清楚
利用二叉树的性质求解一些结点个数，要注意求解的条件，二叉树夹着递归，难免不让人一头雾水

源码：链接

制作不易，记得三连！！！

以上是关于Day6：数据结构之二叉树的主要内容，如果未能解决你的问题，请参考以下文章

SDUT 3341 数据结构实验之二叉树二：遍历二叉树