数据结构——详细讲解二叉树知识点

1.树概念及结构

1.1 树的相关概念

节点的度：一个节点含有的子树的个数称为该节点的度； 如上图：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）棵互不相交的树的集合称为森林；

这些概念我们还是有必要了解一下的。有的题会用概念来考你。
比如：
一颗完全二叉树有1001个结点，其叶子结点的个数是（ ）
如果你不知道什么是叶节点你就不会做

1.2 树的表示

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

typedef int DataType;
struct Node
{
	struct Node* _firstChild1; // 第一个孩子结点
	struct Node* _pNextBrother; // 指向其下一个兄弟结点
	DataType _data; // 结点中的数据域
};

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

2.二叉树概念及结构

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

1. 或者为空
2. 由一个根节点加上两棵别称为左子树和右子树的二叉树组成

从上图可以看出：

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

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

2.2现实中的二叉树：

2.1 特殊的二叉树（重点）：

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= log2（n+1）. (ps： 是log以2为底，n+1为对数)
5. 对于具有n个结点的完全二叉树，如果按照从上至下从左至右的数组顺序对所有节点从0开始编号，则对于序号为i的结点有：
   • 若i>0，i位置节点的双亲序号：(i-1)/2 i=0，i为根节点编号，无双亲节点
   • 若2i+1<n，左孩子序号：2i+1，2i+1>=n否则无左孩子
   • 若2i+2<n，右孩子序号：2i+2，2i+2>=n否则无右孩子

画图解释：
1.性质一

2.性质二

3.性质三

4.性质四
这个性质大家画一个满二叉树套公式计算就行，这个好理解
5.性质五
我把图画出来，只要代数就可以证明性质五了

1. 某二叉树共有 399 个结点，其中有 199 个度为 2 的结点，则该二叉树中的叶子结点数为（ ）
   A 不存在这样的二叉树
   B 200
   C 198
   D 199
2. 在具有 2n 个结点的完全二叉树中，叶子结点个数为（ ）
   A n
   B n+1
   C n-1
   D n/2
3. 一棵完全二叉树的节点数位为531个，那么这棵树的高度为（ ）
   A 11
   B 10
   C 8
   D 12
4. 一个具有767个节点的完全二叉树，其叶子节点个数为（）
   A 383
   B 384
   C 385
   D 386

第一题：
根据上面的性质可知 ，度为 0 的节点 == 度为 2 的节点 +1
第二题：

第三题：
高度为h的完全二叉树的节点范围在【logN^(h-1) , logN^h - 1】（log默认以二为底）
所以 h=10
第四题：

答案为 A，A，B，B

3.二叉树实现堆

堆的性质：

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

3.1堆的实现

typedef int HPDataType;

typedef struct Heap
{
	HPDataType* a;
	int size;
	int capacity;
}HP;

//初始化
void HeapInit(HP* php);

//销毁
void Heapdestroy(HP* php);

//插入
void HeapPush(HP* php, HPDataType x);

//删除
void HeapPop(HP* php);

//判空
bool HeapEmpty(HP* php);

//返回堆顶元素
HPDataType HeapTop(HP* php);

//返回堆中元素个数
int HeapSize(HP* php);

初始化，销毁，插入，删除堆顶元素，判空，返回堆顶元素，返回堆中元素个数
这几个功能比较简单，大家如果自己完成过顺序表，链表一定可以看的懂
这里我挑两个难点来讲：向上调整，向下调整

//初始化
void HeapInit(HP* php)
{
	assert(php);
	php->a = (HPDataType*)malloc(sizeof(HPDataType) * 4);
	if (php->a == NULL)
	{
		perror("malloc fail");
		return;
	}
	php->size = 0;
	php->capacity = 4;

}

//销毁
void Heapdestroy(HP* php)
{
	assert(php);
	free(php->a);
	php->a = NULL;
	php->size = php->capacity = 0;
}

//交换
void Swap(HPDataType* e1, HPDataType* e2)
{
	HPDataType tmp = *e1;
	*e1 = *e2;
	*e2 = tmp;
}

//插入并向上调整
void HeapPush(HP* php, HPDataType x)
{
	assert(php);
	if (php->capacity == php->size)
	{
		HPDataType* tmp = realloc(php->a, sizeof(HPDataType) * php->capacity * 2);
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}
		php->a = tmp;
		php->capacity *= 2;
	}
	php->a[php->size++] = x;
	AdjustUp(php->a, php->size-1);
}

//删除,堆顶元素
void HeapPop(HP* 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(HP* php)
{
	assert(php);
	return php->size == 0;
}

//返回堆顶元素
HPDataType HeapTop(HP* php)
{
	assert(php);
	return php->a[0];
}

//返回堆中元素个数
int HeapSize(HP* php)
{
	assert(php);
	return php->size;
}

上图我们可以了解到，大堆与小堆的特点

⭐3.2向上调整排序（重点）

我们这里只讲这两个功能：
首先如果我们要插入元素，只能在堆底插入，插入元素之后就要去调整堆
假设我们现在有一个大堆是这样的：

插入一个数据然后调整

所以我们在插入数之后要写一个向上调整（AdjustUp）
我们想要向上调整，就得知道要调整的位置（sz-1）长度减一就是最后一个元素的下标，还有堆首的地址
所以我们函数的参数设计为AdjustUp（HPDataType* a, int child），把孩子节点向上调整

知道了孩子节点还得知道它的父节点，那我们该怎么找父节点呢？

我们看图可以知道10的父节点是3
3和8的父节点是9
我们发现规律：父节点的下标 =（孩子节点的下标 - 1）/ 2
知道了下标我们就要去比较 （如果是大堆孩子比父亲大就向上调整，如果是小堆孩子比父亲小就向上调）
当孩子节点的下标 == 0的时候说明已经排完序了（孩子节点一直在向上作比较）
所以我们的向上调整排序代码如下：

//向上调整
void AdjustUp(HPDataType* a, int child)
{
	int parent = (child - 1) / 2;
	//while(parent >= 0)    严格来说是不能这样写的
	// 当 patent等于0时  parent = (child - 1) / 2;  这条语句执行完parent还是等于0
	// 但是程序也不会死循环  因为进入下一次循环的时侯 执行判断语句的条件 
	// a[child] > a[parent] 结果为 0，执行else中的break，会碰巧跳出循环
	while (child > 0)
	{
		if (a[child] > a[parent])
		{
			Swap(&a[child], &a[parent]);
			//这里的交换函数是自己写的
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

⭐3.3向下调整排序（重点）

向下调整排序就是我们在执行删除堆顶元素命令后，需要向下调整排序，为什么呢？，如下：

可以看到上面代码，我们说的是删除堆顶元素，实际上就是让堆顶元素与堆底元素交换，这样堆顶元素就到堆底了，把堆底元素删除就可以了，这样不会影响原来的堆，只需要再想向下调整堆顶元素就可以恢复堆了
如果我们直接删除堆顶元素，不仅要把后面数据全部都向前挪动，而且堆的顺序也乱了
就比如下面这个小堆

所以我们不能直接删除堆顶元素，要先把它与堆底元素交换，然后删除堆底元素
我们向下调整需要知道一共有几个元素（不能让孩子节点的下标超过或等于元素个数），还有要向下调整的位置，还有堆的首地址
所以向下调整的函数为AdjustDown(HPDataType* a,int n,int parent)

我们在选孩子节点的时候，先默认是左孩子节点，然后：
如果是建大堆选出左右孩子中大的那一个
如果是建小堆选出左右孩子中小的那一个
代码如下：

//在建好堆的情况下向下调整
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;
		}
	}
}

4.堆的应用

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

4.1 建堆

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

如果给你一共数组要求你建堆。
那建堆是要用向上调整的方式建堆还是要用向下调整的方式建堆呢？

答案是使用向下调整建堆
首先我们要知道什么情况下才能向下调整建堆，
向下调整建堆的要求是在建好堆的情况下向下调整
列如下图：
如果我们想要用向下调整排序的方式来建堆，就需要倒着建堆

怎么个倒着建堆呢？
先找到最后一个元素的父亲节点节点，最后一个元素的下标为n-1（及元素个数减1），最后一个元素的父节点下标为 (（n-1）-1）/2（及最后一个元素的下标减1再除2）。再向前找前面的父节点（及最后一个父节点依次减1），一直到 i<0时停止。
所以建小堆只需要如下代码：

//n代表元素个数 
//第一个 -1 代表尾元素 
//第二个 -1 代表 左孩子节点 或者左孩子节点 -1
// /2 代表找到它的父节点
for (int i = (n-1-1)/2; i >= 0; --i)
{
	AdjustDown(a, n, i);
}

那为什么向下调整比向上调整要快呢看下图分析：

所以向下调整排序的时间复杂度为O（N）
那么向上调整排序的时间复杂度为多少呢？

那向上调整排序的时间复杂度为O（N*logN）

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

TOP-K问题

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

1. 用数据集合中前K个元素来建堆
   • 如果要找前k个最大的元素，则建小堆
   • 如果要找前k个最小的元素，则建大堆
2. 用剩余的N-K个元素依次与堆顶元素来比较，不满足则替换堆顶元素
   • 将剩余N-K个元素依次与堆顶元素比完之后，堆中剩余的K个元素就是所求的前K个最小或者最大的元素。

可能大家会疑惑为什么找最大的 k 个元素要建小堆，找最小的 k 个元素要建大堆，
这里我只解释找最大的 k 个元素建小堆的原因：
首先对前 k 给元素建小堆，小堆的堆顶一定这个堆中最小的元素。
用剩下的数来跟堆顶元素作比较，如果比堆顶大就进入堆，进入堆之后再向下调整，调整之后堆顶元素一定还是这个堆中最小的数
就这样用堆顶元素一直与剩下的数比较，所有的数的比较完之后，这个堆中的数就是，所有数 N 中最大的前 k 个数

代码如下：

#include <stdio.h>
#include <time.h>
#include <stdlib.h>
void PrintTopK(int* a,int k)
{
	for (int i = 0; i < k; i++)
	{
		printf("%d ", a[i]);
	}
	printf("\n");
}


//srand是创建随机数的
void TestTopk()
{
	int n = 10000;
	int* a = (int*)malloc(sizeof(int) * n);
	if (a == NULL)
	{
		printf("malloc fail");
		return;
	}
	srand(time(0));
	for (int i = 0; i < n; ++i)
	{
		a[i] = rand() % 10000;
	}
	

	//用top这快区域来接收最大的 k 个元素
	int k = 10;
	int* top = (int*)malloc(sizeof(int) * k);
	if (top == NULL)
	{
		printf("malloc fail");
		return;
	}
	for (int i = 0; i < k; i++)
	{
		top[i] = a[i];
	}

	//这里我们用前十个数建堆
	for (int i = (k - 2) / 2; i < k; i++)
	{
		AdjustDown(top, k, i);
	}

	//将剩余n - k个元素依次与top堆顶元素比较，如果满足条件就交换
	// 这里我们建小堆，但小堆里要存所有数中最大的元素
	// 所以我们就要让大于堆顶的数代替堆顶，然后向下调整
	for (int i = k; i < n; i++)
	{
		if (a[i] > top[0])
		{
			top[0] = a[i];
			AdjustDown(top, k, 0);
		}
	}
	PrintTopK(top,k);
	
}

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

输出结果：

画图判断这里的10个数是不是小堆
通过下图我们可以确定这里的就是一个小堆

那我们怎么能确定这 10 个数到底是不是这 10000 个数里最大的数呢？
这里的方法很简单，因为我们之前在给每个元素赋值的时候都是
a【i】 = rand（）% 10000，所以每个元素都小于 10000.
我们只要给这 10000 个数中，随机十个数赋大于 10000 的值就可以通过输出结果判断我们之前的代码是否正确。
代码如下：
只是在之前的

void TestTopk()
{
	int n = 10000;
	int* a = (int*)malloc(sizeof(int) * n);
	if (a == NULL)
	{
		printf("malloc fail");
		return;
	}
	srand(time(0));
	for (int i = 0; i < n; ++i)
	{
		a[i] = rand() % 10000;
	}
	
	a[5] = 10000 + 1;
	a[1231] = 10000 + 2;
	a[531] = 10000 + 3;
	a[5121] = 10000 + 4;
	a[115] = 10000 + 5;
	a[2335] = 10000 + 6;
	a[9999] = 10000 + 7;
	a[76] = 10000 + 8;
	a[423] = 10000 + 9;
	a[3144] = 10000 + 10;
	

	//用top这快区域来接收最大的 k 个元素
	int k = 10;
	int* top = (int*)malloc(sizeof(int) * k);
	if (top == NULL)
	{
		printf("malloc fail");
		return;
	}
	for (int i = 0; i < k; i++)
	{
		top[i] = a[i];
	}
	

	//这里我们用前十个数建堆
	for (int i = (k - 2) / 2; i < k; i++)
	{
		AdjustDown(top, k, i);
	}


	//将剩余n - k个元素依次与top堆顶元素比较，如果满足条件就交换
	// 这里我们建小堆，但小堆里要存所有数中最大的元素
	// 所以我们就要让大于堆顶的数代替堆顶，然后向下调整
	for (int i = k; i < n; i++)
	{
		if (a[i] > top[0])
		{
			top[0] = a[i];
			AdjustDown(top, k, 0);
		}
	}
	PrintTopK(top,k);
	
}

结果证明，我们上面的代码是正确的。输出的都是大于10000的数

那有的同学说这里的堆没有顺序，我们需要写一个堆排序即可
代码如下

void HeapSort(int* a, int n)
{
	//n代表元素个数 
	//第一个 -1 代表尾元素 
	//第二个 -1 代表 左孩子节点 或者左孩子节点 -1
	// /2 代表找到它的父节点

	for (int i = (n - 1 - 1) / 2; i >= 0; --i)
	{
		AdjustDown(a, n, i);
	}
	//n是元素个数，n-1就是尾元素下标
	int end = n - 1;
	//尾元素下标大于0，就进入循环
	//如果尾元素等于 0 那就是剩下最后一个没有排序的元素了，所以
	// end > 0时进入循环就可以了
	while (end > 0)
	{
		Swap(&a[0], &a[end]);
		AdjustDown(a, end, 0);
		end--;
	}
}

输出结果：

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

4.1二叉树的遍历

前序遍历，中序遍历，后序遍历

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

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

学习二叉树我们就要学会把一个大的问题，分解成小问题来解决，用递归来解决问题

例如前序遍历
我们是要先访问当前节点的元素，再访问左节点，再访问右节点
我们把遍历整个树，看做成遍历一颗一颗的小的树
当 root（根节点）== NULL 时返回
我们就上图这颗树，写一下它的前序遍历：

它的前序顺序应该是上图这样，实际输出的数据是，1 > 2 > 4 > 5 > 3 > 6 > 7
那我们来用代码实现一下吧，在实现前序之前我们要先有一颗树
我们直接简单的创建一颗二叉树

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

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

BTNode* BuyNode(BTDataType x)
{
	BTNode* newnode = (BTNode*)malloc(sizeof(BTNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return NULL;
	}
	newnode->data = x;
	newnode->left = NULL;
	newnode->right = NULL;

	return newnode;
}


int main()
{
	BTNode* Node1 = BuyNode(1);
	BTNode* Node2 = BuyNode(2);
	BTNode* Node3 = BuyNode(3);
	BTNode* Node4 = BuyNode(4);
	BTNode* Node5 = BuyNode(5);
	BTNode* Node6 = BuyNode(6);
	BTNode* Node7 = BuyNode(7);

	Node1->left = Node2;
	Node1->right = Node3;
	Node2->left = Node4;
	Node2->right = Node5;
	Node3->left = Node6;
	Node3->right = Node7;

	return 0;
}

注意：上述代码并不是创建二叉树的方式
二叉树写好了之后我们把前序遍历来实现一下

前序遍历代码如下：

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

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

我们把Node1传给前序遍历，发现输出结果与上面画图解释的数据顺序一样。

中序，后序的遍历只是与前序遍历的访问数据的时间不同，如有不理解看下面的代码就知道为什么这样说了

中序遍历：

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

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

后序遍历：

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

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

4.1 层序遍历

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

二叉树的层序遍历我们需要借助之前学过的知识点，队列来帮助我们实现。
栈和队列特性的讲解

层序遍历代码如下：

// 层序遍历
void LevelOrder(BTNode* root)
{
	Queue q1;
	QueueInit(&q1);

	if(root != NULL)
		QueuePush(&q1, root);
	
	while (!QueueEmpty(&q1))
	{
		BTNode* front = QueueFront(&q1);
		QueuePop(&q1);
		printf("%d ", front->data);
		if (front->left)
		{
			QueuePush(&q1, front->left);
		}
		if (front->right)
		{
			QueuePush(&q1, front->right);
		}
	}
}

注意我们这里要把队列的数据类型改为 struct BinaryTreeNode*

4.2 节点个数以及高度等

// 二叉树节点个数
int BinaryTreeSize(BTNode* root);
// 二叉树叶子节点个数
int BinaryTreeLeafSize(BTNode* root);
// 二叉树第k层节点个数
int BinaryTreeLevelKSize(BTNode* root, int k);
// 二叉树查找值为x的节点
BTNode* BinaryTreeFind(BTNode* root, BTDataType x);
// 二叉树销毁
void BinaryTreeDestory(BTNode** root);
// 判断二叉树是否是完全二叉树
int BinaryTreeComplete(BTNode* root);

二叉树节点个数

计算节点个数还是上面讲到的思想，把大问题化为一个小问题
如果节点为空返回 0
如果不为空返回 左节点个数 + 右节点个数 + 1（自己）

// 二叉树节点个数
int BinaryTreeSize(BTNode* root)
{
	if (root == NULL)
		return 0;
	
	return BinaryTreeSize(root->left) + BinaryTreeSize(root->right) + 1;
}

二叉树叶子节点个数

求叶子节点个数，思想还是递归思想
如果 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层节点个数

第 k 层节点个数，当 k == 1 时，就是第 k 层

计算当 k == 1 时的节点个数就行
代码如下；

// 二叉树第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);

}

二叉树查找值为x的节点

只需要遍历二叉树，当 root->data == x 时就返回它的节点
代码如下：

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

	if (root->data == x)
		return root;
	
	//如果左不为空，说明找到了，就返回节点
	BTNode* lret = BinaryTreeFind(root->left, x);
	if (lret)
		return lret;
	
	//同上
	BTNode* rret = BinaryTreeFind(root->right, x);
	if (lret)
		return lret;

	return NULL;
}

二叉树的销毁

二叉树的销毁要使用后续遍历的思想来销毁，如果用前序，中序来销毁，我们销毁了当前节点，就找不到后面的节点了
后续遍历正好时先访问左子树，在访问右子树，最后访问当前节点，我们时最后释放当前节点
代码如下：

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

}

判断二叉树是否是完全二叉树

使用队列来判断，如果访问到空时，后面的元素还有不为空的，二叉树就不是完全二叉树

// 判断二叉树是否是完全二叉树
bool BinaryTreeComplete(BTNode* root)
{
	Queue s1;
	QueueInit(&s1);

	if (root)
		QueuePush(&s1, root);

	while (!QueueEmpty(&s1))
	{
		BTNode* Front = QueueFront(&s1);
		QueuePop(&s1);
		
		if (Front == NULL)
		{
			break;
		}
		else
		{
			QueuePush(&s1, Front->left);
			QueuePush(&s1, Front->right);
		}
		
	}

	while (!QueueEmpty(&s1))
	{
		BTNode* Front = QueueFront(&s1);
		QueuePop(&s1);

		if (Front)
		{
			Queuedestroy(&s1);
			return false;
		}
	}

	Queuedestroy(&s1);
	return true;


}