数据结构：如果写代码，就写一棵树

前言

hello，大家好，这期文章呢，来介绍一下关于树的知识点。在介绍树之前呢，首先先要了解什么是树。如果你已经学会了离散数学，那么概念你自然已经懂的了，如果你学过离散但和博主一样学了等于没学，那你还需要和博主一起重新了解一下什么叫树。
提到树啊，我们总会想起那句著名的话“如果有来生，要做一棵树，站成永恒”。其实实现做一棵树的梦想也许不必等到来生，打开VS，给自己写一棵吧。

1. 树的概念及结构

1. 树的概念

树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。有一个特殊的结点，称为根结点，根节点没有前驱结点除根节点外，其余结点被分成M(M>0)个互不相交的集合T1、T2、……、Tm，其中每一个集合Ti(1<= i<= m)又是一棵结构与树类似的子树。每棵子树的根结点有且只有一个前驱，可以有0个或多个后继因此，树是递归定义的。

当然，并不是所有树都如此繁茂，比如空树。

1.2 树中的一些名称

1.2.2 节点

父节点和子节点：A、B、C、D、E、F、G……都是节点。其中，A为B、C、D、E、F、G的父节点（或双亲节点）。B、C、D、E、F、G为A的子节点（或孩子节点）。同理，D为H、I的父节点，H、I为D的子节点。I为L、M、N的父节点，L、M、N为i的子节点。
根节点和叶节点：没有父节点的节点成为根节点，没有子节点的节点称为叶节点。A为根节点，H、G、L、M、N、O、P为叶节点。

1.2.3 子树

以非根节点的其他节点为根节点构成的“小树”为字树。


这些均为子树。

1.2.4 树的高度或深度

节点的层次：从根开始定义起，根为第1层，根的子节点为第2层，以此类推；
树的高度或深度：树中节点的最大层次； 如上图：树的高度为4。

1.2.5 度

节点的度：一个节点含有的子树的个数称为该节点的度； 如上图：A的为6。B的为0，D的为2。
树的度：一棵树中，最大的节点的度称为树的度； 如上图：树的度为6。
叶节点或终端节点：度为0的节点称为叶节点。如B、C、F、H、G、L、M、N、O、P。
非终端节点或分支节点：度不为0的节点。如A、D、G、I、K。

1.2.6 树中的亲戚关系

双亲节点或父节点：若一个节点含有子节点，则这个节点称为其子节点的父节点。
孩子节点或子节点：一个节点含有的子树的根节点称为该节点的子节点
兄弟节点：具有相同父节点的节点互称为兄弟节点。如O和P。
堂兄弟节点：双亲在同一层的节点互为堂兄弟如H和G。
节点的祖先：从根到该节点所经分支上的所有节点
子孙：以某节点为根的子树中任一节点都称为该节点的子孙
森林：由m（m>0）棵互不相交的树的集合称为森林。

1.3 非树

树需要满足以下条件：
1.子树不相交

2.除根节点外每一个节点都有且仅有一个父节点。

3.一棵N个节点的树有N-1条边。

根据以上条件可以看出，树里面是不包含环的，有环则不为树。

1.4 树的表示

由于树的结构复杂，表示起来也十分困难。在树的多种表示方式中如：双亲表示法，孩子表示法、孩子兄弟表示法等等。最常用的孩子兄弟表示法。

1.4.1 双亲表示法

每个值存双亲的下标。这种表示方法虽然可能知道双亲，但遗憾的是不能知道孩子。如果要找孩子，就要遍历整个结构。

#define MAX_TREE_SIZE 100
typedef struct TreeNode
{
     
	int  data;  //结点数据域
	int parent; //双亲位置
}TNode;
typedef struct
{
                   
	TNode nodes[MAX_TREE_SIZE];    //结点数组
	int  r, n;                     //根节点的位置和结点数
};

1.4.2 孩子表示法

每一棵树都是有根和子树构成，子树也是一样的构成，但是树并不确定有多少个孩子。
我们要使用孩子表示法，就要给每一个孩子对应一个指针。但并不是每一个节点都拥有相同数量的孩子，这就会造成很大的浪费。

struct TreeNode
{
     
	int data;
	struct TreeNode*child1;
	struct TreeNode*child2;
	struct TreeNode*child2;
	……
};

我们也可以采用动态增长的顺序表来通过指针数组来实现孩子指针，在C++中也可以通过vector来解决问题。但这种方法仍然没有从本质上解决问题，还是有许多麻烦。

struct TreeNode
{
     
	int data;
	SeqList childarr;//指针数组，顺序表中存的是struct TreeNode*
};

所以这种方法是不太友好的。

1.4.3 孩子兄弟表示法

struct TreeNode
{
     
	int data;
	struct TreeNode*FirstChild;//指向第一个孩子的节点
	struct TreeNode*pNextBrother;//指向下一个兄弟的节点
};

这是一种很奇妙的表示方法，由孩子找孩子。解决了多孩子不好找问题。

每一个节点都有两个指针，一个指向兄弟，有兄弟则指向兄弟，没有兄弟指向空。一个指针指向最左边的子节点也就是第一个孩子，由第一个孩子去找到第二个孩子，以此类推。
这不由得使我想起了乔祖望，这个不靠谱的渣爹。他管过孩子是甩手掌柜，所有的孩子都是由老大一成来带的。乔祖望就相当于父节点，而一成就是最左边的子节点，而连接乔家的兄弟姐妹的感情的，就是指向兄弟节点的指针。

1.5 树在实际中的应用

目录系统就是树的一个典型应用。

2. 树的计划生育——二叉树

我们通过上面对树的介绍，已经对树有了初步了了解。我们也已经发现，一棵树如果孩子太多，就会很麻烦。要是树也能计划生育一下就好了，只生一个好，树树皆好找。但是树也是逐渐放开了二胎政策的，于是二叉树就出现了。（放开了三胎政策后，会不会三叉树成为主流呢？）

2.1 二叉树的概念

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

1. 每个结点最多有两棵子树，即二叉树不存在度大于2的结点。
2. 二叉树的子树有左右之分，其子树的次序不能颠倒。

也就是说，二叉树里面，一个父节点可以没有孩子，或者一个孩子，或者两个孩子，孩子不能再多了，最多两个。而且，大孩子和小孩子要区分开，顺序不能颠倒。

上图为一个二叉树，里面有独生子女家庭，有二胎家庭，也有丁克家庭。但没有三胎及以上的家庭。
注意，这样的也是二叉树哦。

2.2 特殊的二叉树

2.2.1 满二叉树

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

所谓的满二叉树就是，除了最小的一辈没有孩子外，其他的都是二胎家庭。下一层的节点是上一节的二倍。

2.2.2 完全二叉树

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

完全二叉树是一种允许非最小一辈丁克的二叉树。也就是，最小一辈没孩子，其他辈分的，要么生二胎，要么选择丁克。完全二叉树前n-1层都是满的，最后一层可以不满，但从左到右是连续的，不可以跳着不满。简而言之就是，老大不生老二不可以生，老大一胎老二不许二胎。

这样是不可以的：

注意，满二叉树是一种特殊的完全二叉树。

2.3 二叉树的性质

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

根据以上性质，我们来看几道题：

1. 某二叉树共有 399 个结点，其中有 199 个度为 2 的结点，则该二叉树中的叶子结点数为（ ）
   A 不存在这样的二叉树
   B 200
   C 198
   D 199
   根据度为0比度为二多一，所以要选200.而200+199正好得399，又可以证明是二叉树。
   2.在具有 2n 个结点的完全二叉树中，叶子结点个数为（ ）
   A n
   B n+1
   C n-1
   D n/2
   设度为0的叶子有m个，设度为1的节点有p个，度为2的有q个，则有m+p+q=2n,并且m=q+1.而且，对于完全二叉树度为1的节点最多有一个。如果p=0.则2q+1=2n。n是正整数，所以不存在，所以p=1.则有2q+1+1=2n。所以m=n。答案为A。
   3.一棵完全二叉树的节点数位为531个，那么这棵树的高度为（ ）
   A 11
   B 10
   C 8
   D 12
   设深度为h，最后一层相对于满二叉树缺的节点为x，x的范围为0到2^(h-1)-1.所以可以将选项带入进行求证，最后选B。

2.4 二叉树的存储结构

2.4.1 顺序存储

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

顺序存储在存储非完全二叉树时会存在空间的浪费。

2.4.2 链式存储

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

二叉链：只能找孩子

三叉链：可以找孩子，也可以找父亲

二叉链表和三叉链表：

// 二叉链
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 堆的概念及结构

如果有一个关键码的集合K = {k0，k1， k2，…，kn-1}，把它的所有元素按完全二叉树的顺序存储方式存储在一个一维数组中，并满足：Ki <= K2i+1 且 Ki<= K2i+2 (Ki >= K2i+1 且 Ki >= K2i+2) i = 0，1，2…，则称为小堆(或大堆)。将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。
堆的性质：
堆中某个节点的值总是不大于或不小于其父节点的值；
堆总是一棵完全二叉树。

3.1.1 大根堆小根堆

堆的物理结构是数组，堆的逻辑结构是一个完全二叉树，大根堆中所有的父亲大于等于孩子，小根堆中所有的父亲小于等于孩子。
大根堆：

小根堆：

3.1.2 下标规律

3.2 堆的实现

3.2.1 堆向下调整算法

3.2.1.1 思路分析

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

1.选出左右孩子中小的那一个
2.小的孩子和父亲比
3.如果孩子比父亲小，则与父亲交换，并把原来孩子的位置当成父亲继续往下调整。
4.如果小的孩子比父亲大，则完成调整。

3.2.1.2 代码实现

#include

void Swap(int *p, int *q)
{
     
	int temp;
	temp = *p;
	*p = *q;
	*q = temp;
}

void AdjustDown(int *a,int n,int parent)
{
     
	int child = parent * 2 + 1;
	while (child < n)
	{
     
		//选出左右孩子较小的一个
		if (child+1<n&&a[child + 1] < a[child])
		{
     
			++child;
		}
		//孩子和父亲比大小
		if (a[child] < a[parent])
		{
     
			Swap(&a[parent], &a[child]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
     
			break;
		}
	}
}

int main()
{
     
	int a[] = {
      28, 16, 20, 19, 29, 35, 66, 50, 26, 38 };
	int n = sizeof(a) / sizeof(a[0]);
	AdjustDown(a, n, 0);
	for (int i = 0; i < n; i++)
	{
     
		printf("%d  ", a[i]);
	}
	printf("\n");
	return 0;
}

3.2.2 向上调整排序算法

3.2.2.1 思路分析

向上排序算法和向下排序算法类似，如果我们插入的值比父亲大，就交换。依次向上。

3.2.2.2 代码实现

void AdjustUp(int*a,int child)
{
     
	int parent = (child - 1) / 2;
	while (child>0)
	{
     
		if (a[child] > a[parent])
		{
     
			Swap(&a[child], &a[parent]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
     
			break;
		}
	}
}

3.2.3 堆的创建

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

当左右子树不是小堆时，也就是说，我们需要多次调用向下调整算法。

从倒数第一个非叶子节点，从后往前排。按编号，一次作为子树去向下调整。

#include

void Swap(int *p, int *q)
{
     
	int temp;
	temp = *p;
	*p = *q;
	*q = temp;
}

void AdjustDown(int *a,int n,int parent)
{
     
	int child = parent * 2 + 1;
	while (child < n)
	{
     
		//选出左右孩子较小的一个
		if (child+1<n&&a[child + 1] < a[child])
		{
     
			++child;
		}
		//孩子和父亲比大小
		if (a[child] < a[parent])
		{
     
			Swap(&a[parent], &a[child]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
     
			break;
		}
	}
}

int main()
{
     
	int a[] = {
      20, 16, 38, 29, 50, 35, 66, 19, 26, 28 };
	int n = sizeof(a) / sizeof(a[0]);
	for (int j = (n - 1 - 1) / 2; j >= 0; --j)
	{
     
		AdjustDown(a, n,j);
	}
	for (int i = 0; i < n; i++)
	{
     
		printf("%d  ", a[i]);
	}
	printf("\n");
	return 0;
}

注意，如果是大根堆，只需要将比较时的小于号全部换成大于号就可以。

3.2.4 堆的排序

首先，我们要思考这样一个问题。当我们想要排升序时，应该建大根堆还是小根堆呢？降序时呢？答案是升序时建大堆，降序时建小堆。
我们以升序为例，升序为什么不能建小堆呢？建堆的时间复杂度为O(N)。如果我们建小堆，堆选出最小的数花了O(N)。紧接着剩下的N-1个数如何选出次小呢？剩下的数父子关系依旧全是乱的需要重新建堆。消耗很大。但如果我们建大堆，我们选出最大的后，将其和最后一个数字互换位置，紧接着选出次大的时，不把最后一个数字看出堆里面的，父子关系未变，向下调整就能选出次大的。
我们以升序排列为例观察一下排序流程：



从这个流程中我们就可以感受到，如果排升序建小堆的话，会混乱很多。

接下来的代码展示升序建大堆：

#include

void Swap(int *p, int *q)
{
     
	int temp;
	temp = *p;
	*p = *q;
	*q = temp;
}

void AdjustDown(int *a,int n,int parent)
{
     
	int child = parent * 2 + 1;
	while (child < n)
	{
     
		//选出左右孩子较大的一个
		if (child+1<n&&a[child + 1] > a[child])
		{
     
			++child;
		}
		//孩子和父亲比大小
		if (a[child] > a[parent])
		{
     
			Swap(&a[parent], &a[child]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
     
			break;
		}
	}
}

void HeapSort(int *a, int n)
{
     
	for (int j = (n - 1 - 1) / 2; j >= 0; --j)
	{
     
		AdjustDown(a, n, j);
	}
	int end = n - 1;
	while (end>0)
	{
     
		Swap(&a[0], &a[end]);
		AdjustDown(a, end, 0);
		--end;
	}
}
int main()
{
     
	int a[] = {
      20, 16, 38, 29, 50, 35, 66, 19, 26, 28 };
	int n = sizeof(a) / sizeof(a[0]);
	HeapSort(a, n);
	for (int i = 0; i < n; i++)
	{
     
		printf("%d  ", a[i]);
	}
	printf("\n");
	return 0;
}

接下来的代码，我们展示了堆的降序排序建小堆：

#include

void Swap(int *p, int *q)
{
     
	int temp;
	temp = *p;
	*p = *q;
	*q = temp;
}

void AdjustDown(int *a,int n,int parent)
{
     
	int child = parent * 2 + 1;
	while (child < n)
	{
     
		//选出左右孩子较小的一个
		if (child+1<n&&a[child + 1] < a[child])
		{
     
			++child;
		}
		//孩子和父亲比大小
		if (a[child] < a[parent])
		{
     
			Swap(&a[parent], &a[child]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
     
			break;
		}
	}
}

void HeapSort(int *a, int n)
{
     
	for (int j = (n - 1 - 1) / 2; j >= 0; --j)
	{
     
		AdjustDown(a, n, j);
	}
	int end = n - 1;
	while (end>0)
	{
     
		Swap(&a[0], &a[end]);
		AdjustDown(a, end, 0);
		--end;
	}
}
int main()
{
     
	int a[] = {
      20, 16, 38, 29, 50, 35, 66, 19, 26, 28 };
	int n = sizeof(a) / sizeof(a[0]);
	HeapSort(a, n);
	for (int i = 0; i < n; i++)
	{
     
		printf("%d  ", a[i]);
	}
	printf("\n");
	return 0;
}

注意：堆排序的时间复杂度是O(N*logN)。

3.2.5 堆的基本功能的实现（以大根堆为例）

3.2.5.1 堆的插入

堆的插入是先增加元素到尾上，然后通过向上调整的排序法，直到满足堆。
我们要将88插入，流程如下：

代码如下：

void HeapPush(HP*php, HPDataType x)
{
     
	assert(php);
	if (php->size == php->capacity)
	{
     
		HPDataType*tmp = (HPDataType*)realloc(php->a, sizeof(HPDataType)*php->capacity * 2);
		if (tmp == NULL)
		{
     
			printf("realloc fail\n");
			exit(-1);
		}
		php->a = tmp;
		php->capacity *= 2;
	}
	php->a[php->size] = x;
	php->size++;
	AdjustUp(php->a, php->size-1);
}

3.2.5.2 堆的删除

堆的删除是删除堆顶的元素，实现思路是，先将堆顶元素与堆尾元素交换，将size-1，实现删除，同时通过向下调整算法重新将堆调整好。

代码如下：

void HeapPop(HP*php)
{
     
	assert(php);
	assert(php->size > 0);
	Swap(&php->a[0], &php->a[php->size-1]);
	php->size--;
	AdjustDown(php->a, php->size-1, 0);
}

3.2.5.3 获取堆顶元素、判空、求大小

这些实现起来很简单，代码如下：

HPDataType HeapTop(HP*php)
{
     
	assert(php);
	assert(php->size > 0);
	return php->a[0];
}
int HeapSize(HP*php)
{
     
	assert(php);
	return php->size;
}
bool HeapEmpty(HP*php)
{
     
	if (php->size == 0)
		return true;
	else
		return false;
}

3.2.5.4 完整代码及运行测试

Heqp.h文件

#include
#include
#include
#include

typedef int HPDataType;

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

}HP;

void AdjustDown(int *a, int n, int parent);
void AdjustUp(int *a, int child);
HP* HeapInit(HP*php, HPDataType*a, int n);
void HeapDestroy(HP *php);
void HeapPush(HP*php, HPDataType x);
void HeapPop(HP*php);
HPDataType HeapTop(HP*php);
int HeapSize(HP*php);
bool HeapEmpty(HP*php);
void HeapPrint(HP*php);

Heap.c文件

#include"Heap.h"

void Swap(int *p, int *q)
{
     
	int temp;
	temp = *p;
	*p = *q;
	*q = temp;
}

void AdjustDown(int *a, int n, int parent)
{
     
	int child = parent * 2 + 1;
	while (child < n)
	{
     
		//选出左右孩子较大的一个
		if (child + 1<n&&a[child + 1] > a[child])
		{
     
			++child;
		}
		//孩子和父亲比大小
		if (a[child] > a[parent])
		{
     
			Swap(&a[parent], &a[child]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
     
			break;
		}
	}
}
void AdjustUp(int*a,int child)
{
     
	int parent = (child - 1) / 2;
	while (child>0)
	{
     
		if (a[child] > a[parent])
		{
     
			Swap(&a[child], &a[parent]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
     
			break;
		}
	}
}

HP* HeapInit(HP*php, HPDataType*a, int n)
{
     
	assert(php);
	php->a = (HPDataType*)malloc(sizeof(HPDataType)*n);
	if (php->a == NULL)
	{
     
		printf("malloc fail\n");
		exit(-1);
	}
	memcpy(php->a, a, sizeof(HPDataType)*n);
	php->size = n;
	php->capacity = n;

	//建大堆
	for (int j = (n - 1 - 1) / 2; j >= 0; --j)
	{
     
		AdjustDown(php->a,php->size, j);
	}
}
void HeapDestroy(HP *php)
{
     
	assert(php);
	free(php->a);
	php->a = NULL;
	php->size = php->capacity = 0;

}
void HeapPush(HP*php, HPDataType x)
{
     
	assert(php);
	if (php->size == php->capacity)
	{
     
		HPDataType*tmp = (HPDataType*)realloc(php->a, sizeof(HPDataType)*php->capacity * 2);
		if (tmp == NULL)
		{
     
			printf("realloc fail\n");
			exit(-1);
		}
		php->a = tmp;
		php->capacity *= 2;
	}
	php->a[php->size] = x;
	php->size++;
	AdjustUp(php->a, php->size-1);
}
void HeapPop(HP*php)
{
     
	assert(php);
	assert(php->size > 0);
	Swap(&php->a[0], &php->a[php->size-1]);
	php->size--;
	AdjustDown(php->a, php->size-1, 0);
}
HPDataType HeapTop(HP*php)
{
     
	assert(php);
	assert(php->size > 0);
	return php->a[0];
}
int HeapSize(HP*php)
{
     
	assert(php);
	return php->size;
}
bool HeapEmpty(HP*php)
{
     
	if (php->size == 0)
		return true;
	else
		return false;
}
void HeapPrint(HP*php)
{
     
	for (int i = 0; i <php-> size; i++)
	{
     
		printf("%d  ", php->a[i]);
	}
	printf("\n");
	printf("\n");
	int num = 0;
	int levelSize = 1;
	for (int i = 0; i < php->size; i++)
	{
     
		printf("%d  ", php->a[i]);
		++num;
		if (levelSize == num)
		{
     
			printf("\n");
			levelSize *= 2;
			num = 0;
		}
	}
	printf("\n");
	printf("\n");
	printf("\n");
}

test.c文件

#include"Heap.h"


int main()
{
     
	int a[] = {
      20, 16, 38, 29, 50, 35, 66, 19, 26, 28 };
	int n = sizeof(a) / sizeof(a[0]);
	HP hp;
	HeapInit(&hp, a, n);
	HeapPrint(&hp);
	HeapPush(&hp, 88);
	HeapPrint(&hp);
	HeapPop(&hp);
	HeapPrint(&hp);
	printf("%d\n", HeapTop(&hp));
	HeapDestroy(&hp);
	
	return 0;
}

运行测试：

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

4.1 二叉树链式结构的遍历

所谓遍历(Traversal)是指沿着某条搜索路线，依次对树中每个结点均做一次且仅做一次访问。

二叉树有四种遍历顺序：
1.前序遍历（先根遍历）
2.中序遍历（中根遍历）
3.后序遍历（后根遍历）
4.层序遍历

4.1.1 前序遍历（先根遍历）

遍历顺序为：根——>左子树——>右子树

4.1.2 中序遍历（中根遍历）

遍历顺序为：左子树——>根——>右子树

4.1.3 后序遍历（后根遍历）

遍历顺序为：左子树——>右子树——>根

4.1.4 层序遍历

遍历顺序为：依次遍历

层序遍历代码：

void TreeLevelOrder(BTNode*root)
{
     
	Queue q;
	QueueInit(&q);
	if (root)
	{
     
		QueuePush(&q, root);
	}
	while (!QueueEmpty(&q))
	{
     
		BTNode*front = QueueFront(&q);
		QueuePop(&q);
		printf("%c  ", front->data);
		if (front->left)
		{
     
			QueuePush(&q, front->left);
		}
		if (front->right)
		{
     
			QueuePush(&q, front->right);
		}
	}
}

代码中涉及到的队列的函数我们已经在之前的文章数据结构：队列中实现。

4.1.5 前中后序遍历的代码实现

#include
#include


typedef char BTDataType;

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

BTNode*CreateTreeNode(BTDataType x)
{
     
	BTNode*node = malloc(sizeof(BTNode));
	node->data = x;
	node->left = NULL;
	node->right = NULL;
	return node;
}
//前序
void PrevOrder(BTNode*root)
{
     
	if (root == NULL)
	{
     
		printf("NULL  ");
		return;
	}
	printf("%c  ", root->data);
	PrevOrder(root->left);
	PrevOrder(root->right);
}
//中序
void InOrder(BTNode*root)
{
     
	if (root == NULL)
	{
     
		printf("NULL  ");
		return;
	}
	InOrder(root->left);
	printf("%c  ", root->data);
	InOrder(root->right);
}
//后序
void PostOrder(BTNode*root)
{
     
	if (root == NULL)
	{
     
		printf("NULL  ");
		return;
	}
	PostOrder(root->left);
	PostOrder(root->right);
	printf("%c  ", root->data);
}

int main()
{
     
	BTNode*A = CreateTreeNode('A');
	BTNode*B = CreateTreeNode('B');
	BTNode*C = CreateTreeNode('C');
	BTNode*D = CreateTreeNode('D');
	BTNode*E = CreateTreeNode('E');
	BTNode*F = CreateTreeNode('F');

	A->left = B;
	A->right = C;
	B->left = D;
	C->left = E;
	C->right = F;
	PrevOrder(A);
	printf("\n");
	InOrder(A);
	printf("\n");
	PostOrder(A);
	printf("\n");
	return 0;
}

4.2 二叉树节点计数方法

4.2.1 遍历计数

实现思路：

代码：

#include
#include
typedef char BTDataType;

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

BTNode*CreateTreeNode(BTDataType x)
{
     
	BTNode*node = malloc(sizeof(BTNode));
	node->data = x;
	node->left = NULL;
	node->right = NULL;
	return node;
}
//求节点个数:思路一  遍历计数
void TreeSize1(BTNode*root,int *psize)
{
     
	if (root == NULL)
	{
     
		return;
	}
	++(*psize);
	TreeSize1(root->left,psize);
	TreeSize1(root->right,psize);
}
int main()
{
     
	BTNode*A = CreateTreeNode('A');
	BTNode*B = CreateTreeNode('B');
	BTNode*C = CreateTreeNode('C');
	BTNode*D = CreateTreeNode('D');
	BTNode*E = CreateTreeNode('E');
	BTNode*F = CreateTreeNode('F');

	A->left = B;
	A->right = C;
	B->left = D;
	C->left = E;
	C->right = F;
	int size = 0;
	TreeSize1(A,&size);
	printf("TreeSize1:%d\n", size);
	return 0;
}

4.2.2 拆解计数

实现思路：

代码：

#include
#include

typedef char BTDataType;

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

BTNode*CreateTreeNode(BTDataType x)
{
     
	BTNode*node = malloc(sizeof(BTNode));
	node->data = x;
	node->left = NULL;
	node->right = NULL;
	return node;
}
//求节点个数:思路二  拆解计数
int TreeSize2(BTNode*root)
{
     
	return root == NULL ?0: TreeSize2(root->left) + TreeSize2(root->right) + 1;
}
int main()
{
     
	BTNode*A = CreateTreeNode('A');
	BTNode*B = CreateTreeNode('B');
	BTNode*C = CreateTreeNode('C');
	BTNode*D = CreateTreeNode('D');
	BTNode*E = CreateTreeNode('E');
	BTNode*F = CreateTreeNode('F');

	A->left = B;
	A->right = C;
	B->left = D;
	C->left = E;
	C->right = F;
	printf("TreeSize1:%d\n", size);
	return 0;
}

4.3 求叶子的个数

如果是NULL叶子树为0，如果是指向NULL则代表为叶子。根据这个原理可以得出求叶子树的函数。

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

4.4 求树的深度

树的深度的求法思想是一层层求下去，遇到NULL是0，遇到子树的根继续下去，同时深度+1，继续下去，左右树同时求深度，取大值为整棵树的最大深度

int TreeMaxDepth(BTNode*root)
{
     
	if (root == NULL)
	{
     
		return 0;
	}
	int LeftDepth = TreeMaxDepth(root->left);
	int Rightdepth = TreeMaxDepth(root->right);
	return LeftDepth > Rightdepth ? LeftDepth + 1 : Rightdepth + 1;
}

4.5 求第k层节点个数

这个实现的主要思想是依照上一层的左右指向的节点求本层个数，以此类推。

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

4.6 查找值为x的节点

如果root=NULL，return NULL。如果root不是我们要找的，先去左树找，再去右树找。如果最后都没找到，则当前树无此值，返回空。

// 二叉树查找值为x的节点
BTNode* TreeFind(BTNode* root, BTDataType x)
{
     
	if (root == NULL)
	{
     
		return NULL;
	}
	if (root->data == x)
	{
     
		return root;
	}
	BTNode*lret = TreeFind(root->left, x);
	if (lret)
	{
     
		return lret;
	}
	BTNode*rret = TreeFind(root->right, x);
	if (rret)
	{
     
		return rret;
	}
	return NULL;
}

4.7 销毁二叉树

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

这种方法注意销毁之后置空二叉树的根。

TreeDestroy(A);
	A = NULL;

如果不想再调用之后置空，我们可以采用二级指针的方法。在函数里面置空。

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

4.8 单值二叉树判断

如果二叉树每个节点都具有相同的值，那么该二叉树就是单值二叉树。只有给定的树是单值二叉树时，才返回 true；否则返回 false。

//判断单值树
bool TreeSingle(BTNode*root)
{
     
	if (root == NULL)
	{
     
		return true;
	}
	if (root->left&&root->left->data != root->data)
	{
     
		return false;
	}
	if (root->right&&root->right->data != root->data)
	{
     
		return false;
	}
	return TreeSingle(root->left) && TreeSingle(root->right);
}

判断单值树的思路就是不断对比，只要出现不相同的就为false，还是采用了递归调用。

4.9 对称二叉树

给定一个二叉树，检查它是否是镜像对称的。

bool _TreeSymmertic(BTNode*left, BTNode*right)
{
     
	if (left == NULL&&right == NULL)
	{
     
		return true;
	}
	if (left == NULL || right == NULL)
	{
     
		return false;
	}
	if (left->data != right->data)
	{
     
		return false;
	}
	return _TreeSymmertic(left->right, right->left);
}

bool TreeSymmertic(BTNode*root)
{
     
	if (root == NULL)
	{
     
		return true;
	}
	return _TreeSymmertic(root->left, root->right);
}

4.10 判断两棵树是否相同

如果两个二叉树都为空，则两个二叉树相同。如果两个二叉树中有且只有一个为空，则两个二叉树一定不相同。如果两个二叉树都不为空，那么首先判断它们的根节点的值是否相同，若不相同则两个二叉树一定不同，若相同，再分别判断两个二叉树的左子树是否相同以及右子树是否相同。这是一个递归的过程，因此可以使用深度优先搜索，递归地判断两个二叉树是否相同。

//判断两棵树是否相同
bool TreeSame(BTNode*root1,BTNode*root2)
{
     
	if (root1 == NULL && root2== NULL) 
	{
     
		return true;
	}
	else if (root1 == NULL || root2== NULL)
	{
     
		return false;
	}
	else if (root1->data != root2->data) 
	{
     
		return false;
	}
	else 
	{
     
		return TreeSame(root1->left, root2->left) &&TreeSame(root1->right, root2->right);
	}
}

4.11 判断一棵树为另一棵树的子树

这道题可以将要验证的树和另一棵树的每一个子树比较，若能找到相同的，则是，否则为否。这里我们巧用了之前判断两棵树是否相等的函数。

//判断一棵树为另一棵树的子树
bool TreeSub(BTNode*root, BTNode*subroot)
{
     
	if (root == NULL)
	{
     
		return false;
	}
	if (TreeSame(root, subroot))
	{
     
		return true;
	}
	return TreeSub(root->left,subroot) || TreeSub(root->right,subroot);
}

4.12 平衡二叉树

//判断平衡二叉树
bool _TreeBalance(BTNode*root,int *ph)
{
     
	if (root == NULL)
	{
     
		*ph = 0;
		return true;
	}
	int LeftHeight = 0;
	if (_TreeBalance(root->left, &LeftHeight) == false)
		return false;
	int RightHeight = 0;
	if (_TreeBalance(root->right, &RightHeight) == false)
		return false;
	*ph = fmax(LeftHeight, RightHeight) + 1;
	return abs(LeftHeight - RightHeight) < 2;
}

bool TreeBalance(BTNode*root)
{
     
	if (root == NULL)
	{
     
		return true;
	}
	int height = 0;
	return _TreeBalance(root, &height);
}

4.13 完整代码

#include
#include
#include

typedef char BTDataType;

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

BTNode*CreateTreeNode(BTDataType x)
{
     
	BTNode*node = malloc(sizeof(BTNode));
	node->data = x;
	node->left = NULL;
	node->right = NULL;
	return node;
}
//前序
void PrevOrder(BTNode*root)
{
     
	if (root == NULL)
	{
     
		printf("NULL  ");
		return;
	}
	printf("%c  ", root->data);
	PrevOrder(root->left);
	PrevOrder(root->right);
}
//中序
void InOrder(BTNode*root)
{
     
	if (root == NULL)
	{
     
		printf("NULL  ");
		return;
	}
	InOrder(root->left);
	printf("%c  ", root->data);
	InOrder(root->right);
}
//后序
void PostOrder(BTNode*root)
{
     
	if (root == NULL)
	{
     
		printf("NULL  ");
		return;
	}
	PostOrder(root->left);
	PostOrder(root->right);
	printf("%c  ", root->data);
}

层序遍历，使用时需要引入队列的头文件
//void TreeLevelOrder(BTNode*root)
//{
     
//	Queue q;
//	QueueInit(&q);
//	if (root)
//	{
     
//		QueuePush(&q, root);
//	}
//	while (!QueueEmpty(&q))
//	{
     
//		BTNode*front = QueueFront(&q);
//		QueuePop(&q);
//		printf("%c  ", front->data);
//		if (front->left)
//		{
     
//			QueuePush(&q, front->left);
//		}
//		if (front->right)
//		{
     
//			QueuePush(&q, front->right);
//		}
//	}
//}
//求节点个数:思路一  遍历计数
void TreeSize1(BTNode*root,int *psize)
{
     
	if (root == NULL)
	{
     
		return;
	}
	++(*psize);
	TreeSize1(root->left,psize);
	TreeSize1(root->right,psize);
}
//求节点个数:思路二  拆解计数
int TreeSize2(BTNode*root)
{
     
	return root == NULL ?0: TreeSize2(root->left) + TreeSize2(root->right) + 1;
}
// 二叉树叶子节点个数
int TreeLeafSize(BTNode* root)
{
     
	if (root == NULL)
	{
     
		return 0;
	}
	if (root->left == NULL&&root->right == NULL)
	{
     
		return 1;
	}
	return TreeLeafSize(root->left) + TreeLeafSize(root->right);
}
// 二叉树第k层节点个数
int TreeLevelKSize(BTNode* root, int k)
{
     
	if (root == NULL)
	{
     
		return 0;
	}
	if (k == 1)
	{
     
		return 1;
	}
	return TreeLevelKSize(root->left, k - 1) + TreeLevelKSize(root->right, k - 1);
}
// 二叉树查找值为x的节点
BTNode* TreeFind(BTNode* root, BTDataType x)
{
     
	if (root == NULL)
	{
     
		return NULL;
	}
	if (root->data == x)
	{
     
		return root;
	}
	BTNode*lret = TreeFind(root->left, x);
	if (lret)
	{
     
		return lret;
	}
	BTNode*rret = TreeFind(root->right, x);
	if (rret)
	{
     
		return rret;
	}
	return NULL;
}
int TreeMaxDepth(BTNode*root)
{
     
	if (root == NULL)
	{
     
		return 0;
	}
	int LeftDepth = TreeMaxDepth(root->left);
	int Rightdepth = TreeMaxDepth(root->right);
	return LeftDepth > Rightdepth ? LeftDepth + 1 : Rightdepth + 1;
}

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

void TreeDestroy(BTNode**pproot)
{
     
	if (*pproot == NULL)
	{
     
		return;
	}
	TreeDestroy(&(*pproot)->left);
	TreeDestroy(&(*pproot)->right);
	free(*pproot);
	*pproot = NULL;
}
//判断单值树
bool TreeSingle(BTNode*root)
{
     
	if (root == NULL)
	{
     
		return true;
	}
	if (root->left&&root->left->data != root->data)
	{
     
		return false;
	}
	if (root->right&&root->right->data != root->data)
	{
     
		return false;
	}
	return TreeSingle(root->left) && TreeSingle(root->right);
}
//判断是否为对称树
bool _TreeSymmertic(BTNode*left, BTNode*right)
{
     
	if (left == NULL&&right == NULL)
	{
     
		return true;
	}
	if (left == NULL || right == NULL)
	{
     
		return false;
	}
	if (left->data != right->data)
	{
     
		return false;
	}
	return _TreeSymmertic(left->right, right->left);
}

bool TreeSymmertic(BTNode*root)
{
     
	if (root == NULL)
	{
     
		return true;
	}
	return _TreeSymmertic(root->left, root->right);
}
//判断两棵树是否相同
bool TreeSame(BTNode*root1,BTNode*root2)
{
     
	if (root1 == NULL && root2== NULL) 
	{
     
		return true;
	}
	else if (root1 == NULL || root2== NULL)
	{
     
		return false;
	}
	else if (root1->data != root2->data) 
	{
     
		return false;
	}
	else 
	{
     
		return TreeSame(root1->left, root2->left) &&TreeSame(root1->right, root2->right);
	}
}

//判断一棵树为另一棵树的子树
bool TreeSub(BTNode*root, BTNode*subroot)
{
     
	if (root == NULL)
	{
     
		return false;
	}
	if (TreeSame(root, subroot))
	{
     
		return true;
	}
	return TreeSub(root->left,subroot) || TreeSub(root->right,subroot);
}
//判断平衡二叉树
bool _TreeBalance(BTNode*root,int *ph)
{
     
	if (root == NULL)
	{
     
		*ph = 0;
		return true;
	}
	int LeftHeight = 0;
	if (_TreeBalance(root->left, &LeftHeight) == false)
		return false;
	int RightHeight = 0;
	if (_TreeBalance(root->right, &RightHeight) == false)
		return false;
	*ph = fmax(LeftHeight, RightHeight) + 1;
	return abs(LeftHeight - RightHeight) < 2;
}

bool TreeBalance(BTNode*root)
{
     
	if (root == NULL)
	{
     
		return true;
	}
	int height = 0;
	return _TreeBalance(root, &height);
}
int main()
{
     
	BTNode*A = CreateTreeNode('A');
	BTNode*B = CreateTreeNode('B');
	BTNode*C = CreateTreeNode('C');
	BTNode*D = CreateTreeNode('D');
	BTNode*E = CreateTreeNode('E');
	BTNode*F = CreateTreeNode('F');

	A->left = B;
	A->right = C;
	B->left = D;
	C->left = E;
	C->right = F;
	PrevOrder(A);
	printf("\n");
	InOrder(A);
	printf("\n");
	PostOrder(A);
	printf("\n");
	int size = 0;
	TreeSize1(A,&size);
	printf("TreeSize1:%d\n", size);
	printf("TreeSize2:%d\n", TreeSize2(A));
	printf("TreeLeafSize:%d\n", TreeLeafSize(A));
	printf("TreeMaxDepth:%d\n", TreeMaxDepth(A));
	printf("TreeLevelKSize:%d\n", TreeLevelKSize(A,2));
	BTNode*ret=TreeFind(A, 'E');
	printf("TreeFind:%c\n", ret->data);
	printf("TreeSingle:%d\n", TreeSingle(A));
	printf("TreeSymmertic:%d\n", TreeSymmertic(A));
	printf("TreeSame:%d\n", TreeSame(A,A));
	printf("TreeSub:%d\n", TreeSub(A, B));
	printf("TreeBalance:%d\n", TreeBalance(A));
	TreeDestroy(A);
	//A = NULL;
	return 0;
}

后记

好的，这期诚意满满的博客就分享到这里了。在这期文章中，我们介绍了树的基本知识，希望对大家有所帮助。
回到我们文章开头的那张图片，这张图片是我在网上看到的，是一位摄影师的作品，图片中的人是要搬迁的村民，他走时，背走了家里的一棵桃树。故乡不再，他带走了故乡的一棵树。这倒是与三毛的那句如果有来生要做一棵树站成永恒有了奇妙的关联，当故乡已经难以留下，就让树成为永恒吧。