数据结构二叉树

Kiki529

于 2024-09-14 11:52:54 发布

阅读量570

点赞数 18

文章标签：数据结构

本文链接：https://blog.csdn.net/weixin_67645591/article/details/141959094

版权

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

文章目录

前言
一、pandas是什么？
二、使用步骤
- 1.引入库
- 2.读入数据
总结

前言

一、二叉树是什么？

想要知道二叉树是什么，先要知道树是什么

1.树的概念及结构

1.1树的概念

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

有一个特殊的结点，称为根结点，根节点没有前驱结点。

除根节点外，其余结点被分成M(M>0)个互不相交的集合T1、T2、……、Tm，其中每一个集合Ti(1<= i<= m)又是一棵结构与树类似的子树。

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

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

1.2 树的相关概念

下列标红的概念是最重要也是最常用的。

节点的度：一个节点含有的子树的个数称为该节点的度；如上图：A的为6。

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

1.3树的表示

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

typedef int DataType;
struct Node
{
    struct Node* LeftChild; // 第一个孩子结点
    struct Node* RightBrother; // 指向其下一个兄弟结点
    DataType Data; // 结点中的数据
};

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

了解了这么多关于树的概念之后，有助于我们理解二叉树。

2.二叉树概念及结构

2.1二叉树的概念

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

从上图可以看出：
1. 二叉树不存在度大于2的结点
2. 二叉树的子树有左右之分，次序不能颠倒，因此二叉树是有序树

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

2.2特殊的二叉树

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

2.3二叉树的性质

1. 若规定根节点的层数为1，则一棵非空二叉树的第i层上最多有 $2^{i-1}$ 个结点。
2. 若规定根节点的层数为1，则深度为h的二叉树的最大结点数是 $2^{h-1}$ .
3. 对任何一棵二叉树, 如果度为0其叶结点个数为 $n_{0}$ , 度为2的分支结点个数为 $n_{2}$ ,则有 $n_{0}$ ＝ $n_{2}$ ＋1
4. 若规定根节点的层数为1，具有n个结点的满二叉树的深度，h= $\log_{2}(n+1)$ .

(ps： $\log_{2}(n+1)$ 是log以2为底，n+1为对数)

5.高度为h的完全二叉树，节点数量的范围[2^(h-1),2^h-1]

6. 对于具有n个结点的完全二叉树，如果按照从上至下从左至右的数组顺序对所有节点从0开始编号，则对于序号为i的结点有：
1. 若i>0，i位置节点的双亲序号：(i-1)/2；i=0，i为根节点编号，无双亲节点
2. 若2*i+1<n，左孩子序号：2*i+1，2*i+1>=n否则无左孩子
3. 若2*i+2<n，右孩子序号：2*i+2，2*i+2>=n否则无右孩子

2.4二叉树的存储结构

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

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; // 当前节点值域
}；

3.二叉树的顺序结构及实现

3.1二叉树的顺序结构及实现

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

3.2 堆的概念及结构

如果有一个关键码的集合K = { $k_{0}$ ， $k_{1}$ ， $k_{2}$ ，…， $k_{n-1}$ }，把它的所有元素按完全二叉树的顺序存储方式存储在一个一维数组中，并满足： $k_{i}$ <= $k_{2*i+1}$ 且 $k_{i}$ <= $k_{2*i+2}$ ( $k_{i}$ >= $k_{2*i+1}$ 且 $k_{i}$ >= $k_{2*i+2}$ ) i = 0，1，2…，则称为小堆(或大堆)。

将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。
堆的性质：

堆中某个节点的值总是不大于或不小于其父节点的值；
堆总是一棵完全二叉树。

如上图小根堆示例：

30的下标为4，它的父亲节点15的下标为1，

父亲节点下标计算公式（孩子节点下标-1）/2，即(4-1)/2=1,而1正是15的下标。

15的下标为1，它的左孩子节点25的下标为3，它的右孩子节点30的下标为4，

孩子节点下标计算公式 左孩子节点下标=父亲节点下标*2+1；右孩子节点下标=父亲节点下标*2+2

1*2+1=3；1*2+2=4；

3.3 堆的实现

3.3.1堆向下调整算法

现在我们给出一个数组，逻辑上看做一颗完全二叉树。我们通过从根节点开始的向下调整算法可以把它调整成一个小堆。向下调整算法有一个前提：左右子树必须是一个堆，才能调整。

堆的定义：完全二叉树就是堆。

int array[] = {27,15,19,18,28,34,65,49,25,37};

向下调整代码：

//向下调整
void AdjustDown(HPDataType* a,int n,int parent)
{
	int child = parent * 2 + 1;
	while (child<n)
	{
        //防止该节点只有左孩子，没有右孩子，导致越界访问
        //通过控制这里大<和>来控制建大堆还是小堆
		if (child + 1 < n && a[child] >a[child+1])
		{
			child++;
		}
		//父亲<孩子
        //通过控制这里大<和>来控制建大堆还是小堆
		if (a[parent] >a[child])
		{
			swap(&a[parent], &a[child]);
			parent=child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

这里建小堆时，双亲节点要小于两个孩子节点中最小的，

这里建大堆时，双亲节点要大于两个孩子节点中最大的，

3.3.2堆的创建

下面我们给出一个数组，这个数组逻辑上可以看做一颗完全二叉树，但是还不是一个堆，现在我们通过算法，把它构建成一个堆。根节点左右子树不是堆，这里我们从倒数的第一个非叶子节点的子树开始调整，一直调整到根节点的树，就可以调整成堆。这里采用的是向下调整建堆。

int a[] = {1,5,3,8,7,6};

3.3.3 建堆时间复杂度

因为堆是完全二叉树，而满二叉树也是完全二叉树，此处为了简化使用满二叉树来证明(时间复杂度本来看的就是近似值，多几个节点不影响最终结果)这里建堆采用的是向下调整算法。

因此：建堆的时间复杂度为O(N)。

这里的h-1层是因为向下调整只需要调整到倒数第2层就可以了。每层的节点向下调整该层所需的最大次数*该层的节点个数，然后再相加就是建堆的时间复杂度。(如果对时间复杂度不太了解可以去看我的另一篇文章http://t.csdnimg.cn/fmDEl)

3.3.4堆的向上调整算法

为了防止大家搞混向上调整算法和向下调整算法，特地把向上调整算法放到了建堆和算时间复杂度的后面。

先插入一个10到数组的尾上，再进行向上调整算法，直到满足堆。

向上调整代码：

//向上调整
void AdjustUp(HPDataType* a,int n)
{
	int child = n - 1;            //孩子节点的下标
	int parent = (child- 1) / 2;  //父亲节点的下标
	//child和parent永远>=0
	while(child>0)
	{
		//孩子<父亲
        //通过控制这里大<和>来控制建大堆还是小堆
		if ( a[parent] < a[child])
		{
			swap(& a[parent], & a[child]);//交换两个节点数据
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

向上调整的时间复杂度是O( $N*\log N$ ) 。它的计算方法和向下调整相同，只不过因为最后一层的节点个数占整棵树节点个数的一半，向下调整时节点越靠下，调整的次数越少；而向上调整时节点越靠下，调整的次数越多；

向上调整仅最后一层的节点个数就有 $2^{h-1}$ 个，最多需要向上调整h-1次，最后一层的时间复杂度就为O( $N*\log N$ ),整体算下来向上调整的时间复杂度就为O( $N*\log N$ )。

最后一层时间复杂度解析：

高度为h的完全二叉树，节点数量的范围[2^(h-1),2^h-1]，而N是节点总数，(满二叉树，最坏情况)， $N=2^{h-1}$ 根据对数转指数公式得 $h=\log_{2}(N+1)$ .

最后一层的节点个数 $n=2^{h-1}$ ,n*(h-1)=最后一层的时间复杂度.

$2^{h-1}*(h-1)$ 化简一下得 $2^{h-1}*h-2^{h-1}$ ，因为 $h=\log_{2}(N+1)$ 和 $a^{\log_{a}N}=N$ 得 $n*\log_{2}n+\log_{2}n-(n+1)$ ,根据大O渐进表示法得复杂度为O( $N*\log N$ )。

ps:这只是向上调整算法最后一层的时间复杂度,整体算下来的时间复杂度也为O( $N*\log N$ )。

有兴趣可以完整的算一下，即使不会算也没问题，记住算法的复杂度就是了。

3.3.5 堆的插入

#define Initcapacity 5//初始堆的容量
typedef int HPDataType;
typedef struct Heap {
	HPDataType* a;    //存放堆的空间
	int size;         //堆的节点个数
	int capacity;     //对的容量大小
}Heap;
//初始化堆
void HeapInit(Heap* php);
//插入堆
void HeapPush(Heap* php, HPDataType x);
//判断堆是否为空
bool HeapEmpty(Heap* php);
//删除堆
void HeapDelete(Heap* php);
// 堆的销毁
void HeapDetsory(Heap* php);
//取栈顶元素
HPDataType HeapTop(Heap* php);
//向下调整
void AdjustDown(HPDataType* a, int n, int parent);
//向上调整
void AdjustUp(HPDataType* a, int child);

插入堆之前，先初始化堆

//初始化堆
void HeapInit(Heap* php)；

//初始化堆
void HeapInit(Heap* php)
{
	assert(php);
	HPDataType* tmp = (HPDataType*)malloc(sizeof(HPDataType) * Initcapacity);
	assert(tmp);
	php->a = tmp;
	php->capacity = Initcapacity;
	php->size = 0;
}

//插入堆
void HeapPush(Heap* php, HPDataType x)；

//插入堆
void HeapPush(Heap* php, HPDataType x)
{
	assert(php);
	//判满
	if (php->capacity == php->size)
	{
		//扩容
		HPDataType* tmp = (HPDataType*)realloc(php->a,sizeof(HPDataType) * php->capacity*2);
		assert(tmp);
		php->capacity *= 2;
	}
	php->a[php->size++] = x;
    //这里用的是向上调整来建堆，也可以用向下调整来建堆
	AdjustUp(php->a,php->size);

}

向上调整使用条件方便简单，时间复杂度相较于向下调整较高，但使用向下调整需要保证子树为堆。

3.3.6 堆的删除

删除堆是删除堆顶的数据，将堆顶的数据根最后一个数据一换，然后删除数组最后一个数据，再进行向下调整算法。

//删除堆
void HeapDelete(Heap* php)；

//删除堆
void HeapDelete(Heap* php)
{
	assert(php);
	assert(!HeapEmpty(php));
	//删除堆是删除堆顶的数据，将堆顶的数据根最后一个数据一换，然后删除数组最后一个数据，再进行向下调整。
	swap(&php->a[0], &php->a[php->size - 1]);
	php->size--;
	AdjustDown(php->a,php->size,0);
}

//判断堆是否为空
bool HeapEmpty(Heap* php)；

//判断堆是否为空
bool HeapEmpty(Heap* php)
{
	assert(php);
	return php->size == 0;
}

// 堆的销毁
void HeapDetsory(Heap* php)；

// 堆的销毁
void HeapDetsory(Heap* php)
{
	assert(php);
	free(php->a);
}

//取栈顶元素
HPDataType HeapTop(Heap* php)；

//取栈顶元素
HPDataType HeapTop(Heap* php)
{
    assert(php);
    assert(!HeapEmpty(php));
    return php->a[0];
}

3.4 堆的应用

3.4.1排序

堆排序即利用堆的思想来进行排序，总共分为两个步骤：
1. 建堆

升序：建大堆
降序：建小堆

2. 利用堆删除思想来进行排序

建堆和堆删除中都用到了向下调整，因此掌握了向下调整，就可以完成堆排序。

//向下调整
void AdjustDown(HPDataType* a,int n,int parent)
{
	int child = parent * 2 + 1;
	while (child<n)
	{
        //防止该节点只有左孩子，没有右孩子，导致越界访问
        //通过控制这里大<和>来控制建大堆还是小堆
		if (child + 1 < n && a[child] <a[child+1])
		{
			child++;
		}
		//父亲<孩子
        //通过控制这里大<和>来控制建大堆还是小堆
		if (a[parent] <a[child])
		{
			swap(&a[parent], &a[child]);
			parent=child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}
void sort2(int* a, int n)
{
	//向下调整建堆 排升序建大堆
	//最后一个父亲节点
	for (int i = (n - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(a, n, i);
	}
    //end是尾节点的下标
	int end = n - 1;
    //end为0时表示堆只剩一个节点，所以只要大于0即可
	while (end > 0)
	{
    //交换堆顶和堆的最后一个节点
		swap(&a[0], &a[end]);
		AdjustDown(a, end, 0);
		end--;
	}
}

3.4.2 TOP-K问题

TOP-K问题：即求数据结合中前K个最大的元素或者最小的元素，一般情况下数据量都比较大。
比如：专业前10名、世界500强、富豪榜、游戏中前100的活跃玩家等。
对于Top-K问题，能想到的最简单直接的方式就是排序，但是：如果数据量非常大，排序就不太可取了(可能数据都不能一下子全部加载到内存中)。最佳的方式就是用堆来解决，基本思路如下：
1. 用数据集合中前K个元素来建堆

前k个最大的元素，则建小堆
前k个最小的元素，则建大堆

2. 用剩余的N-K个元素依次与堆顶元素来比较，不满足则替换堆顶元素

将剩余N-K个元素依次与堆顶元素比完之后，堆中剩余的K个元素就是所求的前K个最小或者最大的元素。

void PrintTopK(int* a, int n, int k)
{
	// 1. 建堆--用a中前k个元素建堆--用的是向下调整建堆
	for (int i = (k-1-1)/2; i >=0; i--)
	{
		AdjustDown(a, k, i);
	}
	// 2. 将剩余n-k个元素依次与堆顶元素交换，不满则则替换
	for (int i =k; i <=n; i++)
	{
		if (a[0] < a[i])
		{
			swap(&a[0], &a[i]);
			AdjustDown(a, k, 0);
		}
	}
	//排序
	int end = k -1;
	while (end > 0)
	{
		swap(&a[0], &a[end]);
		AdjustDown(a, end, 0);
		end--;
	}
	for (int i = 0; i < k; i++)
	{
		printf("%d ", a[i]);
	}
}
//创建一个大容量的数据
void TestTopk()
{
	int n = 10000;
	int* a = (int*)malloc(sizeof(int) * n);
	srand(time(0));
	for (int i = 0; i < n; ++i)
	{
		a[i] = rand() % 1000000;
	}
//这里是为了我们容易检查，看找到的数据是否正确，自己赋值的大于1000000的数
	a[5] = 1000000 + 1;
	a[10] = 1000000 + 2;
	a[531] = 1000000 + 3;
	a[5121] = 1000000 + 4;
	a[115] = 1000000 + 5;
	a[2335] = 1000000 + 6;
	a[9999] = 1000000 + 7;
	a[76] = 1000000 + 8;
	a[423] = 1000000 + 9;
	a[153] = 1000000 + 10;
	PrintTopK(a, n, 10);
}

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

看到这里你已经把二叉树的顺序结构(数组)看完了，终于到二叉树的链式结构了。

二叉树是：
1. 空树
2. 非空：根节点，根节点的左子树、根节点的右子树组成的。

从概念中可以看出，二叉树定义是递归式的，因此后序基本操作中基本都是按照该概念实现的。

4.1二叉树的遍历

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

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

按照规则，二叉树的遍历有：前序/中序/后序的递归结构遍历：
1. 前序遍历(Preorder Traversal 亦称先序遍历)——访问根结点的操作发生在遍历其左右子树之前。
2. 中序遍历(Inorder Traversal)——访问根结点的操作发生在遍历其左右子树之中（间）。
3. 后序遍历(Postorder Traversal)——访问根结点的操作发生在遍历其左右子树之后。

由于被访问的结点必是某子树的根，所以N(Node）、L(Left subtree）和R(Right subtree）又可解释为根、根的左子树和根的右子树。NLR、LNR和LRN分别又称为先根遍历、中根遍历和后根遍历。

// 二叉树前序遍历
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);
}

下面主要分析前序递归遍历，中序与后序图解类似，大家可自己动手绘制

前序遍历递归图解：

前序遍历结果：1 2 3 4 5 6
中序遍历结果：3 2 1 5 4 6
后序遍历结果：3 2 5 6 4 1

这三种遍历方式代码实现类似，只是先打印还是后打印的区别。

4.1.2 层序遍历

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

层序遍历实现思想：用队列来实现二叉树的层序遍历，先把二叉树第一个节点入队列，然后每要出队列一个节点时就入队列它的左右孩子节点。如果对队列不了解的可以去看我的另一篇文章（数据结构栈和队列_栈是先进后出的吗-CSDN博客）

typedef struct BinaryTreeNode* QDataType; //队列存放的数据时二叉树的节点的地址
//队列节点
typedef struct QueueNode {
	QDataType x;
	struct QueueNode* next;
}QNode;

typedef struct Queue {
	QNode* head;
	QNode* tail;
	int size;
}Queue;

// 层序遍历 
void LevelOrder(BTNode* root)
{
	Queue head;
	QueueInit(&head);//初始化队列
	QueuePush(&head, root);//插入第一个二叉树节点
	while (!QueueEmpty(&head))//判断队列是否为空
	{
		QDataType tmp = QueueFront(&head);//获取队头
		if (tmp!=NULL)//队头不空就把他的左右节点入队列
		{
			printf("%c ", tmp->_data);
			QueuePush(&head, head.head->x->_left);
			QueuePush(&head, head.head->x->_right);
		}
		QueuePop(&head);//出队列
	}
	QueueDestroy(&head);//队列的销毁
}

这里调用了队列的接口，知道层序的实现思想就行，用c++写会更简单。

4.2二叉树的创建

#pragma once
#include<stdio.h>
#include<stdbool.h>
#include<stdlib.h>
#include<assert.h>
#include "Queue.h"
typedef char BTDataType;
typedef struct BinaryTreeNode
{
	BTDataType _data;
	struct BinaryTreeNode* _left;
	struct BinaryTreeNode* _right;
}BTNode;
// 通过前序遍历的数组"ABD##E#H##CF##G##"构建二叉树
BTNode* BinaryTreeCreate(BTDataType* a, int* pi);
// 二叉树销毁
void BinaryTreeDestory(BTNode* root);
// 判断二叉树是否是完全二叉树
int BinaryTreeComplete(BTNode* root);
// 二叉树节点个数
int BinaryTreeSize(BTNode* root);
// 二叉树叶子节点个数
int BinaryTreeLeafSize(BTNode* root);
// 二叉树第k层节点个数
int BinaryTreeLevelKSize(BTNode* root, int k);
// 二叉树查找值为x的节点
BTNode* BinaryTreeFind(BTNode* root, BTDataType x);
// 层序遍历
void LevelOrder(BTNode* root);

// 通过前序遍历的数组"ABD##E#H##CF##G##"构建二叉树
BTNode* BinaryTreeCreate(BTDataType* a, int* pi);

//通过前序数组创建二叉树
BTNode* BinaryTreeCreate(BTDataType* a, int* pi)
{
	if (a[*pi] == '#')
	{
		(*pi)++;
		return NULL;
	}
	BTNode* tmp = (BTNode*)malloc(sizeof(BTNode));
	assert(tmp);
	tmp->_data = a[(*pi)++];
	//前序打印数组
	// printf("%c ",tmp->val);
	tmp->_left = BinaryTreeCreate(a, pi);
	tmp->_right = BinaryTreeCreate(a, pi);
	return tmp;
}

// 二叉树销毁
void BinaryTreeDestory(BTNode* root);

// 二叉树销毁
void BinaryTreeDestory(BTNode* root)
{
	if (root == NULL)
		return;
	BinaryTreeDestory(root->_left);
	BinaryTreeDestory(root->_right);
	free(root);
}

// 判断二叉树是否是完全二叉树
int BinaryTreeComplete(BTNode* root);

// 判断二叉树是否是完全二叉树
int BinaryTreeComplete(BTNode* root)
{
	Queue head;
	QueueInit(&head);
	QueuePush(&head, root);
	while (!QueueEmpty(&head))
	{
		QDataType tmp = QueueFront(&head);
		if (tmp != NULL)
		{
			printf("%c ", tmp->_data);
			QueuePush(&head, head.head->x->_left);
			QueuePush(&head, head.head->x->_right);
		}
		else
		{
			while (!QueueEmpty(&head))
			{
				QDataType tmp = QueueFront(&head);
				if (tmp != NULL)
				{
					printf("%c ", tmp->_data);
					QueueDestroy(&head);
					return 0;
				}
				QueuePop(&head);
			}
		}
		QueuePop(&head);

	}
	QueueDestroy(&head);
	return 1;
}

这个函数的思想跟层序遍历是一样的。

// 二叉树节点个数
int BinaryTreeSize(BTNode* root);

// 二叉树节点个数
int BinaryTreeSize(BTNode* root)
{
	return root==NULL?0: BinaryTreeSize(root->_left) + BinaryTreeSize(root->_right) + 1;
}

// 二叉树叶子节点个数
int BinaryTreeLeafSize(BTNode* root);

// 二叉树叶子节点个数
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层节点个数
int BinaryTreeLevelKSize(BTNode* root, int k);

// 二叉树第k层节点个数
int BinaryTreeLevelKSize(BTNode* root, int k)
{
	if (root == NULL)
		return 0;
	if (k == 1)
		return 1;
	int leftk = BinaryTreeLevelKSize(root->_left, k - 1);
	int rightk = BinaryTreeLevelKSize(root->_right, k - 1);
	return leftk + rightk;
}

// 二叉树查找值为x的节点
BTNode* BinaryTreeFind(BTNode* root, BTDataType x);

// 二叉树查找值为x的节点
BTNode* BinaryTreeFind(BTNode* root, BTDataType x)
{
	if (root == NULL)
		return NULL;
	if (root->_data == x)
		return root;
	BTNode* left = BinaryTreeFind(root->_left, x);
	if (left != NULL)
		return root;
	return BinaryTreeFind(root->_right, x);
}