数据结构篇六：二叉树

前言

  前面讲的都是属于线性的数据结构，今天我们就来看一看非线性的数据结构。

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

1.3 树的结构

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

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

2. 二叉树的概念及结构

2.1 二叉树的概念

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

1. 或者为空
2. 由一个根节点加上两棵别称为左子树和右子树的二叉树组成
   
   从上图可以看出：
3. 二叉树不存在度大于2的结点
4. 二叉树的子树有左右之分，次序不能颠倒，因此二叉树是有序树
   注意：对于任意的二叉树都是由以下几种情况复合而成的：
   

2.2 特殊的二叉树

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

2.3 二叉树的性质

1. 若规定根节点的层数为1，则一棵非空二叉树的第i层上最多有 2^(i - 1)个结点。
2. 若规定根节点的层数为1，则深度为h的二叉树的最大结点数是2^h - 1。
3. 对任何一棵二叉树, 如果度为0其叶结点个数为 , 度为2的分支结点个数为 ,则有2^h - 1。
4. 若规定根节点的层数为1，具有n个结点的满二叉树的深度，h=log(n + 1).（ps:log(n + 1)是log以2为底，（n + 1)的对数）。
5. 对于具有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否则无右孩子。

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 = { k1，k2 ，k3 ，…， k(n-1) }，把它的所有元素按完全二叉树的顺序存储方式存储
在一个一维数组中，并满足：K(i) <= K(2i+1)且 K(i)<=K(2i+2) 或者(K(i)>=K(2i+1) 且K(i) >= K(2i+2)， i = 0，1，2……，则称为小堆(或大堆)，将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。
堆的性质：

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

3.3 堆的实现

3.3.1 堆的创建

  下面我们给出一个数组，这个数组逻辑上可以看做一颗完全二叉树，但是还不是一个堆，现在我们通过算法，把它构建成一个堆。根节点左右子树不是堆，我们怎么调整呢？在后面我会介绍两种建堆方法，一种是向上建堆，一种是向下建堆。

3.3.2 堆的定义

  我们是以顺序结构也就是数组去实现的，因此只需要一个capacity（容量）以及size（个数）两个变量去记录即可。

typedef int HeapDatatype;
typedef struct Heap
{
    
    
	HeapDatatype* data;
	int capacity;
	int size;
}Heap;

3.3.3 堆的初始化

  起始先将所有变量赋初值，避免出现随机值的情况发生。

void HeapInit(Heap* hp)
{
    
    
	assert(hp);
	hp->capacity = hp->size = 0;
	hp->data = NULL;
}

3.3.4 堆的销毁

  动态开辟的空间皆需要进行手动释放并置空。

void HeapDestory(Heap* hp)
{
    
    
	assert(hp);
	free(hp->data);
	hp->data = NULL;
	hp->capacity = hp->size = 0;
}

3.3.5 堆的向上调整

  以一个小堆来进行展示，如图：

  向上调整没有什么要求，从最后一个元素倒着往前一个一个元素进行调整即可。注意：这里我只是举例展示了一次调整的过程，方便大家理解。（也就是拿出了一个数组进行了一次向上调整）实际上是：在每一次插入数据的时候都会进行一次调整，最终成为一个小根堆（大根堆），上面的图并不是一个堆，只是为大家展示一次调整过程的思路。

//向上调整
void AdjustUp(HeapDatatype* data,int child)
{
    
    
	int parent = (child - 1) / 2;
	while (child > 0)
	{
    
    
		if (data[child] < data[parent]) // "<" 小堆
		{
    
    
			Swap(&data[child], &data[parent]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
    
    
			break;
		}
	}
}

3.3.6 堆的向下调整

  向下调整与向上调整不一样，它有一个前提：左右子树必须是一个堆，才能调整。

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

  向下调整就与向上调整相反，从第一个元素开始，每插入一个元素就进行一次调整。这里也只是演示了一次调整过程，仅供参考。

//向下调整
void AdjustDown(HeapDatatype* data, int size, int parent)
{
    
    
	int child = (parent * 2) + 1;
	while (child < size)
	{
    
    
		if (child + 1 < size &&	data[child] > data[child + 1])  // "<" 大堆
		{
    
    
			child++;
		}
		
		if (data[child] < data[parent]) // ">"大堆
		{
    
    
			Swap(&data[child], &data[parent]);
			parent = child;
			child = (parent * 2) + 1;
		}
		else
		{
    
    
			break;
		}
	}
}

3.3.7 堆的插入

  插入数据的第一步就是需要判断容量是否充足，不足则需要增容，这里与前面的线性表相差不大，比较简单，唯一需要注意的就是，每插入一个数据就需要进行一次向上或者向下调整。

void HeapPush(Heap* hp, HeapDatatype x)
{
    
    
	assert(hp);

	//考虑增容
	if (hp->capacity == hp->size)
	{
    
    
		int newcapacity = hp->capacity == 0 ? 4 : hp->capacity * 2;
		HeapDatatype* tmp = (HeapDatatype*)realloc(hp->data, sizeof(HeapDatatype) * newcapacity);
		if (tmp == NULL)
		{
    
    
			return;
		}
		hp->data = tmp;
		hp->capacity = newcapacity;
	}
	hp->data[hp->size] = x;
	hp->size++;

	AdjustUp(hp->data, hp->size - 1);
}

3.3.8 堆的删除

  第一步与插入相同，这里是需要进行判断堆中是否还有数据，没有则不进行删除操作。但是直接删除又会导致一些问题，如图：

  直接删除的话会破坏堆的结构，有一个取巧的方法，那就是将最后一个结点值与第一个结点值互换，然后删除最后一个结点，这样不符合堆结构的就只有第一个结点，我们只需要进行一次向下调整将第一个结点进行调整，就可以完美解决删除问题了。

void HeapPop(Heap* hp)
{
    
    
	assert(hp);
	assert(hp->size > 0);
	Swap(&hp->data[0], &hp->data[hp->size - 1]);
	hp->size--;

	AdjustDown(hp->data, hp->size, 0);
}

3.3.9 堆的打印

  循环依次打印。

void HeapPrint(Heap* hp)
{
    
    
	int i = 0;
	for (i = 0; i < hp->size; i++)
	{
    
    
		printf("%d ", hp->data[i]);
	}
	printf("\n");
}

3.3.10 取堆顶数据

  堆顶也就是数组里的第一个元素，也就是hp->data[0]。

HeapDatatype HeapTop(Heap* hp)
{
    
    
	assert(hp);
	assert(hp->size > 0);

	return hp->data[0];
}

3.3.11 堆的数据个数

  size变量记录的就是元素个数。

int HeapSize(Heap* hp)
{
    
    
	assert(hp);

	return hp->size;
}

3.3.12 堆的判空

  如果size等于0，说明堆为空。

bool HeapEmpty(Heap* hp)
{
    
    
	assert(hp);

	return hp->size == 0;
}

3.4 堆排序

  堆——也可以用来进行排序，俗称堆排序。堆每次都可以选出最大的数（大根堆）或者最小的数（小根堆），因此可以采用这个性质进行排序。
  如果我们要排升序，值是从小到大，我们一开始肯定会想到小根堆，因为它的堆顶元素是堆中的最小值，但是我们想想，在选出最小值之后如何继续用小根堆选出第二小的数呢？可能大家会想：可以先将第一个元素（最小的）与最后一个元素交换再删除，然后再进行调整就能选出第二小的了。但是我们写的是排序，难道要每一次都要先写一遍堆的各个结构，再借助堆的结构来实现堆排序吗？很麻烦的。
  因此我们可以来考虑大根堆，大根堆是选出最大的数，我们可以将最大的数与最后一个元素进行交换，然后再对前（n-1）个元素进行调整进行调整（一共n个元素）。大家可以想一想这样之后的结果，最大值跑到数组的最后一个位置，并且对前（n-1）个元素进行调整，是不是又选出了第二大的元素，然后再与（n-1）位置上的元素进行交换，再对前（n-2）个元素进行调整，如此循环反复。

  大概过程就是如果是排升序，从数组最后开始排，也就是先找到最大的数放到最后，再选出次大的数放到倒数第二个位置，如此循环完成排序。

//堆排序
//升序 -- 大堆
//降序 -- 小堆
void HeapSort(int* a, int n)
{
    
    
	1.建堆 O(N*logn)
	int i = 0;
	//for (i = 1; i < n; i++)
	//{
    
    
	//	AdjustUp(a, i);
	//}

	//2.建堆 O(N)
	for (i = (n - 1 - 1) / 2; i >= 0; i--)
	{
    
    
		AdjustDown(a, n, i);
	}
	
	int end = n - 1;
	while (end >= 0)
	{
    
    
		Swap(&a[0], &a[end]);
		AdjustDown(a, end, 0);
		end--;
	}
}

3.5 Top—K问题

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

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

//选取最大的前K个数，建小堆
void PrintTopK(int* a, int n, int k)
{
    
    
	// 1. 建堆--用a中前k个元素建堆
	int* KMinHeap = (int*)malloc(sizeof(int) * k);
	if (KMinHeap == NULL)
	{
    
    
		return;
	}

	int i = 0;
	for (i = 0; i < k; i++)
	{
    
    
		KMinHeap[i] = a[i];
	}
	for (i = (n - 1 - 1) / 2; i >= 0; i--)
	{
    
    
		AdjustDown(KMinHeap, k, i);
	}

	// 2. 将剩余n-k个元素依次与堆顶元素交换，不满则则替换
	int j = 0;
	for (j = k; j < n; j++)
	{
    
    
		if (KMinHeap[0] < a[j])
		{
    
    
			KMinHeap[0] = a[j];
			AdjustDown(KMinHeap, k, 0);
		}
	}

	for (i = 0; i < k; i++)
	{
    
    
		printf("%d ", KMinHeap[i]);
	}

	free(KMinHeap);
	KMinHeap = NULL;
}

  我们以排出N个数个中最大的前k个数为例，建小堆，思路与前面的堆排序相差无几，将后面（n-k）个数与堆顶元素进行比较，如果比堆顶元素大，就进行交换并对前k个数进行调整。
  这样的效果就是：前k个数的最小值跑到了后面，并且补上了一个较大数，如此一直循环，不断的将前k个元素中的最小值移出去，再补上一个较大值，最终就只剩下N个元素中最大的前k个元素了。
  可以拿下面的代码进行测试。

void TestTopk()
{
    
    
	int n = 10000;
	int* a = (int*)malloc(sizeof(int) * n);
	srand((unsigned int)time(NULL));
	for (int i = 0; i < n; ++i)
	{
    
    
		a[i] = rand() % 1000000;
	}
	a[5] = 1000000 + 1;
	a[1231] = 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[3144] = 1000000 + 10;
	PrintTopK(a, n, 10);

	free(a);
	a = NULL;
}

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

  在学习二叉树的基本操作前，需先要创建一棵二叉树，然后才能学习其相关的基本操作。由于现在大家对二叉树结构掌握还不够深入，为了降低大家学习成本，此处手动快速创建一棵简单的二叉树，快速进入二叉树操作学习，等二叉树结构了解的差不多时，我们反过头再来研究二叉树真正的创建方式。

BTNode* CreatBinaryTree()
{
    
    
	BTNode* node1 = BuyNode(1);
	BTNode* node2 = BuyNode(2);
	BTNode* node3 = BuyNode(3);
	BTNode* node4 = BuyNode(4);
	BTNode* node5 = BuyNode(5);
	BTNode* node6 = BuyNode(6);

	node1->left = node2;
	node1->right = node4;
	node2->left = node3;
	node4->left = node5;
	node4->right = node6;
	return node1;
}

  先手搓一个进行操作哈。

4.1 二叉树的定义

  二叉树我们定义两个指针域，一个用来放左孩子的地址，一个放右孩子的地址。

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

4.2 开辟新结点

  每插入一个数据都要先为它开辟一个空间来进行存放。

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

	return newnode;
}

4.3 前序遍历

  以根->左->右的顺序来依次访问整个二叉树的所有结点。注意：在二叉树这里全部都采用了递归的方式进行解决问题，不熟练的小伙伴要多多画一画递归展开图哦，我在后面也会画一些方便大家理解。

void PreOrder(BTNode* root)
{
    
    
	if (root == NULL)
	{
    
    
		printf("# ");
		return;
	}

	//用于整形数据的测试
	printf("%d ", root->data);

	用于字符型数据的测试
	//printf("%c ", root->data);
	PreOrder(root->left);
	PreOrder(root->right);
}

  递归展开图：

  我只画了这棵树的左子树部分，大家可以试着画出右子树来进行练习理解。

4.4 中序遍历

  以左->根->右的顺序来依次访问整个二叉树的所有结点。

void InOrder(BTNode* root)
{
    
    
	if (root == NULL)
	{
    
    
		printf("# ");
		return;
	}

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

  递归展开图：

  这里我同样也只是画出了左子树部分，蓝色箭头的方向就是调用的顺序。

4.5 后序遍历

  以左->右->根的顺序来依次访问整个二叉树的所有结点。

void PostOrder(BTNode* root)
{
    
    
	if (root == NULL)
	{
    
    
		printf("# ");
		return;
	}

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

  后续遍历的递归展开图与上面没有差异，区别就在于打印的时机不太一样，但是画法与上面别无二致。

4.6 二叉树节点个数

  通过递归计算，如果根节点为空，返回0，不为空就继续对左右子树进行递归。

int BinaryTreeSize(BTNode* root)
{
    
    
	return root == 0 ? 0 : BinaryTreeSize(root->left) + BinaryTreeSize(root->right) + 1;
}

  递归展开图：
  同样只画出了左子树的递归展开图，思路已经有了，勤加练习即可。

4.7 二叉树叶子节点个数

  一样是递归计算，根节点为空返回0，左右子树都为空返回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);
}

  递归展开图：

  这部分不动手练习不太容易能理解，当然对于佬不是问题哈，如果是初学者建议在纸上多画一画。

4.8 二叉树第k层节点个数

  我们倒着来，将第一层视为第k层，那么当k = 1，时，就是我们要计算的节点个数了。如果在k层之内提前遇到空节点，那么就返回0，否则一直递归，直到k = 1。

int BinaryTreeLevelKSize(BTNode* root, int k)
{
    
    
	assert(k >= 1);
	if (root == NULL)
		return 0;

	if (k == 1)
		return 1;

	return BinaryTreeLevelKSize(root->left, k - 1) + BinaryTreeLevelKSize(root->right, k - 1);
}

  递归展开图：

4.9 二叉树查找值为x的节点

  通过遍历依次比较就可以了，这里用的是前序遍历，依次遍历。这里的递归结束条件是要么找到了，返回找到的节点地址，要么是一直到叶子节点结束也没有找到，返回NULL，因此为了更好的理解，可以把每一次的递归返回值保存起来进行判断，如果不为空的话直接返回，也就是找到所需要查找的节点了。
  递归展开图与上面一致，大概路程就是一直调用左子树的左孩子（最左边的一列孩子），一直到叶子节点结束，进行return，然后再从下往上对左子树的右孩子一一进行查找。如果还没有找到，就再对右子树的左孩子（最左边的一列孩子）一一进行查找，再从下往上依次返回，同时再调用右子树的右孩子。
  这一段是已经经过前面一系列的画图练习，可以通过文字解释来想象出它的递归展开图，又能力的小伙伴可以试一试，可以想象一下，更进一步理解递归。

BTNode* BinaryTreeFind(BTNode* root, BTDataType x)
{
    
    
	if (root == NULL)
		return NULL;

	if (root->data == x)
		return root;

	BTNode* ret1 = BinaryTreeFind(root->left, x);
	if (ret1)
		return ret1;

	BTNode* ret2 = BinaryTreeFind(root->right, x);
	if (ret2)
		return ret2;

	return NULL;
}

4.10 通过前序遍历的数组"ABD##E#H##CF##G##"构建二叉树

  ‘#‘代表着的是空的意思，如果是’#’，说明此处为空，然后通过递归，不断将它们进行连接。这里的pi，是作为数组的下标的，每用完一个字符都需要对pi＋＋，来找到下一个字符。为什么要用指针呢？看图：

  我们先假设这里的pi不是传地址，就是一个定义的局部变量，上图所说的pi是几呢？答案是1。对于递归而言，每一次调用都是一次单独的程序，而局部变量它的作用域只在本次调用内部有效，出了函数就不存在了。所以左孩子pi的改变对于右孩子的pi没有任何影响，会使得左右孩子调用的是同一个字符，所以需要传指针来使pi可以正确的＋＋。

//需要单独拿出来测试，因为此时的BTDataType的类型需要是char
BTNode* BinaryTreeCreate(BTDataType* str, int* pi)
{
    
    
	if (str[*pi] == '#')
	{
    
    
		(*pi)++;
		return NULL;
	}
	
	BTNode* root = BuyNode(str[(*pi)++]);
	root->left = BinaryTreeCreate(str, pi);
	root->right = BinaryTreeCreate(str, pi);
	return root;
}

4.11 二叉树的销毁

  通过后序遍历依次释放，防止出现根节点已经释放而孩子节点还未释放的情况。

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

	BinaryTreeDestory(root->left);
	BinaryTreeDestory(root->right);
	free(root);
}

4.12 层序遍历

  借助队列的结构来实现，忘记的小伙伴可以点开链接再看一看。在前面都是通过递归来遍历的，左子树访问完了才会访问右子树，那么该如何实现层序遍历呢？
  队列是先进先出，我们可以进根节点，如何打印它，再出队列，如果此时的根节点的左子树不为空，那就将左子树进队列，如果右子树也不为空，将右子树也进队列。然后再循环上面的步骤，打印，出队列，进左右子树，就很好的实现了一层一层打印了，当队列为空的时候说明遍历就结束了。

void LevelOrder(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);
		}
	}
	printf("\n");
	QueueDestroy(&q);
}

  上面5和6再依次出队列就完成了层序遍历。一个节点出队列的同时，它的两个孩子进队列，如此反复，当队列为空的时候，说明已经遍历完毕。

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

  完全二叉树是有特点的，那就是最后一个节点的前面不能有空，因此我们可以考虑层序遍历，如果根节点不为空，那么就将它的左右孩子进队列，再将自身出队列，依次循环，直到遇到第一个空节点跳出循环。如果是完全二叉树的话，那么循环结束时队列应该为空，相反，如果队列不为空就说明不是完全二叉树。

bool BinaryTreeComplete(BTNode* root)
{
    
    
	Queue q;
	QueueInit(&q);

	if (root)
	{
    
    
		QueuePush(&q, root);
	}

	while (!QueueEmpty(&q))
	{
    
    
		BTNode* front = QueueFront(&q);
		QueuePop(&q);
		if (front)
		{
    
    
			QueuePush(&q, front->left);
			QueuePush(&q, front->right);
		}
		else
		{
    
    
			break;
		}
	}
	while (!QueueEmpty(&q))
	{
    
    
		BTNode* Front = QueueFront(&q);
		QueuePop(&q);
		if (Front)
			return false;
	}
	QueueDestroy(&q);
	return true;
}

  退出循环之后再对队列进行判空，如果队列为空，则说明是完全二叉树，如果不为空，即为上面这种情况，就不是完全二叉树，大家可以将上面的左右子树交换再画一遍图，看是否退出循环后队列为空。

5. 代码实现

  一共有五个文件，分别为Tree.h、Tree.c、test.c以及Queue.h、Queue.c。分为记录的是树的定义与各个函数的声明，函数的具体实现，功能测试；后面的是需要用队列辅助完成层序遍历以及判断是否为完全二叉树所需。

5.1 Tree.h

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

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

//创建结点
BTNode* BuyNode(BTDataType x);

// 二叉树前序遍历
void PreOrder(BTNode* root);

// 二叉树中序遍历
void InOrder(BTNode* root);

// 二叉树后序遍历
void PostOrder(BTNode* root);

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

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

// 二叉树第k层节点个数
int BinaryTreeLevelKSize(BTNode* root, int k);

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

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

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

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

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

5.2 Tree.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"Tree.h"
#include"Queue.h"

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

	return newnode;
}

void PreOrder(BTNode* root)
{
    
    
	if (root == NULL)
	{
    
    
		printf("# ");
		return;
	}

	//用于整形数据的测试
	printf("%d ", root->data);

	用于字符型数据的测试
	//printf("%c ", root->data);
	PreOrder(root->left);
	PreOrder(root->right);
}

void InOrder(BTNode* root)
{
    
    
	if (root == NULL)
	{
    
    
		printf("# ");
		return;
	}

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

void PostOrder(BTNode* root)
{
    
    
	if (root == NULL)
	{
    
    
		printf("# ");
		return;
	}

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

//int count = 0;
//int BinaryTreeSize(BTNode* root)
//{
    
    
//	if (root == NULL)
//	{
    
    
//		return;
//	}
//	count++;
//	BinaryTreeSize(root->left);
//	BinaryTreeSize(root->right);
//}

int BinaryTreeSize(BTNode* root)
{
    
    
	return root == 0 ? 0 : BinaryTreeSize(root->left) + BinaryTreeSize(root->right) + 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);
}

int BinaryTreeLevelKSize(BTNode* root, int k)
{
    
    
	assert(k >= 1);
	if (root == NULL)
		return 0;

	if (k == 1)
		return 1;

	return BinaryTreeLevelKSize(root->left, k - 1) + BinaryTreeLevelKSize(root->right, k - 1);
}

BTNode* BinaryTreeFind(BTNode* root, BTDataType x)
{
    
    
	if (root == NULL)
		return NULL;

	if (root->data == x)
		return root;

	BTNode* ret1 = BinaryTreeFind(root->left, x);
	if (ret1)
		return ret1;

	BTNode* ret2 = BinaryTreeFind(root->right, x);
	if (ret2)
		return ret2;

	return NULL;
}

//需要单独拿出来测试，因为此时的BTDataType的类型需要是char

BTNode* BinaryTreeCreate(BTDataType* str, int* pi)
{
    
    
	if (str[*pi] == '#')
	{
    
    
		(*pi)++;
		return NULL;
	}
	BTNode* root = BuyNode(str[(*pi)++]);
	root->left = BinaryTreeCreate(str, pi);
	root->right = BinaryTreeCreate(str, pi);
	return root;
}

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

	BinaryTreeDestory(root->left);
	BinaryTreeDestory(root->right);
	free(root);
}

void LevelOrder(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);
		}
	}
	printf("\n");
	QueueDestroy(&q);
}

bool BinaryTreeComplete(BTNode* root)
{
    
    
	Queue q;
	QueueInit(&q);

	if (root)
	{
    
    
		QueuePush(&q, root);
	}

	while (!QueueEmpty(&q))
	{
    
    
		BTNode* front = QueueFront(&q);
		QueuePop(&q);
		if (front)
		{
    
    
			QueuePush(&q, front->left);
			QueuePush(&q, front->right);
		}
		else
		{
    
    
			break;
		}
	}
	while (!QueueEmpty(&q))
	{
    
    
		BTNode* Front = QueueFront(&q);
		QueuePop(&q);
		if (Front)
			return false;
	}
	QueueDestroy(&q);
	return true;
}

5.3 Test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"Tree.h"
#include"Queue.h"

BTNode* CreatBinaryTree()
{
    
    
	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 = node4;
	node2->left = node3;
	node4->left = node5;
	node4->right = node6;
	node2->right = node7;
	return node1;
}

//测试基本功能
void test1()
{
    
    
	BTNode* root = CreatBinaryTree();
	PreOrder(root);  //测试:前序遍历
	printf("\n");

	InOrder(root);  //测试:中序遍历
	printf("\n");

	PostOrder(root);  //测试:后序遍历
	printf("\n");

	int count = BinaryTreeSize(root);  //测试:统计树的结点个数
	printf("BinaryTreeSize:%d\n", count);

	int leafSize = BinaryTreeLeafSize(root);  //测试:统计树的叶子结点个数
	printf("BinaryTreeLeafSize:%d\n", leafSize);

	int LeveKSize = BinaryTreeLevelKSize(root,3);  //测试:统计树的第K层的结点个数
	printf("BinaryTreeLevelKSize:%d\n", LeveKSize);

	LevelOrder(root);  //测试:层序遍历

	printf("BinaryTreeComplete:%d\n", BinaryTreeComplete(root));  //测试:判断是否为完全二叉树

	BinaryTreeDestory(root);
}

// 通过前序遍历的数组"ABD##E#H##CF##G##"构建二叉树
void test2()
{
    
    
	char str[20] = "ABC##DE#G##F###";
	int i = 0;
	int* pi = &i;
	BTNode* root = BinaryTreeCreate(str, pi);
	PreOrder(root);
	printf("\n");

	BinaryTreeDestory(root);
}

int main()
{
    
    
	test1();
	//test2();
	return 0;
}

5.4 Queue.h

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

//前置声明
struct BinaryTreeNode;

typedef struct BinaryTreeNode* Datatype;

//链式结构表示队列
typedef struct QListNode
{
    
    
	Datatype data;
	struct Queue* next;
}QNode;

typedef struct Queue
{
    
    
	QNode* front;
	QNode* tail;
}Queue;

// 初始化队列
void QueueInit(Queue* pq);

// 队尾入队列
void QueuePush(Queue* pq, Datatype data);

// 队头出队列
void QueuePop(Queue* pq);

// 获取队列头部元素
Datatype QueueFront(Queue* pq);

// 获取队列队尾元素
Datatype QueueBack(Queue* pq);

// 获取队列中有效元素个数
int QueueSize(Queue* pq);

// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 
bool QueueEmpty(Queue* pq);

// 销毁队列
void QueueDestroy(Queue* pq);

5.5 Queue.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"Queue.h"

void QueueInit(Queue* pq)
{
    
    
	assert(pq);
	
	pq->front = NULL;
	pq->tail = NULL;
}

void QueueDestroy(Queue* pq)
{
    
    
	assert(pq);
	QNode* cur = pq->front;
	while (cur != NULL)
	{
    
    
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}
	pq->front = NULL;
	pq->tail = NULL;
}

void QueuePush(Queue* pq, Datatype x)
{
    
    
	assert(pq);	
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
    
    
		printf("开辟失败！！");
		return;
	}
	newnode->next = NULL;
	newnode->data = x;
	
	if (pq->front == NULL)
	{
    
    
		pq->tail = newnode;
		pq->front = newnode;
	}
	else
	{
    
    
		pq->tail->next = newnode;
		pq->tail = pq->tail->next;
	}
}

void QueuePop(Queue* pq)
{
    
    
	assert(pq);
	assert(!QueueEmpty(pq));

	QNode* next = pq->front->next;
	free(pq->front);
	pq->front = next;
	if (pq->front == NULL)
	{
    
    
		pq->tail = NULL;
	}
}


Datatype QueueFront(Queue* pq)
{
    
    
	assert(pq);
	assert(!QueueEmpty(pq));
	return pq->front->data;
}

Datatype QueueBack(Queue* pq)
{
    
    
	assert(pq);
	assert(!QueueEmpty(pq));
	return pq->tail->data;
}

int QueueSize(Queue* pq)
{
    
    
	assert(pq);
	int count = 0;
	QNode* cur = pq->front;
	while (cur)
	{
    
    
		count++;
		cur = cur->next;
	}
	return count;
}

bool QueueEmpty(Queue* pq)
{
    
    
	assert(pq);
	if (pq->front == NULL)
	{
    
    
		return true;
	}
	return false;
}

6. 总结

  二叉树的内容还是比较多的，并且对于递归有很强的要求性，初学者可以通过手动画图这一途径来进行来理解是一个很不错的方式。想要快速的学好二叉树画图是必不可少的。
  此篇内容较多，我也是花费了几天时间来整理，略感疲惫（叹气），如果大家发现有什么错误的地方，可以私信或者评论区指出喔。那么树的讲解就先告一段落了，接下来就剩下排序了，希望能与大家共同进步，那么本期就到此结束，让我们下期再见！！觉得不错可以点个赞以示鼓励喔！！