学习目标：

二叉树的深度优先遍历
二叉树的广度优先遍历
二叉树的拷贝和销毁

学习内容：

一、树的相关概念
1、节点的度：一个节点含有的子树的个数。
2、叶节点或终端节点：度为0的节点。
3、树的度：最大的节点的度。
4、节点的层次：从根节点起，根为第一层……（空树的高度为0）
5、树的高度或深度：节点的最大层次。

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

二叉树：每个节点的度不超过2。
完全二叉树：只有最后一层的节点没满。
满二叉树：每个节点的度都是2。
搜索二叉树：每个节点，左子树的值小于根节点，右子树的值大于根节点。
平衡二叉树：符合搜索二叉树的条件，同时左右两边的节点数据比较均匀。
二叉树的性质：
1、若规定根节点的层数为1，则一棵非空二叉树的第i层上最多有2^(i-1)个节点。
2、满二叉树高度h和节点个数N的关系：2^h-1 = N。h = log2 (N+1)。
3、对于任何一棵二叉树，如果度为0其叶节点个数为n0，度为2的分支节点个数为n2，则n0 = n2+1。
4、满二叉树是特殊的完全二叉树，完全二叉树的前h-1层是满的，最后一层节点从左到右必须连续。
5、完全二叉树高度h和节点个数N的关系：2h-1-X = N。h = log2 (N+1+X)，假设缺失的节点数为x。
注意：
在一颗完全二叉树中，度为1的节点，要么为0个，要么为1个。则n = x0 + x1+x2。得n = 2x0 + x1 – 1。叶子节点的个数x0 = (n+1)/2或(n)/2
一颗完全二叉树的节点个数n，与高度h的关系：n = 2^ h -1 -x。x表示最后一层缺少的节点数。x的范围：0~2^(h-1)-1
注意：使用的范围是完全二叉树或满二叉树。

在这里插入图片描述

任何一颗二叉树（以每个节点为开始的二叉树），由三部分构成：
1、根节点
2、左子树
3、右子树
如：A节点的二叉树，分为左子树右子树、B节点的二叉树，分为左子树右子树、D节点的二叉树，分为左子树右子树……

分治算法：分而治之，大问题分成类似子问题，子问题再分成子问题…直到子问题不可再分割。
例如：上面的二叉树
将一个树，以A为节点的树，分成A根节点、以B为节点的左子树、以C为节点的右子树。继续将大问题分解成类似的子问题。将B为节点的左子树，分成B根节点、以D为节点的左子树、以E为节点的右子树。又继续将大问题分解成类似的子问题。分成D根节点、以NULL为节点的左子树、以NULL为节点的右子树。直到子问题不能再分割。因此可以使用递归实现二叉树的遍历。

三、二叉树链式结构的深度优先遍历
在这里插入图片描述
1、前序(根在前面)：当遇到任意一颗二叉树的节点时，先访问根节点，再访问左子树，再访问右子树。
A B D NULL NULL E NULL NULL C NULL NULL
2、中序(根在中间)：当遇到任意一颗二叉树的节点时，先访问左子树，再访问根节点，再访问右子树。
NULL D NULL B NULL E BULL A NULL C NULL
3、后序(根在后面)：当遇到任意一颗二叉树的节点时，先访问左子树，再访问右子树，再访问根节点。
NULL NULL D NULL NULL E B NULL NULL C A
4、代码实现：

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>

//二叉树的前序、中序、后序遍历也叫深度优先遍历。层序遍历也叫广度优先遍历。

typedef char BTDataType;
//定义二叉树的节点
typedef struct BinaryTreeNode
{
    
    
	struct BinaryTreeNode* left;//节点的左子树
	struct BinaryTreeNode* right;//节点的右子树
	BTDataType data;//节点的值
}BTNode;

//前序遍历：根 左子树 右子树
void PrevOrder(BTNode* root)//注意：root表示节点指针，第一次调用指根节点
{
    
    
	if (root == NULL)
	{
    
    
		printf("NULL ");
		return;
	}
	printf("%c ", root->data);//当前节点
	PrevOrder(root->left);//当前节点的左子树
	PrevOrder(root->right);//当前节点的右子树
}

//中序遍历：左子树 根 右子树
void InOrder(BTNode* root)//注意：root表示节点指针，第一次调用指根节点
{
    
    
	if (root == NULL)
	{
    
    
		printf("NULL ");
		return;
	}

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

//后序遍历：左子树 右子树 根
void PostOrder(BTNode* root)//注意：root表示节点指针，第一次调用指根节点
{
    
    
	if (root == NULL)
	{
    
    
		printf("NULL ");
		return;
	}

	PostOrder(root->left);
	PostOrder(root->right);
	printf("%c ", root->data);
}
int main()
{
    
    
	BTNode* A = (BTNode*)malloc(sizeof(BTNode));
	A->data = 'A';
	A->left = NULL;
	A->right = NULL;

	BTNode* B = (BTNode*)malloc(sizeof(BTNode));
	B->data = 'B';
	B->left = NULL;
	B->right = NULL;

	BTNode* C = (BTNode*)malloc(sizeof(BTNode));
	C->data = 'C';
	C->left = NULL;
	C->right = NULL;

	BTNode* D = (BTNode*)malloc(sizeof(BTNode));
	D->data = 'D';
	D->left = NULL;
	D->right = NULL;

	BTNode* E = (BTNode*)malloc(sizeof(BTNode));
	E->data = 'E';
	E->left = NULL;
	E->right = NULL;

	A->left = B;
	A->right = C;
	B->left = D;
	B->right = E;

	PrevOrder(A);
	printf("\n");
	InOrder(A);
	printf("\n");
	PostOrder(A);
	printf("\n");

	return 0;
}

5、递归展开图：
在这里插入图片描述

四、二叉树链式结构的广度优先遍历

思路：使用队列实现层序遍历

//二叉树的层序遍历，也叫广度优先遍历。即从根节点开始一层一层的遍历

typedef char BTDataType;
typedef struct BinaryTreeNode
{
    
    
	struct BinaryTreeNode* left;//节点的左子树
	struct BinaryTreeNode* right;//节点的右子树
	BTDataType data;//节点的值
}BTNode;

#include "Queue.h"//包含头文件

void LevelOrder(BTNode* root)//注意：root仅仅指根节点
{
    
    
	//核心思路：从根节点开始入队，每次当上一层节点出队(数据)的时候，将该出节点的下一层子节点入队
	Queue q;
	QueueInit(&q);
	if (root != NULL)
	{
    
    
		QueuePush(&q, root);//将根节点入队列
	}
	//遍历
	while (!QueueEmpty(&q))
	{
    
    
		BTNode* front = QueueFront(&q);//保存队头的节点(指针)
		QueuePop(&q);//从队列中取出指针(二叉树节点)元素，出队列free删除的是队列节点指针，而节点的数据域还在。
		//二叉树的节点并没有删除，删除的是队列的节点
		printf("%c ", front->data);

		//将下一层的节点入队
		if (front->left != NULL)
		{
    
    
			QueuePush(&q, front->left);
		}
		if (front->right != NULL)
		{
    
    
			QueuePush(&q, front->right);
		}
	}
	printf("\n");
	QueueDestroy(&q);
}

五、求二叉树的节点个数或叶子节点的个数

typedef char BTDataType;
typedef struct BinaryTreeNode
{
    
    
	struct BinaryTreeNode* left;//节点的左子树
	struct BinaryTreeNode* right;//节点的右子树
	BTDataType data;//节点的值
}BTNode;

//1、求二叉树节点的个数
//方法一：遍历计数
//将size定义为全局变量
int size = 0;
void  BinaryTreeSize(BTNode* root)//注意：root表示节点指针，第一次调用指根节点
{
    
    
	if (root == NULL)
	{
    
    
		return;
	}
	else
	{
    
    
		++size;//当前节点
	}
	BinaryTreeSize(root->left);//当前节点的左子树
	BinaryTreeSize(root->right);//当前节点的右子树
}

//方法二：遍历计数
//将size定义为静态变量
int BinaryTreeSize(BTNode* root)//注意：root表示节点指针，第一次调用指根节点
{
    
    
	if (root == NULL)
	{
    
    
		return;
	}
	static int size = 0;
	++size;

	BinaryTreeSize(root->left);
	BinaryTreeSize(root->right);

	return size;
}
//注意：以上两种方法，在多线程并发执行时，并行去计算两棵树，会出现干扰
//因此以上两个方法，不是线程安全的。

//方法三：传参
void  BinaryTreeSize(BTNode* root,int *psize)//注意：root表示节点指针，第一次调用指根节点
{
    
    
	if (root == NULL)
	{
    
    
		return;
	}
	else
	{
    
    
		++(*psize);//解引用再++,相当于++size
	}
	BinaryTreeSize(root->left,psize);
	BinaryTreeSize(root->right,psize);
}

//方法四：分治算法
//将一棵树分成根，左子树，右子树
//该树的节点可以计算为：先计算左子树的节点个数，再计算右子树的节点个数,再计算根节点(1)。
//一颗树的节点个数：左子树+右子树+1
//左子树又可以继续再分成根，左子树，右子树，返回(左子树的节点个数+右子树的节点个数+1)......直到不可再分，返回0
int BinaryTreeSize(BTNode* root)//注意：root表示节点指针，第一次调用指根节点
{
    
    
	return root == NULL ? 0 : BinaryTreeSize(root->left) + BinaryTreeSize(root->right) + 1;//后序遍历的思维
}

//2、求叶子节点的个数
//方法1：遍历计数，如果左右子树都为NULL，则size++
//方法2：分治算法
//将一棵树分成根，左子树，右子树
//该树的节点可以计算为：先判断根左右子树是否为空。再计算左子树的叶子节点个数，再计算右子树的叶子节点个数。
//一颗树的叶子节点个数：左子树+右子树
//左子树又可以继续再分成根，左子树，右子树，返回(左子树的叶子节点个数+右子树的叶子节点个数)......直到不可再分，返回0
int BinaryTreeLeafSize(BTNode* root)//注意：root表示节点指针，第一次调用指根节点
{
    
    
	if (root == NULL)//节点为空
	{
    
    
		return 0;
	}
	if (root->left == NULL && root->right == NULL)//当前节点
		return 1;
	//当以上两个都不满足，也就是当前节点还有子节点。既不是空，也不是叶子节点
	return BinaryTreeLeafSize(root->left) + BinaryTreeLeafSize(root->right);//当前节点的左子树、当前节点的右子树
}

六、拷贝和销毁二叉树

struct TreeNode
{
    
    
	struct TreeNode* left;//节点的左子树
	struct TreeNode* right;//节点的右子树
	int data;//节点的值
};
//思路：先拷贝左子树，再拷贝右子树，再根节点，采用后序遍历

//拷贝二叉树
struct TreeNode* CopyTree(struct TreeNode* root)//这里是传值调用
{
    
    //注意：root表示节点指针，第一次调用指根节点
	if (root == NULL)
	{
    
    
		return;
	}
	struct TreeNode* left = CopyTree(root->left);//当前节点的左子树
	struct TreeNode* right = CopyTree(root->right);//当前节点的右子树

	//创建根结点
	struct TreeNode* newroot = (struct TreeNode*)malloc(sizeof(struct TreeNode));
	if (newroot == NULL)
		return NULL;
	newroot->data = root->data;
	newroot->left = root->left;
	newroot->right = root->right;

	return newroot;
}

//由于先销毁根节点，就无法销毁左子树，和右子树，因此消除一个树，采用后序遍历

//思想：分治算法
//1、当前树的根节点为空，直接返回
//2、当前树的根节点非空，先释放左，右子树，再释放根节点（左右子树继续分解成以上两步）
//继续分解成，判断当前树的根是否为空，释放左，右子树，再释放根节点
void DestroyTree(struct TreeNode* *proot)//或者C++改为引用DestroyTree(struct TreeNode*& root)
{
    
    //注意：root表示节点指针的地址，不仅仅指根节点的地址
	if (*proot == NULL)
	{
    
    
		return;
	}
	DestroyTree(&((*proot)->left));
	DestroyTree(&((*proot)->right));
	free(*proot);
	*proot = NULL;//改变外边的root，则用*root，改变*root，则用**root
}

【数据结构和算法】 - 二叉树

学习目标：

学习内容：

猜你喜欢