数据结构二叉树的常规算法（C语言）

最新推荐文章于 2024-01-06 21:32:05 发布
最新推荐文章于 2024-01-06 21:32:05 发布
阅读量2.1k 收藏 20
点赞数 4
文章标签： 数据结构 算法 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46263870/article/details/121195962
版权
  1. 求二叉树叶子结点个数。
  2. 求二叉树的宽度。
  3. 求任意二叉树中第一条最长的路径长度，并输出此路径上各结点的值。
  4. 输出二叉树中从每个叶子结点到根结点的路径。

目录

//树的结构定义

//求叶子结点个数

//求树的宽度

//求树的深度

//求最长路径

//求叶子节点到根节点的路径

//树的结构定义

//二叉树：
typedef struct BTree {
	elemtype data;
	struct BTree* left;
	struct BTree* right;
}*BTree

//求叶子结点个数

思路：在遍历的基础上加一个判断语句和一个计数器，判断该节点是不是叶子节点，是的话计数器就加1.

//求叶子结点数
//前序遍历的方式
int count = 0;	//计数器
void GetNum(BTree root) {
	if (root == NULL)
		return;
	if (root->left == NULL && root->right == NULL) {//叶子结点
		++count;
		return;
	}
	GetNum(root->left);
	GetNum(root->right);
}

//求树的宽度

思路：用层次遍历的方式，比较每一层的结点数，最大的就是整颗树的宽度。先定义一个新的结构体，用来描述每一个结点所在的层次数，再定义一个队列，给所有的结点都记录上自己的层数，最后比较。

//用一个新结构体记录每一个结点所在的层数
typedef struct Width {
	BTree p;	//树的结点
	int num;	//该节点层数
}Width;
//求树的宽度
int GetWidth(BTree root) {
	BTree p = root;
	Width Queue[MAXSIZE];	//建一个队列
	int front = 0;			//队首指针
	int rear = 0;			//队尾指针
	int num = 1;			//初始层数
	BTree q = NULL;			//辅助结点
	if (p != NULL) {
		Queue[rear].p = p;						//结点入队
		Queue[rear++].num = num;				//该结点所在层数
		//先确定每一个结点所在的层数
		while (rear != front) {					//队不为空
			q = Queue[front].p;					//出队
			num = Queue[front++].num;			//获得当前结点的所在层数
			if (q->left) {						//左儿子存在就把左儿子入队
				Queue[rear].p = q->left;		//入队
				Queue[rear++].num = num + 1;	//所在层次要加1
			}
			if (q->right) {
				Queue[rear].p = q->right;
				Queue[rear++].num = num + 1;
			}
		}
		int i = 0;								//i作队列指针
		int max = 0;							//宽度
		num = 1;								//重置层次数
		while (i < rear) {		
			int count = 0;						//计数器，每层节点数
			while (i < rear && Queue[i].num == num) {		//统计同一层上结点数
				++count;
				++i;
			}
			num++;								//层次加1
			if (max < count)
				max = count;
		}
		return max;
	}
	return 0;
}

//求树的深度

思路：采用递归的方法，分别算出左子树和右子树的深度，然后比较两边深度大小，大的作为整颗树的深度。

//求树的深度
//递归方法
int Depth(BTree root) {
	if (root == NULL)
		return 0;
	int ldpeth = Depth(root->left) + 1;	//左子树深度
	int rdpeth = Depth(root->right) + 1;//右子树深度
	return ldpeth > rdpeth ? ldpeth : rdpeth;	//返回最深的子树的深度
}

//求最长路径

思路：还是用递归，中间通过判断两边的深度来决定递归的子树。

//求最长路径
void Long(BTree root) {
	if (root == NULL)
		return;
	printf("%c ", root->data);
	if (Depth(root->left) > Depth(root->right))	//判断哪边的深度最深
		Long(root->left);
	else
		Long(root->right);
}

//求叶子节点到根节点的路径

思路：用辅助栈来操作，将叶子结点前的每一个结点值存入栈中，如果遇到叶子结点，就打印栈中的结点值，这就是根结点到该叶子结点的路径。

//叶子到根的路径
//辅助栈：
typedef struct Stack {
	int top;//栈顶指针
	elemtype data[MAXSIZE];
}*Stack;
Stack stack;
//栈的初始化：
void init() {
	stack = (Stack)malloc(sizeof(struct Stack));
	stack->top = -1;
}
//压栈操作
void Push(elemtype ch) {
	stack->data[++stack->top] = ch;
}
//出栈操作
void Pop() {
	stack->top--;
}
//打印栈
void PrintStack() {
	printf("%c", stack->data[0]);
	for (int i = 1; i <= stack->top; i++) {
		printf("-->%c", stack->data[i]);
	}
	printf("\n");
}
//求路径
void Path(BTree root) {
	if (root) {
		Push(root->data);	//先将结点值压栈
		if (!root->left && !root->right) {	//如果这个结点是叶子就打印栈里的内容
			PrintStack();
		}
		else {								//不是的话就递归左子树和右子树
			Path(root->left);
			Path(root->right);
		}
		Pop();								//出栈，改变叶子结点，改变路径的终点
	}
}

//加主函数的完整测试源码

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<malloc.h>
#define elemtype char
#define MAXSIZE 15

//二叉树：
typedef struct BTree {
	elemtype data;
	struct BTree* left;
	struct BTree* right;
}*BTree;

void menu() {
	printf("================\n");
	printf("1、求叶子结点数\n");
	printf("2、求二叉树宽度\n");
	printf("3、最长路径长度\n");
	printf("4、叶子到根路径\n");
	printf("5、二叉树的深度\n");
	printf("================\n");
}
//队列初始化树
BTree InitTree(BTree root) {
	BTree Queue[MAXSIZE + 1];	//创建队，+1防止溢出
	int front = 1;				//队首指针,从1开始方便后面的左右儿子判断
	int rear = 0;				//队尾指针。从0开始方便后面计算
	BTree new;					//新节点
	elemtype ch;				//结点值
	while ((ch = getchar()) != '\n') {
		new = (BTree)malloc(sizeof(struct BTree));
		new->data = ch;
		new->left = new->right = NULL;
		Queue[++rear] = new;	//入队
		if (root == NULL)
			root = new;
		if (Queue[rear]->data == '#')
			Queue[rear] = NULL;
		if (rear == front * 2)	//判断是否是root的左儿子
			Queue[front]->left = Queue[rear];
		if (rear == front * 2 + 1) {	//判断是否是root的右儿子
			Queue[front]->right = Queue[rear];
			front++;			//如果是右儿子那代表着这个结点已经操作完了，就将front加1(出队)
		}
	}
	return root;
}
//求叶子结点数
//前序遍历的方式
int count = 0;	//计数器
void GetNum(BTree root) {
	if (root == NULL)
		return;
	if (root->left == NULL && root->right == NULL) {
		++count;
		return;
	}
	GetNum(root->left);
	GetNum(root->right);
}
//求树的宽度
//用一个结构体记录每一个结点所在的层数
typedef struct Width {
	BTree p;	//树的结点
	int num;	//该节点层数
}Width;
int GetWidth(BTree root) {
	BTree p = root;
	Width Queue[MAXSIZE];	//建一个队列
	int front = 0;			//队首指针
	int rear = 0;			//队尾指针
	int num = 1;			//初始层数
	BTree q = NULL;			//辅助结点
	if (p != NULL) {
		Queue[rear].p = p;						//结点入队
		Queue[rear++].num = num;				//该结点所在层数
		//先确定每一个结点所在的层数
		while (rear != front) {					//队不为空
			q = Queue[front].p;					//出队
			num = Queue[front++].num;			//获得当前结点的所在层数
			if (q->left) {						//左儿子存在就把左儿子入队
				Queue[rear].p = q->left;		//入队
				Queue[rear++].num = num + 1;	//所在层次要加1
			}
			if (q->right) {
				Queue[rear].p = q->right;
				Queue[rear++].num = num + 1;
			}
		}
		int i = 0;								//i作队列指针
		int max = 0;							//宽度
		num = 1;								//重置层次数
		while (i < rear) {		
			int count = 0;						//计数器，每层节点数
			while (i < rear && Queue[i].num == num) {		//统计同一层上结点数
				++count;
				++i;
			}
			num++;								//层次加1
			if (max < count)
				max = count;
		}
		return max;
	}
	return 0;
}
//求树的深度
//递归方法
int Depth(BTree root) {
	if (root == NULL)
		return 0;
	int ldpeth = Depth(root->left) + 1;	//左子树深度
	int rdpeth = Depth(root->right) + 1;//右子树深度
	return ldpeth > rdpeth ? ldpeth : rdpeth;	//返回最深的子树的深度
}
//求最长路径
void Long(BTree root) {
	if (root == NULL)
		return;
	printf("%c ", root->data);
	if (Depth(root->left) > Depth(root->right))	//判断哪边的深度最深
		Long(root->left);
	else
		Long(root->right);
}
//叶子到根的路径
//辅助栈：
typedef struct Stack {
	int top;//栈顶指针
	elemtype data[MAXSIZE];
}*Stack;
Stack stack;
//栈的初始化：
void init() {
	stack = (Stack)malloc(sizeof(struct Stack));
	stack->top = -1;
}
//压栈操作
void Push(elemtype ch) {
	stack->data[++stack->top] = ch;
}
//出栈操作
void Pop() {
	stack->top--;
}
//打印栈
void PrintStack() {
	printf("%c", stack->data[0]);
	for (int i = 1; i <= stack->top; i++) {
		printf("-->%c", stack->data[i]);
	}
	printf("\n");
}
//求路径
void Path(BTree root) {
	if (root) {
		Push(root->data);	//先将结点值压栈
		if (!root->left && !root->right) {	//如果这个结点是叶子就打印栈里的内容
			PrintStack();
		}
		else {								//不是的话就递归左子树和右子树
			Path(root->left);
			Path(root->right);
		}
		Pop();								//出栈，改变叶子结点，改变路径的终点
	}
}
int main(){
	init();
	int chose = 0;
	BTree root=NULL;
	printf("用对列初始化，‘#’代表虚结点：\n");
	root=InitTree(root);		//初始化树
	while (1) {
		menu();
		scanf("%d", &chose);
		switch (chose) {
		case 1: //叶子节点数目
			GetNum(root);
			printf("叶子结点数是：%d\n",count);
			count = 0;
			break;
		case 2://树的最大宽度
			printf("宽度是%d\n", GetWidth(root));
			break;
		case 3://树的最长路径
			Long(root);
			printf("\n");
			break;
		case 4://树的所有路径
			Path(root);
			break;
		case 5://树的深度
			printf("二叉树的深度是：%d\n", Depth(root));
			break;
		default:return;
		}
	}
	return 0;
}
多低调
关注
  • 4
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
数据结构——二叉树的最长路径问题
qq_50675813的博客
11-26 9407
题目： 求任意二叉树中第一条最长的路径长度,并输出此路径上各结点的值。 思路： 求最长路径算法（核心代码） void longest_path(BiTree T,int *path,int &len,int *longestpath,int &longest_len) { if(T!=NULL) { if(T->lchild==NULL&&T->rchild==NULL) { path[len]=T->data; if(len>
编写求任意二叉树中一条最长的路径的算法，要求输出此路径上各结点的值及路径的长度。...
weixin_34062329的博客
11-16 4908
int Depth(BiTree T)/* 深度 */ { if(T==NULL) return(0); return 1+(Depth(T->lchild)>Depth(T->rchild)? Depth(T->lchild):Depth(T->rchild)); //选择左右孩子深度高的然后加上根节点这一层就是深度了 ...
C/C++二叉树
qq_61213622的博客
10-24 672
二叉树和堆
求二叉树的深度C语言实现
最新发布
Cyber.L的博客
01-06 1218
在二叉树中，深度是指从根节点到最远叶子节点的最长路径上的边数。
求二叉树中的结点个数、叶子结点个数、某结点层次和二叉树宽度
ytuyzh的博客
12-03 6176
目的：掌握二叉树遍历算法的应用，熟练使用先序、中序、后序3种递归遍历算法和层次遍历算法进行二叉树的问题求解。 内容：编写一个程序exp7-6.cpp实现以下功能，并对图7.33所示的二叉树进行验证。 （1）输出二叉树b的结点个数。 （2）输出二叉树b的叶子结点个数。 （3）求二叉树b中指定结点值（假设所有节点值不同）的结点层次。 （4）利用层次遍历求二叉树b的宽度。 代码如下： #...
数据结构ppt.zip
11-29
在C语言中，学习数据结构是理解和编写高效算法的基础。本套课件"数据结构ppt.zip"提供了全面的数据结构教程，涵盖了一系列关键主题。 首先，从第1章“概述”开始，我们了解到数据结构的重要性以及它在编程中的应用...
《数据结构》_C.高一凡
08-16
- **全面覆盖**：除了常规内容外，还涵盖了教科书中较少提及的特殊数据结构和算法。 - **实用性高**：附带光盘包含了所有程序代码，方便读者实践操作。 #### 五、结语 《数据结构》算法实现及解析（第二版）是一本...
数据结构题库
05-09
9. **文件系统和数据持久化**：虽然这不是数据结构的常规部分，但在实际应用中，数据结构需要考虑数据的持久化存储，比如磁盘上的文件系统是如何组织和检索数据的。 通过解答这个题库，你可以深入理解数据结构的...
输出树的根节点到叶子节点的所有路径
06-28
输出树的根节点到叶子节点的所有路径，用递归实现
二叉树中第一条最长的路径并输出此路径上各结点的值
weixin_30847939的博客
05-08 2486
本文采用递归方法和配合STL模板的容器实现最长结点的遍历。 实现代码如下： 1 #include<iostream> 2 #include<vector> 3 4 using namespace std; 5 6 typedef struct node 7 { 8 char data;//结点数据 9 struct node *...
【数据结构与算法】求任意二叉树中第一条最长的路径长度，并输出此路径上各结点的值
知识虔诚的信徒，探索所有未知是信徒毕生的信仰
07-04 3499
求任意二叉树中第一条最长的路径长度，并输出此路径上各结点的值
二叉树-求第一条最长路径长度并输出路径
weixin_42299851的博客
06-04 9255
求第一条最长路径长度并输出路径 算法思想 利用递归遍历思想，先求出二叉树最长路径也就是当前树的高度 再调用求路径长度的函数判断指针走向输出路径 int LongestPath(BiTree *T){ //求出当前二叉树的最长路径 if(T==0) return 0; if(T->lchild==0&&T->rchild==0) return 1; int L=LongestPath(T->lchild); int R=LongestPath(T->rch
求任意二叉树中第一条最长的路径长度，并输出此路径上各结点的值。
weixin_35757531的博客
01-02 1160
对于任意一棵二叉树，要求出第一条最长的路径长度并输出此路径上各结点的值，可以使用以下方法： 定义一个全局变量 maxLength，用于存储当前找到的最长路径长度。令 maxLength 的初始值为 0。 定义一个变量 path，用于存储当前找到的最长路径上各结点的值。 在二叉树的每个结点处，递归地求出以该结点为根的子树中最长的路径长度。具体地，对于当前结点的左子结点，求出以该左子结点为根的子...
求任意二叉树中第一条最长的路径长度，并输出此路径上各结点的值
clementchueng的博客
05-03 3903
#include <stdio.h> #include <stdlib.h> #define TElemType int //初始化队头和队尾指针 int front = 0, rear = 0; typedef struct BiTNode { TElemType data; //数据域 struct BiTNode *lchild, *rchild; //左右孩子指针 } BiTNode, *BiTree; void Crea
求二叉树最长路径和所有路径
suiyu_4572的博客
05-13 714
求最长路径 采用递归的方法，比较左右子树的高度，输出深度最大的那棵树的根节点。 int Depth(BiTree T) { if (T == NULL) return 0; return 1 + (Depth(T->lchild) > Depth(T->rchild) ? Depth(T->lchild) : Depth(T->rchild)); //左右子树高度最大的那颗子树的高度加一就是树的高度 } void Long(BiTree T
二叉树的最长路径
IBelieve2016的博客
04-19 3963
在一个二叉树中，输出从根节点到叶子节点的最长路径。 首先，找到最长的长度是比较容易的，直接求数的高度就可以，但是如果输出该条路径，需要两个节点数组来记录路径。 求树的高度的代码如下：int BinaryTree :: Depth (BinTreeNode *t ) { if ( t == NULL ) return -1; else return 1 + Max ( Depth
【数据结构与算法】二叉树中从每个叶子结点到根结点的路径
知识虔诚的信徒，探索所有未知是信徒毕生的信仰
07-04 4070
请设计一个算法输出二叉树中从每个叶子结点到根结点的路径
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

多低调

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

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

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

打赏作者

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

抵扣说明：

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

余额充值