数据结构（四）：二叉树

待我称王封你为后i 2021-09-07 15:24 407阅读 0赞

### 文章目录 ###

*  一、树的概念及结构
 *   *  1.树的概念
     *  2.树的表示方法
 *  二、二叉树
 *   *  1.二叉树概念及结构
     *   *  概念
         *  结构
     *  2.二叉树的实现
     *   *  （1）二叉树的四种遍历方式
         *  （2）二叉树第k层的结点个数
         *  （3）一棵树的结点总个数
         *  （4）一棵树的叶子结点个数
         *  （5）在树中查找值为x的结点
 *  感谢阅读，如有错误请批评指正

--------------------

# 一、树的概念及结构 #

## 1.树的概念 ##

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

有一个特殊的结点，称为根结点，根节点没有前驱结点。除根节点外，其余结点被分成m(m > 0)个互不相交的集合T1、T2、…… 、Tm，其中每一个集合Ti(1 <= i <= m)又是一棵结构与树类似的子树。每棵子树的根结点有且只有一个前驱，但可以有0个或多个后继。

由此可知，树是递归定义的。

--------------------

下面是一个简单的树。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MTk4MzYwNA_size_16_color_FFFFFF_t_70_pic_center]  
图中根节点就是没有父结点的结点，叶子结点就是没有子节点的结点。

--------------------

还要注意：树的子树是不相交的；除了根节点外，每个结点有且仅有一个父结点。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MTk4MzYwNA_size_16_color_FFFFFF_t_70_pic_center 1]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MTk4MzYwNA_size_16_color_FFFFFF_t_70_pic_center 2]

--------------------

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MTk4MzYwNA_size_16_color_FFFFFF_t_70_pic_center 3]

下面介绍一些与树相关的概念（以上面的树为例）：

（1）结点的度：一个节点含有的子树的个数称为该节点的度；如上图：A的为6，即B、C、D、E、F、G。

（2）叶结点：度为0的节点称为叶结点；如上图：B、C、H、I…等为叶结点。

（3）双亲结点或父结点：若一个节点含有子结点，则这个结点称为其子结点的父结点；如上图：A是B的父结点。

（4）孩子结点或子结点：一个结点含有的子树的根结点称为该结点的子结点；如上图：B是A的孩子节点。

（5）兄弟结点：具有相同父结点的结点互称为兄弟结点； 如上图：B、C是兄弟结点。

（6）树的度：一棵树中，最大的节点的度称为树的度； 如上图：树的度为6。

（7）结点的层次：从根开始定义起，根为第1层，根的子结点为第2层，以此类推。

（8）树的高度或深度：树中结点的最大层次； 如上图：树的高度为4。

（9）节点的祖先：从根到某一结点所经分支上的所有结点；如上图：D、A是H的祖先；A是所有结点的公共祖先。

（10）子孙：以某节点为根的子树中任一节点都称为该节点的子孙。如上图：所有节点都是A的子孙。

（11）森林：多棵互不相交的树的集合称为森林。

--------------------

## 2.树的表示方法 ##

树由于不是线性结构，所以相对线性表，要存储、表示就相对麻烦，实际中树有很多种表示方式，如：双亲表示法，孩子表示法、孩子兄弟表示法等等。这里简单地介绍其中最常用的孩子兄弟表示法。

孩子兄弟表示法就是用孩子结点来找到下一层的结点，用兄弟结点来找到这一层其余的结点，结构如下。

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MTk4MzYwNA_size_16_color_FFFFFF_t_70_pic_center 4]

--------------------

# 二、二叉树 #

## 1.二叉树概念及结构 ##

### 概念 ###

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

二叉树的特点：

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

### 结构 ###

特殊的二叉树：

（1）满二叉树

每一层的结点数都达到最大值，则这个二叉树就是满二叉树。  
也就是说，如果一个二叉树的层数为K（根节点是第1层），且结点总数是(2^k) -1 ，则它就是满二叉树。  
![在这里插入图片描述][20210506135638250.png_pic_center]

--------------------

（2）完全二叉树

完全二叉树是由满二叉树而引出来的。对于深度为K的、有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树。 满二叉树是一种特殊的完全二叉树。  
也就是说：完全二叉树的叶子结点只能出现在最下层和次下层，且最下层的叶子结点从左到右连续；前K-1层是满的二叉树。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MTk4MzYwNA_size_16_color_FFFFFF_t_70_pic_center 5]

--------------------

非完全二叉树

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MTk4MzYwNA_size_16_color_FFFFFF_t_70_pic_center 6]

--------------------

## 2.二叉树的实现 ##

二叉树可通过线性结构或链式结构实现，本文使用链式结构，线性结构将在[数据结构（五）：堆][Link 1]中具体实现。

二叉树的结构如下：

typedef int BTData;
    typedef struct BinaryTree
    { 
    	BTData x;//数据域
    	struct BinaryTree* left;//左子树的根节点
    	struct BinaryTree* right;//右子树的根节点
    }BTNode;

--------------------

### （1）二叉树的四种遍历方式 ###

前序遍历：先访问一棵树的根节点，再访问左子树，最后访问右子树。  
中序遍历：先访问一棵树的左子树，再访问根节点，最后访问右子树。  
后序遍历：先访问一棵树的左子树，再访问右子树，最后访问根节点。  
层序遍历：首先访问第一层的根结点，然后从左到右访问第2层上的节点，接着访问第三层的结点，以此类推，自上而下，自左至右逐层访问树的结点的过程就是层序遍历。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MTk4MzYwNA_size_16_color_FFFFFF_t_70_pic_center 7]  
如上面这棵树，对它进行四种遍历：

前序遍历：A B D NULL NULL NULL C E NULL NULL F NULL NULL  
中序遍历：NULL D NULL B NULL A NULL E NULL C NULL F NULL  
后序遍历：NULL NULL D NULL B NULL NULL E NULL NULL F C A  
层序遍历：A B C D NULL E F NULL NULL NULL NULL NULL NULL

--------------------

下面用代码实现

代码如下（示例）：

//前序遍历：根 左子树 右子树
    void PrevOrder(BTNode* root)
    { 
    	//root为空是递归的终止条件
    	if (root == NULL)
    	{ 
    		printf("NULL ");
    		return;
    	}
    
    	printf("%c ", root->x);//访问根，这里进行打印操作，也可进行其他操作
    	PrevOrder(root->left);//递归访问左子树
    	PrevOrder(root->right);//递归访问右子树
    }

//中序遍历：左子树 根 右子树
    void InOrder(BTNode* root)
    { 
    	if (root == NULL)
    	{ 
    		printf("NULL ");
    		return;
    	}
    
    	InOrder(root->left);
    	printf("%c ", root->x);
    	InOrder(root->right);
    }

//后序遍历：左子树 右子树 根
    void PostOrder(BTNode* root)
    { 
    	if (root == NULL)
    	{ 
    		printf("NULL ");
    		return;
    	}
    
    	PostOrder(root->left);
    	PostOrder(root->right);
    	printf("%c ", root->x);
    }

--------------------

由上面的三种遍历过程，结合二叉树的结构可知，二叉树的许多问题都可以变成对当前结点的处理和对左右子树的处理，当遇到空结点或达到一定条件时结束。这是典型的递归思想，递归也是二叉树这里用的比较多的思路。

--------------------

层序遍历的过程较为复杂，需要借助队列来实现  
开始先让根节点入队，之后每次让队头的结点出队，并将队头结点的左右结点入队，直到队头结点的左右结点均为空。这是不再入队，将队列中的数据依次出队，最后得到的就是层序遍历的结果。

下面以刚才的二叉树为例，给出了层序遍历的过程。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MTk4MzYwNA_size_16_color_FFFFFF_t_70_pic_center 8]

--------------------

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MTk4MzYwNA_size_16_color_FFFFFF_t_70_pic_center 9]

--------------------

void TreeLevelOrder(BTNode* root)
    { 
    	Queue q;
    	QueueInit(&q);
    	if (root != NULL)//把整个树的根节点入队
    		QueuePush(&q, root);
    	while (!QueueEmpty(&q))
    	{ 
    		//保存当前的队头
    		BTNode* front = QueueFront(&q);
    		QueuePop(&q);
    		printf("%c ", front->x);//打印
    		//如果队头的左右结点不为空，左右结点入队
    		if (front->left != NULL)
    		{ 
    			QueuePush(&q, front->left);
    		}
    		if (front->right != NULL)
    		{ 
    			QueuePush(&q, front->right);
    		}
    	}
    
    	QueueDestroy(&q);
    }

--------------------

### （2）二叉树第k层的结点个数 ###

（这里规定root节点是第1层）

从root开始计数第k层的结点个数  
= 从root->left开始计数第k-1层的结点个数 + 从root->right开始计数第k-1层的结点个数  
…  
直到到达第k层时，如果一个结点不是空，那么它就算是第k层的一个结点。  
这仍是递归的思想。

int TreeKLevelSize(BTNode* root, BTData k)
    { 
    	if (root == NULL)
    		return 0;
    
    	//root != NULL
    	if (k == 1)
    		return 1;
    
    	return TreeKLevelSize(root->left, k - 1) + TreeKLevelSize(root->right, k - 1);
    }

--------------------

### （3）一棵树的结点总个数 ###

一棵树的结点总个数为：  
（1）如果这个结点是空，这个结点的总个数为0  
（2）如果这个结点不是空，这个结点的总个数就是这个结点加上它左右子树的结点个数

int TreeSize2(BTNode* root)
    { 
    	//结点是空则为0，否则为左右子树的结点个数加上1（这个不为空的结点是1个结点）
    	return root == NULL ? 0 : (TreeSize2(root->left) + TreeSize2(root->right) + 1);
    }

--------------------

### （4）一棵树的叶子结点个数 ###

思路仍是先检验当前结点是否为空，是则不计数，若非空则检验它是否是叶子，如果是则个数加1，若不是叶子则去它的左右子树去找叶子结点。

int LeafSize(BTNode* root)
    { 
    	if (root == NULL)//空结点不计数
    		return 0;
    	else if (root->left == NULL && root->right == NULL)//是叶子结点计数
    		return 1;
    	else
    		return LeafSize(root->left) + LeafSize(root->right);
    }

--------------------

### （5）在树中查找值为x的结点 ###

BTNode* TreeFind(BTNode* root, BTData x)
    { 
    	BTNode* leftRet = NULL;
    	BTNode* rightRet = NULL;
    
    	if (root == NULL)//是空返回
    		return NULL;
    
    	if (root->x == x)//找到
    		return root;
    
    	//代码运行到这里说明root不是空，且root的值不为x
    	leftRet = TreeFind(root->left, x);//去root的左子树找
    	if (leftRet != NULL)//leftRet不是空说明找到了
    		return leftRet;
    	
    	//代码运行到这里说明root不是空，且root的值不为x，且root的左子树中没有值为x的结点
    	rightRet = TreeFind(root->right, x);
    	if (rightRet != NULL)
    		return rightRet;
    
    	//代码运行到这里说明root不是空，且root的值不为x，且root的左右子树中均没有值为x的结点
    	//说明树中没有值为x的结点，返回空
    	return NULL;
    }

--------------------

# 感谢阅读，如有错误请批评指正 #

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MTk4MzYwNA_size_16_color_FFFFFF_t_70_pic_center]: /images/20210813/17bdab6d0632468aba539922b524a09c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MTk4MzYwNA_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20210813/b8ab8890797f4ca5aef6a49a6df15d65.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MTk4MzYwNA_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20210813/9678c8763b5a4170a8b0bb2ca0f46880.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MTk4MzYwNA_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20210813/6262b20db0ee4189a01410dfa381482b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MTk4MzYwNA_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20210813/ec0c739f1573468392843fcf2370db89.png
[20210506135638250.png_pic_center]: /images/20210813/8beea28c342c49c9b49354cb7a2e80bc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MTk4MzYwNA_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20210813/a5caa75f799743ec95c45d59f87181da.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MTk4MzYwNA_size_16_color_FFFFFF_t_70_pic_center 6]: /images/20210813/e61b5d9e736c46d6bda576059b566bca.png
[Link 1]: https://blog.csdn.net/weixin_51983604/article/details/116520674
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MTk4MzYwNA_size_16_color_FFFFFF_t_70_pic_center 7]: /images/20210813/8def29da74954faaa73e98a4db5d3f17.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MTk4MzYwNA_size_16_color_FFFFFF_t_70_pic_center 8]: /images/20210813/62afe258b4f442fdbe52abb97990c4cc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MTk4MzYwNA_size_16_color_FFFFFF_t_70_pic_center 9]: /images/20210813/df36b3ae14434202b788b9acd6e58508.png