链式二叉树

本文详细介绍了链式二叉树的结构,包括手动创建、四种遍历方式(前序、中序、后序、层序)以及如何判断是否为完全二叉树。此外,还探讨了DFS和BFS的基本概念及其在二叉树中的应用。
摘要由CSDN通过智能技术生成

前言

本章将重点讲解链式二叉树的四种遍历方式。

一、链式二叉树

1、引入链式二叉树

我们知道完全二叉树可以使用堆存储,那非完全二叉树?

非完全二叉树不适合用堆来存储,因为浪费空间,所以非完全二叉树使用链式存储。

2、链式二叉树的意义

  1. 链式二叉树并没有实际的意义,即链式二叉树我们不学增删查改。
  2. 所以学习链式二叉树的意义是:
    • 学习它的结构,为后续学习打基础,例如搜索二叉树。
    • OJ题会考察链式二叉树的结构

3、手动创建链式二叉树

在学习链式二叉树的四种遍历之前,我们需要创建一棵二叉树,但是链式二叉树的实现有点复杂,所以这里我们先手动创建一棵链式二叉树。

手动创建一颗链式二叉树,只需要按照它的逻辑结构将节点连接在一起即可。
在这里插入图片描述
代码实现:

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

//结点数据类型
typedef int BTDataType;

//链式二叉树的结点
typedef struct BinaryTreeNode
{
	struct BinaryTreeNode* left;//左子树
	struct BinaryTreeNode* right;//右子树
	BTDataType data;
}BTNode;

//初始化结点
BTNode* BuyNode(BTDataType x)
{
	BTNode* node = (BTNode*)malloc(sizeof(BTNode));
	if (node == NULL)
	{
		perror("malloc fail");
		return NULL;
	}

	node->data = x;
	node->left = NULL;
	node->right = NULL;

	return node;
}

//手动创建一棵链式二叉树
BTNode* CreatTree()
{
	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;
}

tip:后序的四种遍历均是以此二叉树为例做讲解的。

二、链式二叉树四种遍历

在学习这四种遍历之前我们先回顾下二叉树结构:

  1. 空树
  2. 非空:根节点,根节点的左子树、根节点的右子树组成的。

tip:二叉树定义是递归式的,任何一棵二叉树都可以将其分为根、左子树、右子树。

1、前序遍历

  • 遍历顺序

前序遍历(也叫先根遍历):遍历顺序为,根 -> 左子树 -> 右子树。

  • 思路

递归实现:因为二叉树定义是递归式的,任何一棵(非空)二叉树都可以分为根、左子树、右子树,所以我们可以通过递归实现前序遍历,只需控制遍历的顺序即可。

  • 图示

在这里插入图片描述

  • 代码实现
//前序遍历:根->左子树->右子树
void PerOrder(BTNode* root)
{
	if (NULL == root){
		printf("NULL ");
		return;
	}
	printf("%d ", root->data);
	PerOrder(root->left);
	PerOrder(root->right);
}
  • 代码逻辑递归图

在这里插入图片描述
递归理解:

  • 递——递推,即调用自己,创建函数栈帧
  • 归——回归,函数结束,栈帧销毁(把空间还给操作系统)

2、中序遍历

  • 遍历顺序

中序遍历(也叫中根遍历):遍历顺序为,左子树 -> 根 -> 右子树。

  • 思路

递归实现:因为二叉树定义是递归式的,任何一棵(非空)二叉树都可以分为根、左子树、右子树,所以我们可以通过递归实现中序遍历,只需控制遍历的顺序即可。

  • 图示

在这里插入图片描述

  • 代码实现
//中序遍历:左子树->根->右子树
void InOrder(BTNode* root)
{
	if (NULL == root){
		printf("NULL ");
		return;
	}
	InOrder(root->left);
	printf("%d ", root->data);
	InOrder(root->right);
}
  • 代码逻辑递归图

在这里插入图片描述
tip:中序遍历第一个一定为空。

3、后序遍历

  • 遍历顺序

后序遍历(也叫后根遍历):遍历顺序为,左子树 -> 右子树 -> 根。

  • 思路

递归实现:因为二叉树定义是递归式的,任何一棵(非空)二叉树都可以分为根、左子树、右子树,所以我们可以通过递归实现后序遍历,只需控制遍历的顺序即可。

  • 图示

在这里插入图片描述

  • 代码实现
void PostOrder(BTNode* root)
{
	if (NULL == root){
		printf("NULL ");
		return;
	}
	PostOrder(root->left);
	PostOrder(root->right);
	printf("%d ", root->data);
}
  • 代码逻辑递归图

在这里插入图片描述
tip:后序遍历与中序遍历一样,第一个一定为空。

总结

前中后三种遍历的递归过程一样,只是访问根的时机不同。

二叉树的逻辑递归图:在这里插入图片描述

4、层序遍历

  • 遍历顺序

层序遍历:设二叉树的根节点所在层数为1,层序遍历就是从所在二叉树的根节点出发,首先访问第一层的树根节点,然后从左到右访问第二层上的节点,接着是第三层的结点,以此类推,自上而下,自左至右逐层访问树的节点的过程就是层序遍历。

  • 思路

队列实现:利用队列先进先出的性质,出上一层,带入下一层。

  1. 树不为空,首先把根结点入队列
  2. 队列不为空,再将根结点出队列,根的左右孩子入队列(注:入队列时,需要判断不为空,才能入队列)——即出上一层,带入下一层
  3. 依次类推,当队列为空时,即层序遍历结束。

tip:队列中我们存储树节点这个结构体的指针。(1、节约内存;2、树节点入队列时需要作为参数压栈,压栈有时间和空间上的系统开销)

  • 图示

在这里插入图片描述

  • 代码实现
//层序遍历:队列的经典应用——出上一层,带入下一层
void LevelOrder(BTNode* root)
{
	Queue q;
	QueueInit(&q);
	//1、树不为空,首先把根节点入队列
	if (root)
	{
		QueuePush(&q, root);
	}
	//2、队列不为空,根出,带入左右孩子
	while (!QueueEmpty(&q))
	{
		//根出,遍历
		BTNode* front = QueueFront(&q);
		QueuePop(&q);
		printf("%d ", front->data);
		//带入左右孩子,注意不为空才能带入
		if (front->left)
		{
			QueuePush(&q, front->left);
		}
		if (front->right)
		{
			QueuePush(&q, front->right);
		}
	}
	QueueDesttroy(&q);
}

5、判断一颗二叉树是否为完全二叉树

  • 概念

完全二叉树:对于深度为K的,有n个结点的二叉树,按层序编号,当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点——对应时称之为完全二叉树。在这里插入图片描述

  • 思路

完全二叉树按层序走,它的非NULL结点是连续的

  1. 树不为空,首先把根结点入队列
  2. 队列不为空且根不为空时,根结点出队列,带入根的左右孩子(注:与层序遍历不同的是,空节点也入队列)
  3. 判断队列中的结点是否全为空,如果全为NULL就是完全二叉树,如果有非空就不是完全二叉树。
  • 图示

在这里插入图片描述

  • 代码实现
// 判断二叉树是否是完全二叉树
bool BinaryTreeComplete(BTNode* root)
{	
	Queue q;
	QueueInit(&q);
	//1、根不为空,首先根入队列
	if (root)
	{
		QueuePush(&q, root);
	}
	//2、队列不为空且根不为空,根出带入左右孩子
	while (!QueueEmpty(&q))
	{
		//根出
		BTNode* front = QueueFront(&q);//获取队头元素
		QueuePop(&q);//出队列
		//根不为空,带入左右孩子,为空结束循环
		if (front)
		{
			QueuePush(&q, front->left);
			QueuePush(&q, front->right);
		}
		else
		{
			break;
		}
	}
	//3、判断队列元素是否全为空
	while (!QueueEmpty(&q))
	{
		BTNode* front = QueueFront(&q);
		QueuePop(&q);
		//判断是否为空
		if (front)
		{
			//有非空,则该二叉树不是完全二叉树
			QueueDesttroy(&q);
			return false;
		}
	}
	//全为空,则该二叉树是完全二叉树
	QueueDesttroy(&q);
	return true;
}

6、按照前序遍历的数组创建二叉树

  • 思路

递归实现:按照前序遍历创建二叉树就是根->左子树->右子树。

  1. 递推时创建:按照根->左子树->右子树创建,遇到空返回
  2. 回归时链接
  • 代码实现
typedef struct BinaryTreeNode1
{
	struct BinaryTreeNode1* left;
	struct BinaryTreeNode1* right;
	char val;
}BTNode1;

//通过前序遍历的数组"ABD##E#H##CF##G##"构建二叉树
BTNode1* BinaryTreeCreate(char* a, int* pi)
{
	//先序遍历创建——按照根->左->右顺序创建
	//为'#'时,代表空树,返回空
	if ('#' == a[*pi])
	{
		//每创建一个结点,下标就往后++
		(*pi)++;
		return NULL;
	}
	//创建根
	BTNode1* root = (BTNode1*)malloc(sizeof(BTNode1));
	root->val = a[(*pi)++];
	//创建左子树
	root->left = BinaryTreeCreate(a, pi);
	//创建右子树
	root->right = BinaryTreeCreate(a, pi);
	return root;
}

tip:因为递归需要改变下标,所以下标参数是输出型参数。

7、销毁二叉树

  • 思路

销毁二叉树也很简单,就是遍历二叉树,遍历一个结点销毁一个结点,问题在于选择哪种遍历?

选择前中两种遍历方式销毁都有一个问题,那就是先销毁了根,就找不到孩子呢,需要保存孩子的位置,麻烦。

所以销毁二叉树,就是典型的后序遍历的应用。

  • 代码实现
// 二叉树销毁
void BinaryTreeDestory(BTNode* root)
{
	//典型的后序遍历应用——因为前中两种遍历都有一个问题,在销毁根之前需要保存孩子结点的位置
	if (NULL == root)
	{
		return;
	}
	BinaryTreeDestory(root->left);
	BinaryTreeDestory(root->right);
	free(root);//记得在外将其置为空
}

8、总代码

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

//结点数据类型
typedef int BTDataType;

//链式二叉树的结点
typedef struct BinaryTreeNode
{
	struct BinaryTreeNode* left;//左子树
	struct BinaryTreeNode* right;//右子树
	BTDataType data;
}BTNode;

//初始化结点
BTNode* BuyNode(BTDataType x)
{
	BTNode* node = (BTNode*)malloc(sizeof(BTNode));
	if (node == NULL)
	{
		perror("malloc fail");
		return NULL;
	}

	node->data = x;
	node->left = NULL;
	node->right = NULL;

	return node;
}

//手动创建一棵链式二叉树
BTNode* CreatTree()
{
	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;
}

//前序遍历:根->左子树->右子树
void PerOrder(BTNode* root)
{
	if (NULL == root){
		printf("NULL ");
		return;
	}
	printf("%d ", root->data);
	PerOrder(root->left);
	PerOrder(root->right);
}

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

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

#include"Queue.h"
//层序遍历:队列的经典应用——出上一层,带入下一层
void LevelOrder(BTNode* root)
{
	Queue q;
	QueueInit(&q);
	//1、树不为空,首先把根节点入队列
	if (root)
	{
		QueuePush(&q, root);
	}
	//2、队列不为空,根出,带入左右孩子
	while (!QueueEmpty(&q))
	{
		//根出,遍历
		BTNode* front = QueueFront(&q);
		QueuePop(&q);
		printf("%d ", front->data);
		//带入左右孩子,注意不为空才能带入
		if (front->left)
		{
			QueuePush(&q, front->left);
		}
		if (front->right)
		{
			QueuePush(&q, front->right);
		}
	}
	QueueDesttroy(&q);
}

// 判断二叉树是否是完全二叉树
bool BinaryTreeComplete(BTNode* root)
{	
	Queue q;
	QueueInit(&q);
	//1、根不为空,首先根入队列
	if (root)
	{
		QueuePush(&q, root);
	}
	//2、队列不为空且根不为空,根出带入左右孩子
	while (!QueueEmpty(&q))
	{
		//根出
		BTNode* front = QueueFront(&q);//获取队头元素
		QueuePop(&q);//出队列
		//根不为空,带入左右孩子,为空结束循环
		if (front)
		{
			QueuePush(&q, front->left);
			QueuePush(&q, front->right);
		}
		else
		{
			break;
		}
	}
	//3、判断队列元素是否全为空
	while (!QueueEmpty(&q))
	{
		BTNode* front = QueueFront(&q);
		QueuePop(&q);
		//判断是否为空
		if (front)
		{
			//有非空,则该二叉树不是完全二叉树
			QueueDesttroy(&q);
			return false;
		}
	}
	//全为空,则该二叉树是完全二叉树
	QueueDesttroy(&q);
	return true;
}

typedef struct BinaryTreeNode1
{
	struct BinaryTreeNode1* left;
	struct BinaryTreeNode1* right;
	char val;
}BTNode1;

//通过前序遍历的数组"ABD##E#H##CF##G##"构建二叉树
BTNode1* BinaryTreeCreate(char* a, int* pi)
{
	//先序遍历创建——按照根->左->右顺序创建
	//为'#'时,代表空树,返回空
	if ('#' == a[*pi])
	{
		//每创建一个结点,下标就往后++
		(*pi)++;
		return NULL;
	}
	//创建根
	BTNode1* root = (BTNode1*)malloc(sizeof(BTNode1));
	root->val = a[(*pi)++];
	//创建左子树
	root->left = BinaryTreeCreate(a, pi);
	//创建右子树
	root->right = BinaryTreeCreate(a, pi);
	return root;
}


// 二叉树销毁
void BinaryTreeDestory(BTNode* root)
{
	//典型的后序遍历应用——因为前中两种遍历都有一个问题,在销毁根之前需要保存孩子结点的位置
	if (NULL == root)
	{
		return;
	}
	BinaryTreeDestory(root->left);
	BinaryTreeDestory(root->right);
	free(root);//记得在外将其置为空
}

int main()
{
	//创建一棵二叉树
	BTNode* root = CreatTree();
	//前序遍历
	PerOrder(root);
	printf("\n");
	//中序遍历
	InOrder(root);
	printf("\n");
	//后序遍历
	PostOrder(root);
	printf("\n");
	//层序遍历
	LevelOrder(root);
	printf("\n");
	//判断是否为完全二叉树
	printf("%d\n", BinaryTreeComplete(root));
	//销毁二叉树
	BinaryTreeDestory(root);
	root = NULL;
	return 0;
}

三、DFS和BFS(了解)

1、DFS

DFS:深度优先遍历

特点:沿着一条路一直往下走,直到无路可走时才回退,回退过程中如果有其他路再去走,直到无路可走。

DFS的实现:一般递归实现(实现DFS的关键在于回溯——自后向前,追溯曾经走过的路径,就叫做回溯)

二叉树中的前序遍历就是典型的一种DFS。

思考:中后遍历属于DFS吗?

  1. 中后遍历看情况而定,如果必须先访问值再往下走,就不能说是DFS
  2. 不考虑什么时候访问值,就可以说是DFS,因为前中后遍历的递归逻辑顺序都是一样的。

2、BFS

BFS:广度优先遍历

特点:从起点出发,先遍历起点的相邻结点,再依次遍历每一个相邻结点的相邻结点。

BFS的实现:一般队列实现(实现BFS的关键在于重放——把遍历过的结点按照之前遍历顺序重新回顾,就叫做重放)

二叉树的层序遍历就是典型的一种BFS。

  • 35
    点赞
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值