北邮22信通：二叉树 书上重要知识点补充 例4.3 统计结点总数 深度和叶子结点数

已于 2023-08-05 23:35:49 修改
阅读量557 收藏 2
点赞数 2
分类专栏： 北邮22信通——数据结构 文章标签： 算法
于 2023-04-16 17:52:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bc202205/article/details/130185096
版权
本文是北邮22信通学生关于数据结构与算法的实践分享，主要涉及二叉树的结点总数统计、二叉树深度计算和叶子结点数量的求解，通过递归实现。同时，提供了完整代码示例，包括int和class类型的存储测试，适用于C++编程学习者参考。
摘要由CSDN通过智能技术生成

北邮22信通一枚~   

跟随课程进度每周更新数据结构与算法的代码和文章 

持续关注作者  解锁更多邮苑信通专属代码~

获取更多文章  请访问专栏：

北邮22信通_青山如墨雨如画的博客-CSDN博客

目录

一.统计结点总个数

二.统计二叉树深度

三.统计叶子结点总数

四.完整代码

4.1测试int存储类型：

代码部分：

运行结果： 

4.2测试class储存类型：

代码部分：

运行结果： 

***说明***

书上例4.3的代码和思考题~

对上一篇文章的功能有了新补充~

函数主要思想：递归调用。

***说明完毕***

一.统计结点总个数

思路：二叉树结点总数等于其左子树的节点总数+右子树的结点总数+根结点。

代码部分：

template<class temp>
int bintree<temp>::nodecount(binnode<temp>* r)
{
	if (r == NULL)
		return 0;
	if (r->leftchild == NULL && r->rightchild == NULL)
		return 1;
	else
	{
		int m = nodecount(r->leftchild);
		int n = nodecount(r->rightchild);
		return m + n + 1;
	}
}

二.统计二叉树深度

代码部分：

思路：保存现场截止。

template<class temp>
int bintree<temp>::height(binnode<temp>* r)
{
	if (r == NULL)
		return 0;
	else
	{
		int m = height(r->leftchild);
		int n = height(r->rightchild);
		return m > n ? m + 1 : n + 1;
	}
}

三.统计叶子结点总数

        思路：判断某一处的结点是不是叶子结点，判断条件就是看它左右孩子是否没有。如果都没有，那就是叶子结点。然后调用函数递归来实现整体。

代码部分：

template<class temp>
int bintree<temp>::leafcount(binnode<temp>* r)
{
	if (r == NULL)
		return 0;
	if (r->leftchild == NULL && r->rightchild == NULL)
		return 1;
	else
	{
		int m = leafcount(r->leftchild);
		int n = leafcount(r->rightchild);
		return m + n;
	}
}

四.完整代码

4.1测试int存储类型：

代码部分：

#include<iostream>
#define MAXSIZE 100000
//注意：不能将上面这行宏定义写成
//#define MAXSIZE 1e5
//上面这样写会报错！！
using namespace std;

template<class temp>
struct binnode
{
	temp data;
	binnode<temp>* leftchild;
	binnode<temp>* rightchild;
};

template<class temp>
class bintree
{
private:
	void create(binnode<temp>*& r, temp data[], int i, int n);
	void release(binnode<temp>* r);
public:
	binnode<temp>* root;
	bintree(temp data[], int n);
	void preorder(binnode<temp>* r);
	void inorder(binnode<temp>* r);
	void postorder(binnode<temp>* r);
	void levelorder(binnode<temp>* r);

	int nodecount(binnode<temp>* r);
	int height(binnode<temp>* r);
	int leafcount(binnode<temp>* r);
	~bintree();
};

template<class temp>
void bintree<temp>::create(binnode<temp>*& r, temp data[], int i, int n)
{
	if (i <= n && data[i - 1] != 0)
	{
		r = new binnode<temp>;
		r->data = data[i - 1];
		r->leftchild = r->rightchild = NULL;
		create(r->leftchild, data, 2 * i, n);/*书上代码错误1：向函数传入实参时少传入一个n*/
		create(r->rightchild, data, 2 * i + 1, n);/*书上代码错误同上*/
	}
}

template<class temp>
bintree<temp>::bintree(temp data[], int n)
/*书上代码错误2：构造函数不能有返回值类型，但是书上多加了一个void*/
/*如果构造函数的声明语句写成
void bintree<temp>::bintree(temp data[], int n)，
程序会报错：不能在构造函数上指定返回值类型*/
{
	create(this->root, data, 1, n);
}

template<class temp>
void bintree<temp>::preorder(binnode<temp>* r)
{
	if (r != NULL)
	{
		cout << r->data;//访问结点；
		preorder(r->leftchild);//遍历左子树
		preorder(r->rightchild);//遍历右子树
	}
}

template<class temp>
void bintree<temp>::inorder(binnode<temp>* r)
{
	if (r != NULL)
	{
		inorder(r->leftchild);
		cout << r->data;
		inorder(r->rightchild);
	}
}

template<class temp>
void bintree<temp>::postorder(binnode<temp>* r)
{
	if (r != NULL)
	{
		postorder(r->leftchild);
		postorder(r->rightchild);
		cout << r->data;
	}
}

template<class temp>
void bintree<temp>::levelorder(binnode<temp>* R)
{
	binnode<temp>* queue[MAXSIZE];
	int f = 0, r = 0;
	if (R != NULL)
		queue[++r] = R;//根节点入队
	while (f != r)
	{
		binnode<temp>* p = queue[++f];//队头元素入队
		cout << p->data;//出队打印
		if (p->leftchild != NULL)
			queue[++r] = p->leftchild;//左孩子入队
		if (p->rightchild != NULL)
			queue[++r] = p->rightchild;//右孩子入队
	}
}

template <class temp>
void bintree<temp>::release(binnode<temp>* r)
{
	if (r != NULL)
	{
		release(r->leftchild);
		release(r->rightchild);
		delete r;
	}
}

/*书上代码错误3：不能在析构函数上指定返回值类型，但是书上代码多了一个void*/
template<class temp>
bintree<temp>::~bintree()
{
	release(this->root);
}

template<class temp>
int bintree<temp>::nodecount(binnode<temp>* r)
{
	if (r == NULL)
		return 0;
	if (r->leftchild == NULL && r->rightchild == NULL)
		return 1;
	else
	{
		int m = nodecount(r->leftchild);
		int n = nodecount(r->rightchild);
		return m + n + 1;
	}
}

template<class temp>
int bintree<temp>::height(binnode<temp>* r)
{
	if (r == NULL)
		return 0;
	else
	{
		int m = height(r->leftchild);
		int n = height(r->rightchild);
		return m > n ? m + 1 : n + 1;
	}
}

template<class temp>
int bintree<temp>::leafcount(binnode<temp>* r)
{
	if (r == NULL)
		return 0;
	if (r->leftchild == NULL && r->rightchild == NULL)
		return 1;
	else
	{
		int m = leafcount(r->leftchild);
		int n = leafcount(r->rightchild);
		return m + n;
	}
}

int main()
{
	system("color 0A");
	int a[5] = { 1,2,3,4,5 };
	bintree<int>bintreee(a, 5);
	cout << "前序遍历:" << endl;
	bintreee.preorder(bintreee.root);
	cout << endl << "中序遍历:" << endl;
	bintreee.inorder(bintreee.root);
	cout << endl << "后序遍历:" << endl;
	bintreee.postorder(bintreee.root);
	cout << endl << "层序遍历:" << endl;
	bintreee.levelorder(bintreee.root);
	cout << endl << "二叉树中的节点总数为:";
	cout << bintreee.nodecount(bintreee.root);
	cout << endl << "二叉树的深度为:";
	cout << bintreee.height(bintreee.root);
	cout << endl << "二叉树的叶子结点数为:";
	cout << bintreee.leafcount(bintreee.root);
	cout << endl;
}

运行结果： 

4.2测试class储存类型：

代码部分：

#include<iostream>
#define MAXSIZE 100000
//注意：不能将上面这行宏定义写成
//#define MAXSIZE 1e5
//上面这样写会报错！！
using namespace std;
class student
{
private:
	int ID;
	string name;
public:
	int existence;
	student()
	{
		this->ID = 0;
		this->name = "unknown name";
		this->existence = 0;
	}
	student(int ID, string name)
	{
		this->ID = ID;
		this->name = name;
		this->existence = 1;
	}
	friend ostream& operator<<(ostream& output, student& s)
	{
		output << s.ID << " " << s.name << endl;
		return output;
	}
};

template<class temp>
struct binnode
{
	temp data;
	binnode<temp>* leftchild;
	binnode<temp>* rightchild;
};

template<class temp>
class bintree
{
private:
	void create(binnode<temp>*& r, temp data[], int i, int n);
	void release(binnode<temp>* r);
public:
	binnode<temp>* root;
	bintree(temp data[], int n);
	void preorder(binnode<temp>* r);
	void inorder(binnode<temp>* r);
	void postorder(binnode<temp>* r);
	void levelorder(binnode<temp>* r);

	int nodecount(binnode<temp>* r);
	int height(binnode<temp>* r);
	int leafcount(binnode<temp>* r);
	~bintree();
};

template<class temp>
void bintree<temp>::create(binnode<temp>*& r, temp data[], int i, int n)
{
	/*书上代码的一个问题：data[i-1]!=0会报错，这是因为data的数据类型是temp，没法实现！=的运算*/
	//书上原代码
	//if (i <= n && data[i - 1] != 0)
	if (i <= n && data[i - 1].existence != 0)
	{
		r = new binnode<temp>;
		r->data = data[i - 1];
		r->leftchild = r->rightchild = NULL;
		create(r->leftchild, data, 2 * i, n);/*书上代码错误1：向函数传入实参时少传入一个n*/
		create(r->rightchild, data, 2 * i + 1, n);/*书上代码错误同上*/
	}
}

template<class temp>
bintree<temp>::bintree(temp data[], int n)
/*书上代码错误2：构造函数不能有返回值类型，但是书上多加了一个void*/
/*如果构造函数的声明语句写成
void bintree<temp>::bintree(temp data[], int n)，
程序会报错：不能在构造函数上指定返回值类型*/
{
	create(this->root, data, 1, n);
}

template<class temp>
void bintree<temp>::preorder(binnode<temp>* r)
{
	if (r != NULL)
	{
		cout << r->data;//访问结点；
		preorder(r->leftchild);//遍历左子树
		preorder(r->rightchild);//遍历右子树
	}
}

template<class temp>
void bintree<temp>::inorder(binnode<temp>* r)
{
	if (r != NULL)
	{
		inorder(r->leftchild);
		cout << r->data;
		inorder(r->rightchild);
	}
}

template<class temp>
void bintree<temp>::postorder(binnode<temp>* r)
{
	if (r != NULL)
	{
		postorder(r->leftchild);
		postorder(r->rightchild);
		cout << r->data;
	}
}

template<class temp>
void bintree<temp>::levelorder(binnode<temp>* R)
{
	binnode<temp>* queue[MAXSIZE];
	int f = 0, r = 0;
	if (R != NULL)
		queue[++r] = R;//根节点入队
	while (f != r)
	{
		binnode<temp>* p = queue[++f];//队头元素入队
		cout << p->data;//出队打印
		if (p->leftchild != NULL)
			queue[++r] = p->leftchild;//左孩子入队
		if (p->rightchild != NULL)
			queue[++r] = p->rightchild;//右孩子入队
	}
}

template <class temp>
void bintree<temp>::release(binnode<temp>* r)
{
	if (r != NULL)
	{
		release(r->leftchild);
		release(r->rightchild);
		delete r;
	}
}

/*书上代码错误3：不能在析构函数上指定返回值类型，但是书上代码多了一个void*/
template<class temp>
bintree<temp>::~bintree()
{
	release(this->root);
}

template<class temp>
int bintree<temp>::nodecount(binnode<temp>* r)
{
	if (r == NULL)
		return 0;
	if (r->leftchild == NULL && r->rightchild == NULL)
		return 1;
	else
	{
		int m = nodecount(r->leftchild);
		int n = nodecount(r->rightchild);
		return m + n + 1;
	}
}

template<class temp>
int bintree<temp>::height(binnode<temp>* r)
{
	if (r == NULL)
		return 0;
	else
	{
		int m = height(r->leftchild);
		int n = height(r->rightchild);
		return m > n ? m + 1 : n + 1;
	}
}

template<class temp>
int bintree<temp>::leafcount(binnode<temp>* r)
{
	if (r == NULL)
		return 0;
	if (r->leftchild == NULL && r->rightchild == NULL)
		return 1;
	else
	{
		int m = leafcount(r->leftchild);
		int n = leafcount(r->rightchild);
		return m + n;
	}
}

int main()
{
	system("color 0A");
	student stu[5] = { {1,"zhang"},{2,"wang"},{3,"li"},{4,"zhao"},{5,"liu"} };
	bintree<student>bintreee(stu, 5);
	cout << "前序遍历:" << endl;
	bintreee.preorder(bintreee.root);
	/*说明：这里体现了将根节点定义为public类型的好处，
	不然需要通过一个成员函数来实现这个功能，
	从数据保密性来看，这样做也是可以的：
	外部如果不通过调用成员函数，就只能访问根节点一个节点内的数据，
	但是其他任意节点内的数据都无法访问，安全性也相对较高。
	*/
	cout << endl << "中序遍历:" << endl;
	bintreee.inorder(bintreee.root);
	cout << endl << "后序遍历:" << endl;
	bintreee.postorder(bintreee.root);
	cout << endl << "层序遍历:" << endl;
	bintreee.levelorder(bintreee.root);
	cout << endl << "二叉树中的节点总数为:";
	cout << bintreee.nodecount(bintreee.root);
	cout << endl << "二叉树的深度为:";
	cout << bintreee.height(bintreee.root);
	cout << endl << "二叉树的叶子结点数为:";
	cout << bintreee.leafcount(bintreee.root);
	cout << endl;
	return 0;
}

运行结果： 

6-129 统计二叉树叶子结点的个数（Python语言描述）
燕朝铭的博客
04-17 171
本题要求计算二叉树中有多少片树叶，输出格式见样例。
二叉树学习
ORANCLE
11-16 274
一.树 树是一种递归定义的数据结构，是一种重要非线性的数据结构。它是由n(n>=1)个有限节点组成一个具有层次结构的集合。 二.树的相关术语 节点的度：一个节点含有的子树的个数称为该节点的度。 叶节点或终端节点：度为0的节点称为叶节点。 非终端节点或分支节点：度不为0的节点 兄弟节点：具有相同父节点的节点。 树的度：一棵树中，最大的节点的度称树的度。 节点的 层次：从根开始定义起，
6-5 统计二叉树叶子结点个数 (10 分)（C语言版）
热门推荐
qq_54210270的博客
02-15 1万+
先说思路： 有下面三种情况： 如果是空树，返回0； 如果只有一个根结点，即左右子树为空NULL，返回1； 如果左右子树不空，返回递归求左右子树叶子结点之和。 本题要求实现一个函数，可统计二叉树的叶子结点个数。 函数接口定义： int LeafCount ( BiTree T); T是二叉树树根指针，函数LeafCount返回二叉树中叶子结点个数，若树为空，则返回0。 裁判测试程序样例： #include <stdio.h> #include <stdlib.h> typede.
二叉树常用操作算法集、解释及注意事项
ljianhui的专栏
07-06 9339
二叉树是一种常用的数据结构，在程序中也经常需要使用二叉树，但是你所使用语言却并不一定提供了二叉树这种数据类型，所以为了方便使用，我们可以自己实现一个二叉树的数据类型。在需要时就像使用其他已定义的类型一样方便。 下面给出一些本人写的算法和解释（基于C语言），希望对读者写一个二叉树数据类型有所帮助。 0、递归的四条基本法则 由于二叉树中的算法大多使用递归来实现，而且使用递归实现也
点云配准之点到点，点到面，点到线ICP，NDT算法介绍
qq_54375651的博客
11-10 1249
点云配准在人工智能，自动驾驶，SLAM等任务中具有十分关键的作用，本文将介绍点云配准的点到点，点到线，点到面ICP和NDT算法
二分查找习题篇(上)
zoelinkailuo的博客
11-07 992
给定⼀个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。这里，我们把数组的元素分为两部分——小于等于target的部分[left,Bright] and 大于target的部分[Bright+1,right]。这里，我们把数组的元素分为两部分——平方后小于等于x的部分[1,mid] and 平方后大于x的部分[mid-1, x]和一个目标值，在数组中找到目标值，并返回其索引;
数组类算法【leetcode】
随便写写
11-07 369
给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。二分查找 用于有序数组中，没有重复的数组。首先需要定义一个头（left）和尾(right)，最后通过mid和target对比不断修改头和尾指向的位置。【需要注意区间问题，根据区间的开和闭决定边界条件】推荐练习 leetcode35.
GJ Round (2024.10) Round 8~21
lunjiahao的博客
11-06 895
前言： 点此 返回 GJ Round 目录 Round 8 (10.5) A 给定 nnn 个区间，每个区间 [li,ri][l_i,r_i][li​,ri​]，最大化选取区间对数，使得每对区间 [li,ri],[lj,rj][l_i,r_i],[l_j,r_j][li​,ri​],[lj​,rj​] 满足 [li,ri]∩[lj,rj]=∅[l_i,r_i] \cap [l_j,r_j] =\varnothing[li​,ri​]∩[lj​,rj​]=∅ 先按 lil_ili​ 从小到大排序，再按
【刷题】优选算法
林宇恒的博客
11-06 525
如图，我们先算出最左边(1)和最右边(7)围起来的容量，然后，7不动，1继续和7的左边3，8，4...遍历算出容量，你会发现底是不断缩短的，同时高一直都是1，因为高只有两种情况，比它小或和它相等，所以1和7左边的值算出来的容量都是比1和7的容量小的，因为底在不断变小同时高可能不变也可能变小。根据两个实例和鸽巢原理可以发现不断的平方和最终都会形成环，所以我们可以联想到用快慢指针，慢指针走一步，快指针走两步，最终会在环相遇，判断相遇时是否为1。第一个实例是快乐数，因为会变为1且不断是1的循环。
【LeetCode】【算法】416. 分割等和子集
passer__jw767的博客
11-06 324
LeetCode 416. 分割等和子集
69. x 的平方根
学习历程记录和分享
11-06 193
注意：不允许使用任何内置指数函数和算符，例如 pow(x, 0.5) 或者 x ** 0.5。由于返回类型是整数，结果只保留 整数部分 ，小数部分将被 舍去。给你一个非负整数 x ，计算并返回 x 的 算术平方根。
100种算法【Python版】第59篇——滤波算法之扩展卡尔曼滤波
AnFany
11-08 136
100种算法【Python版】第59篇——滤波算法之扩展卡尔曼滤波
算法通关（4）-- 前缀树
2301_79985750的博客
11-07 1010
前缀树（Trie树），也称为字典树，是一种用于的数据结构。它是一种树形结构，能够利用字符串的公共前缀来减少存储空间和查询时间。现在有“acb”,"cba","acc"，"ac"四个字符串，利用这四个字符串构出一颗前缀树。根节点不包含任何字符，是所有字符串的公共前缀；每个节点包含pass信息，代表加节点的时候路过了几次，还有一个end信息表示多少个字符串是以当前字符串结尾的。举个例子：插入完成后得到的树形结构：那么现在问：字符串acb出现了几次。
力扣 x的平方根-69
最新发布
Sunyanhui1的博客
11-11 357
函数模板的定义以template关键字开头，后面跟着模板参数列表，通常是typename（或clss，它们在这种情况下是等价的）加上一个参数名。T temp = a;a = b;b = temp;这个函数模板可以交换两个相同类型的变量的值，T是一个模板参数，它可以代表任意类型，只要该类型支持赋值操作。类模板的定义也是以template关键字开头，后面跟着模板参数列表。int size;public://其他成员函数的定义。
人脸识别技术：从算法到深度学习的全面解析
梵心白莲的博客
11-07 1255
人脸识别技术作为一种重要的生物识别技术，在当今社会中具有举足轻重的地位。它广泛应用于各个领域，如金融领域的实名认证、安保领域的门禁系统、通行领域的火车站和地铁站检票、泛娱乐领域的美颜相机和短视频特效处理、公安和司法领域的逃犯追捕和服刑人员管理、自助服务设备以及考勤和会务等。
01背包模板+空间压缩优化
aoe_z的博客
11-06 958
01背包模板+空间压缩优化01背包模板。
【EMNLP2024】基于多轮课程学习的大语言模型蒸馏算法 TAPIR
科技很有意思
11-08 819
阿里云人工智能平台 PAI与复旦大学王鹏教授团队合作，在自然语言处理顶会EMNLP 2024上发表论文《Distilling Instruction-following Abilities of Large Language Models with Task-aware Curriculum Planning》。
动态规划 之 简单多状态 dp 问题 算法专题
m0_73992740的博客
11-11 573
2.如果处于"可交易"状态, 那么第i - 1天, 可能处于"可交易"状态(i - 1天之前就卖了, 第i天还没买, 等于啥也没干), 可能处于"冷冻期"状态(i - 1天卖了, 第i天还没买, 等于啥也没干), 由于要最大利润, 对两次状态的结果取最大值。2.如果i选择蓝色, dp[i][0], 那么dp[i - 1]只能选择[1][2], 要的是最小花费, 所以。3.如果i选择红色, dp[i][0], 那么dp[i - 1]只能选择[1][2], 要的是最小花费, 所以。
置信传播算法复现
程序猿追的博客
11-08 120
例如，许多其他资源分配、调度安排、路径规划等问题在本质上与0 - 1背包问题有相似之处，通过对0 - 1背包问题的研究，可以探索通用的求解策略和近似算法，用于解决更广泛的NP难问题。例如，一家电子产品制造企业有一定数量的芯片、电路板等原材料，以及有限的生产线使用时间，要决定生产哪些型号的电子产品（每个型号产品视为一个物品，其价值为利润，重量为所需资源量），从而在不超过资源限制的情况下获得最大利润。载重约束为因子图中的一个因子节点，每个物品的状态约束为一个子句节点，变量节点与包含该变量的子句节点相连。
定义一棵二叉树T，分别输出二叉树的前序序列，中序序列和后续序列，输出二叉树的叶子结点数，深度和结点总数
10-24
这里我会给出三个常用的遍历方法：前序、中序和后序遍历，以及计算叶子节点数、深度和节点总数的简单方法。 **前序遍历（Preorder Traversal）**: 首先访问根节点，然后遍历左子树，最后遍历右子树。假设`pre_order...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

青山入墨雨如画

你的鼓励将是我创作的动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值