求二叉树的深度、宽度和叶子结点数

最新推荐文章于 2023-10-29 17:06:01 发布
最新推荐文章于 2023-10-29 17:06:01 发布
阅读量1w 收藏 37
点赞数 9
分类专栏： C++ 算法 笔试 文章标签： 二叉树 存储 链表 深度 叶子
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sanqima/article/details/48900301
版权
C++ 同时被 3 个专栏收录
241 篇文章 7 订阅
订阅专栏
笔试
57 篇文章 1 订阅
订阅专栏
算法
52 篇文章 2 订阅
订阅专栏

如果用链表来存储二叉树，那么可以将二叉树定义如下：

typedef char ElemType;
typedef struct node{
	ElemType data;     //数据元素
	struct node* lchild;  //指向左孩子
	struct node* rchild;  //指向右孩子
}BTNode;

问题一：二叉树的深度
　　二叉树的深度，也叫二叉树的高度，二叉树的深度等于从根结点到叶子结点的最长路径加1。用递归的观点来看，二叉树的深度，等于其最大左右子树的深度加1，而每个左子树(右子树)又可以分解为次左子树+次右子树，它们是深度也是最大子树深度加1。也就是二叉树深度的递归模型f(b)如下：　　 　 { f ( b ) = 0 , 若b=NULL f ( b ) = M a x { f ( b − > l c h i d ) , f ( b − > r c h i l d ) } + 1 , 其他情况 　 　 　 　 　\begin{cases} f(b)=0, & \text{若b=NULL} \\ f(b)=Max\{f(b->lchid),f(b->rchild)\}+1, & \text{其他情况} 　\end{cases}　　 　 　{f(b)=0,f(b)=Max{f(b−>lchid),f(b−>rchild)}+1,​若b=NULL其他情况　​　　　

对应的递归算法如下：

//求二叉树b的深度
int BTNodeDepth(BTNode *b){
	int lchilddep,rchilddep;
	if(b==NULL)
		return 0;
	else{
		lchilddep=BTNodeDepth(b->lchild);
		rchilddep=BTNodeDepth(b->rchild);
		return (lchilddep>rchilddep)?(lchilddep+1):(rchilddep+1);
	}

}

问题二：二叉树的宽度
　　二叉树的宽度：具有结点数最多的那一层的结点个数。
　　采用分层遍历的方法求出所有结点的层编号，然后，求出各层的结点总数，通过比较找出层结点数最多的值。对应的算法如下：

//求二叉树b的宽度
int BTWidth(BTNode *b){
	struct{
		int lno;        //结点的层次编号
		BTNode *p;      //结点指针
	}Qu[MaxSize];      //定义顺序非循环队列
	int front,rear;
	int lnum,max,i,n;
	front=rear=0;      //置队列为空
	if (b!=NULL)
	{
		rear++;
		Qu[rear].p=b;      //根结点指针入队
		Qu[rear].lno=1;    //根结点的层次编号为1
		while (rear!=front)  //队列不为空
		{
			front++;
			b=Qu[front].p;    //队头出队
			lnum=Qu[front].lno;
			if (b->lchild!=NULL)  //左孩子入队
			{
				rear++;
				Qu[rear].p=b->lchild;
				Qu[rear].lno=lnum+1;
			}
			if (b->rchild!=NULL)  //右孩子入队
			{
				rear++;
				Qu[rear].p=b->rchild;
				Qu[rear].lno=lnum+1;
			}
		}
		max=0; lnum=1; i=1;
		while (i<=rear)
		{
			n=0;
			while (i<=rear && Qu[i].lno==lnum)
			{
				n++; i++;
			}
			lnum=Qu[i].lno;
			if(n>max) max=n;
		}
		return max;
	}
	else
		return 0;

}

问题三：二叉树b的叶子结点个数
　　当b为空树时，叶子结点数为0；
　　当b的左子树和右子树都为空，b只有一个结点时，叶子结点数为1；
　　当b的左子树或右子树不为空时，叶子结点数=左子树叶子结点数+右子树叶子结点数。
　　即递归模型为:

{ f ( b ) = 0 , 若b=NULL f ( b ) = 1 , 若b->lchild==NULL且b->rchild==NULL f ( b ) = f ( b − > l c h i l d ) + f ( b − > r c h i l d ) , 其他情况 \begin{cases} f(b)=0, & \text{若b=NULL} \\ f(b)=1, & \text{若b->lchild==NULL且b->rchild==NULL} \\ f(b)=f(b->lchild)+f(b->rchild), & \text{其他情况} \end{cases} ⎩⎪⎨⎪⎧​f(b)=0,f(b)=1,f(b)=f(b−>lchild)+f(b−>rchild),​若b=NULL若b->lchild==NULL且b->rchild==NULL其他情况​

对应的递归算法如下：

//求二叉树b的叶子结点个数
int LeafNodes(BTNode *b){
	int num1,num2;
	if(b==NULL)
		return 0;
	else if(b->lchild==NULL && b->rchild==NULL)
		return 1;
	else{
		num1=LeafNodes(b->lchild);
		num2=LeafNodes(b->rchild);
		return (num1+num2);
	}

}

完整代码如下：

//BinaryTreeBase.h
#include <stdio.h>
#include <malloc.h>
#define MaxSize 100
typedef char ElemType;
typedef struct node{
	ElemType data;     //数据元素
	struct node* lchild;  //指向左孩子
	struct node* rchild;  //指向右孩子
}BTNode;

//由str串创建二叉链
void CreateBTNode(BTNode *&b,char *str){
	BTNode *St[MaxSize],*p=NULL;
	int top=-1,k,j=0;
	char ch;
	b=NULL;
	ch=str[j];
	while (ch!='\0')
	{
		switch(ch){
		case '(': top++; St[top]=p; k=1; break;
		case ')': top--; break;
		case ',': k=2; break;
		default: p=(BTNode *)malloc(sizeof(BTNode));
			p->data=ch; p->lchild=p->rchild=NULL;
			if(b==NULL)
				b=p;
			else{
				switch(k){
				case 1: St[top]->lchild=p; break;
				case 2: St[top]->rchild=p; break;
				}
			}
		}
		j++;
		ch=str[j];
	}

}

//返回data域为x的结点指针
BTNode *FindNode(BTNode *b,ElemType x){
	BTNode *p;
	if(b==NULL)
		return NULL;
	else if(b->data==x)
		return b;
	else{
		p=FindNode(b->lchild,x);
		if(p!=NULL)
			return p;
		else
			return FindNode(b->rchild,x);
	}

}

BTNode *LchildNode(BTNode *p){
	return p->lchild;
}

BTNode *RchildNode(BTNode *p){
	return p->rchild;
}

//求二叉树b的深度
int BTNodeDepth(BTNode *b){
	int lchilddep,rchilddep;
	if(b==NULL)
		return 0;
	else{
		lchilddep=BTNodeDepth(b->lchild);
		rchilddep=BTNodeDepth(b->rchild);
		return (lchilddep>rchilddep)?(lchilddep+1):(rchilddep+1);
	}

}

//用括号表示法输出二叉树
void DispBTNode(BTNode *b){
	if (b!=NULL)
	{
		printf("%c",b->data);
		if (b->lchild!=NULL || b->rchild!=NULL)
		{
			printf("(");
			DispBTNode(b->lchild);
			if(b->rchild!=NULL) printf(",");
			DispBTNode(b->rchild);
			printf(")");
		}
	}

}

void printBTN(BTNode *b,int w){
	int i;
	if (b!=NULL)
	{
		printBTN(b->rchild,w+5);
		for(i=1;i<w;i++)
			printf(" ");
		printf("%c\n",b->data);
		printBTN(b->lchild,w+5);
	}

}

//求二叉树b的宽度
int BTWidth(BTNode *b){
	struct{
		int lno;        //结点的层次编号
		BTNode *p;      //结点指针
	}Qu[MaxSize];      //定义顺序非循环队列
	int front,rear;
	int lnum,max,i,n;
	front=rear=0;      //置队列为空
	if (b!=NULL)
	{
		rear++;
		Qu[rear].p=b;      //根结点指针入队
		Qu[rear].lno=1;    //根结点的层次编号为1
		while (rear!=front)  //队列不为空
		{
			front++;
			b=Qu[front].p;    //队头出队
			lnum=Qu[front].lno;
			if (b->lchild!=NULL)  //左孩子入队
			{
				rear++;
				Qu[rear].p=b->lchild;
				Qu[rear].lno=lnum+1;
			}
			if (b->rchild!=NULL)  //右孩子入队
			{
				rear++;
				Qu[rear].p=b->rchild;
				Qu[rear].lno=lnum+1;
			}
		}
		max=0; lnum=1; i=1;
		while (i<=rear)
		{
			n=0;
			while (i<=rear && Qu[i].lno==lnum)
			{
				n++; i++;
			}
			lnum=Qu[i].lno;
			if(n>max) max=n;
		}
		return max;
	}
	else
		return 0;

}

//求二叉树b的结点个数
int Nodes(BTNode *b){
	int num1,num2;
	if(b==NULL)
		return 0;
	else if(b->lchild==NULL && b->rchild==NULL)
		return 1;
	else{
		num1=Nodes(b->lchild);
		num2=Nodes(b->rchild);
		return (num1+num2+1);
	}

}

//求二叉树b的叶子结点个数
int LeafNodes(BTNode *b){
	int num1,num2;
	if(b==NULL)
		return 0;
	else if(b->lchild==NULL && b->rchild==NULL)
		return 1;
	else{
		num1=LeafNodes(b->lchild);
		num2=LeafNodes(b->rchild);
		return (num1+num2);
	}

}

//主函数.cpp
#include "BinaryTreeBase.h"
#include <stdio.h>
#include <stdlib.h>

void main()
{
	BTNode* bt;
	char str[20]="A(B(D(,G)),C(E,F))";
	CreateBTNode(bt,str);
	printf("二叉树的括号表示法：");
	DispBTNode(bt);
	printf("\n");

	printf("横向打印二叉树：\n");
	printBTN(bt,10);
	printf("\n");

	int num=0,leafNum=0,deepth=0,width=0;
	num=Nodes(bt);
	leafNum=LeafNodes(bt);
	deepth=BTNodeDepth(bt);
	width=BTWidth(bt);

	printf("二叉树的结点数: %d\n",num);
	printf("二叉树的叶子结点数: %d\n",leafNum);
	printf("二叉树的深度: %d\n",deepth);
	printf("二叉树的宽度: %d\n",width);

	system("pause");
}

效果如下：

图(1) 用括号表示法，创建二叉树，并求它的深度、宽度和叶子结点数
图(1) 用括号表示法，创建二叉树，并求它的深度、宽度和叶子结点数

sanqima
关注
  • 9
    点赞
  • 踩
  • 37
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
给定一棵二叉树，计算该二叉树的深度、总节点个数和叶子节点个数。
weixin_46314022的博客
11-17 4216
#include "binary_tree.h" int GetTreeDepth(BiTreeNode* root) // 计算该二叉树的深度 // 参数：二叉树根节点root // 返回：二叉树的深度 { // 请在这里补充代码，完成本关任务 /********** Begin *********/ int m; int n; if(root==NULL) { return 0; } else { m=GetTreeD
Java实现求二叉树的深度和宽度
09-03
主要介绍了Java实现求二叉树的深度和宽度,本文分别给出代码实例,需要的朋友可以参考下
二叉树的宽度
热门推荐
Dablelv 的博客专栏。
04-06 6万+
二叉树的宽度定义为具有最多结点数的层中包含的结点数。比如上图中，第 1 层有 1 个结点， 第 2 层有 2 个结点， 第 3 层有 4 个结点， 第 4 层有 1 个结点。可知，第 3 层的结点数最多，所以这棵二叉树的宽度是 4。
二叉树专题--洛谷 P3884 [JLOI2009]二叉树问题（dfs求二叉树深度 bfs求二叉树宽度 dijkstra求最短路）
Jacob0824的博客
06-28 470
如下图所示的一棵二叉树的深度、宽度及结点间距离分别为：其中宽度表示二叉树上同一层最多的结点个数。给定一颗以 1 号结点为根的二叉树，请求出其深度、宽度和两个指定节点 x,yx, yx,y 之间的距离。第一行是一个整数，表示树的结点个数 nnn。 接下来 n−1n - 1n−1 行，每行两个整数 u,vu, vu,v，表示树上存在一条连接 u,vu, vu,v 的边。 最后一行有两个整数 x,yx, yx,y，表示求 x,yx, yx,y 之间的距离。输入三行，每行一个整数，依次表示二叉树的深度、宽度和 x,
C语言实现二叉树的四种遍历和求深度与叶子结点个数
酒醉浮生的博客
09-04 9178
C语言实现二叉树的四种遍历和求深度与叶子结点个数使用链式存储实现二叉树使用顺序队列实现二叉树的层序遍历功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 使用链式存储实现二叉树 定义存储数据类型和链式二叉树 //定义数据类型 ty
数据结构与算法：二叉树层次遍历的应用（2）(求二叉树的最大最小值，宽度，深度，第k层节点数量，值为x的节点所在层次)
weixin_50690285的博客
07-18 954
数据结构与算法：二叉树层次遍历的应用（2）
二叉树的叶子结点数及深度
04-03
完整的计算C++二叉树叶子结点数及深度的程序，希望能帮到大家。
叶子结点数及深度（C语言）
02-03
计算叶子结点数及深度，C语言入门小程序，适用于C语言课程入门的小练习
树的高度和叶子结点数.rar_二叉树
09-21
先是建立一个树,然后对树进行转换变成二叉树,求出树的高度和叶子节点,此程序对于数据结构学习者很有帮助
二叉树的遍历与求深度以及结点数
12-10
二叉树的三种遍历与求数的深度以及数的结点数 二叉树的三种遍历与求数的深度以及数的结点数
数据结构上机实验——二叉树的实现、二叉树遍历、求二叉树的深度/节点数目/叶节点数目、计算二叉树度为1或2的节点数、判断二叉树是否相似
Crocodile1006的博客
10-29 1371
数据结构、二叉树、创建一颗二叉树、对这棵二叉树进行遍历、求二叉树的深度/节点数目/叶节点数目、计算二叉树中度为 1 或 2 的结点数、判断2棵二叉树是否相似，若相似返回1，否则返回0
建立一棵二叉树，求二叉数的树的深度、统计叶子结点的个数、统计总的结点个数、进行层序遍历、交换左右子树
qq_55109560的博客
01-21 2592
源程序及注释 //测试数据 ABC##DE#G##F### #include<iostream> usingnamespacestd; #defineERROR0 #defineOK1 typedefintStatus; typedefcharTElemType; //二叉树的二叉链表存储表示 typedefstructBiTNode{ TElemTypedata; //结点数据域 structBiTNode*lchild, *rch...
数据结构习题——求二叉树的深度与宽度
无由页的博客
04-27 4232
前言 题目来自王道数据结构一书，归纳一下 正文 求二叉树的深度 递归
计算二叉树的 高度/宽度（带图解）
qq_28983957的博客
04-25 3056
本章主要实现了二叉树的宽度以及高度的计算的代码并且带图解
计算二叉树的深度和宽度
飞翔的美食家
04-12 4744
如何求解二叉树的深度，可以先分析一下下图： 在这个图中，根节点R的高度H1=max{左子节点高度H2，右子节点高度H3}+1;可以得出H1=H3+1; 而H2=max{H4,0}+1;H3=H5+1; ....;... 所以可以看出对高度的求解可以满足以下递归： 求得左子树的高度 LHeight; 求得右子树的高度RHeight; 根的高度为max（LHeight+1,RHe
二叉树的几种简单算法
rzchong1988的专栏
08-12 501
#定义一个二叉树结点# typedef struct node{ Datatype data; /*相应的数据类型*/ struct node* lchild,rchild; /*表示指向左右子树的指针*/ }BinTNode; typedef BinTNode* BinTree;   /*计算二叉树深度的算法*/ /*二叉树深度为左子树，或右子树的最大深度加上1 *
求二叉树的宽度和高度
hr786250678的博客
11-12 1244
一、二叉树宽度         利用队列保存每一层的结点，借助层次遍历的思想(先将根节点入队，队列非空时每出队一个结点将其左右子节点入队），队列中的结点个数就是下一次的循环次数，当循环结束后队列中的结点就全部是下一层的结点。 int width(BTree t) { if(t==NULL) return 0; queue &lt;BNode*&gt; que; que...
二叉树求深度和宽度，叶子节点数，总结点数
wuhuagu_wuhuaguo的博客
05-06 3693
二叉树求深度和宽度，叶子节点数，总结点数
二叉树的有关计算
weixin_30644369的博客
03-31 493
有关概念：https://www.cnblogs.com/schips/p/10630533.html 参考：　　https://blog.csdn.net/bojie5744/article/details/30744767 计算公式 https://blog.csdn.net/stf1065716904/article/details/80874065 1. n个节点的二...
创建二叉树、求二叉树的叶子节点、求二叉树的深度
最新发布
11-16
以下是关于创建二叉树、求二叉树的叶子节点、求二叉树的深度的回答： 1. 创建二叉树 创建二叉树的方法有很多，这里提供一种基于Python的实现方法。我们可以定义一个二叉树节点类，然后通过递归的方式创建二叉树。 ```python class TreeNode: def __init__(self, val=0, left=None, right=None): self.val = val self.left = left self.right = right def create_tree(nums): if not nums: return None mid = len(nums) // 2 root = TreeNode(nums[mid]) root.left = create_tree(nums[:mid]) root.right = create_tree(nums[mid+1:]) return root ``` 上述代码中，我们定义了一个TreeNode类，包含节点值val、左子节点left和右子节点right。create_tree函数接收一个列表nums作为参数，返回一个二叉树的根节点。在函数内部，我们首先判断nums是否为空，如果为空则返回None。否则，我们找到nums的中间位置mid，将mid位置的元素作为根节点的值，然后递归地创建左子树和右子树。 2. 求二叉树的叶子节点 二叉树的叶子节点是指没有子节点的节点。我们可以通过递归的方式遍历整个二叉树，统计叶子节点的个数。 ```python def count_leaves(root): if not root: return 0 if not root.left and not root.right: return 1 return count_leaves(root.left) + count_leaves(root.right) ``` 上述代码中，count_leaves函数接收一个二叉树的根节点root作为参数，返回二叉树的叶子节点个数。在函数内部，我们首先判断root是否为空，如果为空则返回0。然后判断root是否为叶子节点，如果是则返回1。否则，递归地计算左子树和右子树的叶子节点个数，并将它们相加。 3. 求二叉树的深度 二叉树的深度是指从根节点到最远叶子节点的最长路径上的节点数。我们可以通过递归的方式遍历整个二叉树，统计二叉树的深度。 ```python def max_depth(root): if not root: return 0 left_depth = max_depth(root.left) right_depth = max_depth(root.right) return max(left_depth, right_depth) + 1 ``` 上述代码中，max_depth函数接收一个二叉树的根节点root作为参数，返回二叉树的深度。在函数内部，我们首先判断root是否为空，如果为空则返回0。然后递归地计算左子树和右子树的深度，并将它们的最大值加1返回。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值