【初阶】带你看懂二叉树（附图解）

准备

博主:大大怪先森(记得关注哦!）
编程环境：vs2013

---

提示：本文内容基于C语言主要讲述数据结构二叉树的问题！！！

---

前言

提示：本文要记录的大概内容：
二叉树是数据结构当中一种重要的存储方式
本文将简单讲述二叉树的存储方法和相关树的问题！！！

---

提示：以下是本篇文章正文内容

一、二叉树和树

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; // 结点中的数据域
};

1.3二叉树的概念及其结构

1.3.1二叉树的概念

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

• 1. 或者为空
• 2. 由一个根节点加上两棵别称为左子树和右子树的二叉树组成
     
     从上图可以看出：

1. 二叉树不存在度大于2的结点
2. 二叉树的子树有左右之分，次序不能颠倒，因此二叉树是有序树
   注意：对于任意的二叉树都是由以下几种情况复合而成的：
   

1.3.2 现实生活中的二叉树

作为一个程序员，当看到这棵树的第一反应，我相信就是：哎，，，这不是一颗二叉树吗？果然现实中处处都是知识

1.3.3特殊的二叉树

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

1.4二叉树的相关概念

1.4.1二叉树的性质

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

1.4.2二叉树的存储结构

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

1.4.2.1顺序存储

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

1.4.2.2链式存储

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

1.5二叉树和树，森林之间的相互转化

二、二叉树经典例题

1.前序，中序，后序遍历二叉树

此处以中序的内容举例
代码如下（示例）：

//中序遍历二叉树
void InOrder(BTNode* root)
{
	if (root == NULL){
		printf("NULL ");
		return;
	}

	InOrder(root->lchild);
	printf("%C ", root->data);
	InOrder(root->rchild);
}

2.二叉树求叶子节点的个数

代码如下（示例）：

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

3.二叉树中查找值为x的节点

//二叉树查找值为X的节点
BTNode* BinaryTreeFind(BTNode* root, STDataType x)
{
	if (root == NULL)
		return NULL;
	if (root->data == x)
		return root;
	struct Tree* left = BinaryTreeFind(root->lchild, x);
	if (left != NULL)
		return left;
	struct Tree* right = BinaryTreeFind(root->rchild, x);
	if (right != NULL)
		return right;
	return NULL;
}

4.二叉树中第k层的个数

//二叉树第k层的节点的个数
int BinaryTreeLevelSize(BTNode* root,int k)
{
	if (root == NULL)
	{
		return 0;
	}
	if (k == 1)
	{
		return 1;
	}
	// root不等空，k也不等于1，说明root这颗树的第k节点在子树里面
	// 转换成求左右子树的第k-1等的节点数量
	return BinaryTreeLevelSize(root->lchild, k - 1) + 
		BinaryTreeLevelSize(root->rchild, k - 1);
}

5.二叉树中深度

// 二叉树深度/高度
int BinaryTreeDepth(BTNode* root)
{
	if (root == NULL)
		return 0;

	int leftDepth = BinaryTreeDepth(root->lchild);

	int rightDepth = BinaryTreeDepth(root->rchild);

	return leftDepth > rightDepth ? leftDepth + 1 : rightDepth + 1;
}

---

三、大堆和小堆

3.1堆的概念和结构

如果有一个关键码的集合K = {k1 ，k2 ， k3，…kn }，把它的所有元素按完全二叉树的顺序存储方式存储
在一个一维数组中，并满足： ki<= k(2K + 1）且ki <= k(2 k + 2) ( ki>= k(2K + 1）且ki >= k(2 k + 2)) i = 0，1，2…，则称为小堆(或大堆)。将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。

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

3.2大堆和小堆的建立

3.2.1大小堆的向上和向下调整

//大堆树：向上调整
void AdjustUp(int* a, int child)
{
	int parent = (child - 1) / 2;
	while (child)
	{
		if (a[child] < a[parent])
		{
			Swap(&a[child], &a[parent]);
		}
		else
		{
			break;
		}
		child = parent;
		parent = (child - 1) / 2;
	}
}
//小堆树：向下调整
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 (child < n && a[child] < a[parent])//如果想要更改为大堆只需要将<更改为>即可
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}

}

此处以一个小堆的更换来演示小堆的工作模式（AdjustDown函数）：

3.3topk问题

对于小堆和大堆我相信各位大大一定有了一定得了解，那么大小堆究竟有什么作用？
我们接着往下看
思考：在n个数中选出最大的k个数？

思路方法：
1.使用前k个数建立一个k个数的小堆
2.剩下的n - k个数与小堆的堆顶进行比较如果比堆顶大就进行交换。
3.最后堆里面的就是最大的k个数

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

typedef struct Tree
{
	STDataType data;
	struct Tree* lchild;
	struct Tree* rchild;
}BTNode;
//初始化节点
void HeapInit(HP* hp)
{
	assert(hp);
	hp->a = NULL;
	hp->size = hp->capacity = 0;
}

//交换大小
void Swap(int* a, int* b)
{
	int tmp = *a;
	*a = *b;
	*b = tmp;
}
void AdjustUp(int* a, int child)
{
	int parent = (child - 1) / 2;
	while (child)
	{
		if (a[child] < a[parent])
		{
			Swap(&a[child], &a[parent]);
		}
		else
		{
			break;
		}
		child = parent;
		parent = (child - 1) / 2;
	}
}
//在N个数中找到最大的k个数
void HeapPush(HP* hp, HPDataType x)
{
	assert(hp);
	int parent = 0;
	if (hp->size == hp->capacity)
	{
		int Nowcapacity = hp->capacity == 0 ? 4 : hp->capacity * 2;
		struct Heap* tmp = (struct Heap*)realloc(hp->a,sizeof(struct Heap) * Nowcapacity);
		if (tmp == NULL)
		{
			printf("realloc fail");
		}
		hp->a = tmp;
		hp->capacity = Nowcapacity;
	}
	hp->a[hp->size] = x;
	hp->size++;
	AdjustUp(hp->a,hp->size - 1);
}
void HeapPrintTopk(int* a, int n,int k)
{
	HP hp;
	HeapInit(&hp);
	//创建一个小堆
	for (int i = 0; i < k; i++)
	{
		HeapPush(&hp, a[i]);
	}
	//剩下的N - K 个数跟堆顶的元素数据比较，比它大，就替换他进堆
	for (int i = k; i < n - k; i++)
	{
		if (a[i] > HeapTop(&hp))
		{
			hp.a[0] = a[i];
			AdjustDown(hp.a, hp.size, 0);//AdjustDown()函数此处不在写入，可以参照上面。
		}
	}
}

3.4堆排序

void HeapSort(int* a, int n)
{
	for (int i = (n - 1 - 1) / 2; i >= 0; i--)
	{
		//利用向下排序建立大堆选出最大的数
		AdjustDown(a, n, i);
	}
	//依次选数，调堆O(N * log ^ n)
	for (int end = n - 1; end > 0; end--)
	{
		//大堆就是最大的树与最后一个数交换位置
		Swap(&a[0], &a[end]); 
		//再进行一次向下大堆调整
		AdjustDown(a, end, 0);
	}
}

以一个数组：18 16 56 23 17 65 为例
利用向下排序建立大堆选出最大的数（图解）

大堆就是最大的树与最后一个数交换位置
再进行一次向下大堆调整于是将最大的数交换到数据最后的位置

总结

二叉树问题的大多数的解决方法就是基于左右孩子的递归问题，当处理问题我们应该尽可能就
去解决左右子树的问题。

结语

希望本篇文章能给各位带来帮助，如有不足还请指正！！！
码字不易，各位大大给个收藏点赞吧！！！