关于树的遍历

最新推荐文章于 2024-10-16 19:08:56 发布
最新推荐文章于 2024-10-16 19:08:56 发布
阅读量715 收藏 20
点赞数 9
分类专栏： 算法与数据结构 文章标签： 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/DaisyMaria/article/details/141818515
版权

我感觉“树的遍历”中的题目与“二叉树的遍历”思路有许多相似之处，对比对照着学习可以加深印象

 

1.树的先根遍历

 

二叉树先序遍历是一种深度优先遍历方法，首先访问根节点，然后递归地访问左子树，最后递归地访问右子树。

核心代码是：

vector<int> pre; // 存储先序遍历结果

void preOrder(int root) {
    if (root == -1) { // 如果当前节点为空，直接返回
        return;
    }

    pre.push_back(root); // 访问当前节点
    preOrder(nodes[root].l); // 递归访问左子树
    preOrder(nodes[root].r); // 递归访问右子树
} 

 

 本题中的数据结构是树，与二叉树有所不同，先序遍历需要使用深度优先搜索（DFS）来实现这一过程。DFS通过递归的方式，先访问当前根节点，然后依次访问其子节点，从而实现先根遍历，核心代码：

void preOrder(int root) 
{
    pre.push_back(root);//访问当前结点
    for (int i = 0; i < nodes[root].children.size(); i++)
    {
        preOrder(nodes[root].children[i]);//递归访问子结点
    }
}

#define _CRT_SECURE_NO_WARNINGS
#include <cstdio>
#include <vector>
using namespace std;

const int MAXN = 50;

struct Node 
{
	vector<int> children;
}nodes[MAXN];

vector<int> pre;

void preOrder(int root) 
{
	pre.push_back(root);//访问当前结点
	for (int i = 0; i < nodes[root].children.size(); i++)
	{
		preOrder(nodes[root].children[i]);//递归访问子结点
	}
}

int main()
{
	int n, k, child;
	scanf("%d", &n);

	for (int i = 0; i < n; i++)
	{
		scanf("%d", &k);
		for (int j = 0; j < k; j++)
		{
			scanf("%d", &child);
			nodes[i].children.push_back(child);
		}
	}

	preOrder(0);//从根节点开始先根遍历

	for (int i = 0; i < pre.size(); i++)
	{
		printf("%d", pre[i]);
		if (i < pre.size() - 1)
			printf(" ");
	}

	return 0;
}

2.树的后根遍历

 二叉树的后根遍历核心代码：

vector<int> post; // 存储后序遍历结果 

void postOrder(int root) {
    if (root == -1) { // 如果当前节点为空，直接返回
        return;
    }

    postOrder(nodes[root].l); // 递归访问左子树
    postOrder(nodes[root].r); // 递归访问右子树
    post.push_back(root); // 访问当前节点
}

对比二叉树先根和后根遍历的核心代码，可以对树的后根遍历代码顺序进行调整

核心代码：

void postOrder(int root) 
{
    for (int i = 0; i < nodes[root].children.size(); i++)
    {
        postOrder(nodes[root].children[i]);//递归访问子结点
    }

    post.push_back(root);//访问当前结点
}

#define _CRT_SECURE_NO_WARNINGS
#include <cstdio>
#include <vector>
using namespace std;

const int MAXN = 50;

struct Node 
{
	vector<int> children;
}nodes[MAXN];

vector<int> post;

void postOrder(int root) 
{
	for (int i = 0; i < nodes[root].children.size(); i++)
	{
		postOrder(nodes[root].children[i]);//递归访问子结点
	}

	post.push_back(root);//访问当前结点
}

int main()
{
	int n, k, child;
	scanf("%d", &n);

	for (int i = 0; i < n; i++)
	{
		scanf("%d", &k);
		for (int j = 0; j < k; j++)
		{
			scanf("%d", &child);
			nodes[i].children.push_back(child);
		}
	}

	postOrder(0);//从根节点开始先根遍历

	for (int i = 0; i < post.size(); i++)
	{
		printf("%d", post[i]);
		if (i < post.size() - 1)
			printf(" ");
	}

	return 0;
}

 

3.树的层序遍历

考虑使用BFS算法：

#define _CRT_SECURE_NO_WARNINGS
#include <cstdio>
#include <vector>
#include <queue>
using namespace std;

const int MAXN = 50;

struct Node 
{
	vector<int> children;
}nodes[MAXN];

vector<int> layer;

void layerOrder(int root) 
{
	queue<int> q;//创建队列用于BFS
	q.push(root);//将根节点加入队列当中
	while (!q.empty())
	{
		int front = q.front();
		q.pop();
		layer.push_back(front);
		for (int i = 0; i < nodes[front].children.size(); i++)
		{
			q.push(nodes[front].children[i]);
		}
	}
}

int main()
{
	int n, k, child;
	scanf("%d", &n);

	for (int i = 0; i < n; i++)
	{
		scanf("%d", &k);
		for (int j = 0; j < k; j++)
		{
			scanf("%d", &child);
			nodes[i].children.push_back(child);
		}
	}

	layerOrder(0);//从根节点开始先根遍历

	for (int i = 0; i < layer.size(); i++)
	{
		printf("%d", layer[i]);
		if (i < layer.size() - 1)
			printf(" ");
	}

	return 0;
}

4.树的高度

3.二叉树的高度 的三种解法

这道题答案的解法类似于 ↑ 中的第三种解法（当然↑中的 方法2 同样可以适用于这里）：

有点类似于从定义出发。首先，树的高度指树中结点的最大高度

于是答案把目标转化成，树的高度= max（根左节点Height，根右节点Height）+1

核心代码：

int getHeight(int root) {
    if (root == -1) { // 如果当前节点为空，返回0
        return 0;
    }
    int leftHeight = getHeight(nodes[root].l); // 递归计算左子树高度
    int rightHeight = getHeight(nodes[root].r); // 递归计算右子树高度
    return max(leftHeight, rightHeight) + 1; // 返回左子树高度和右子树高度的最大值加1
}

但是这里不是二叉树，是树。所以要稍微调整思路，通用使用DFS递归思路，核心代码：

int getHeight(int root) {
    int maxHeight = 0;
    for (int i = 0; i < nodes[root].children.size(); i++)
    {
        // 递归计算每个子节点的高度
        maxHeight = max(maxHeight, getHeight(nodes[root].children[i]));
    }
    return maxHeight + 1;// 当前节点的高度为子节点最大高度加1
}

#define _CRT_SECURE_NO_WARNINGS
#include <cstdio>
#include <vector>
#include <algorithm>
using namespace std;

const int MAXN = 50;

struct Node 
{
	vector<int> children;
}nodes[MAXN];

vector<int> layer;

// 递归计算节点高度
int getHeight(int root) {
	int maxHeight = 0;
	for (int i = 0; i < nodes[root].children.size(); i++)
	{
		// 递归计算每个子节点的高度
		maxHeight = max(maxHeight, getHeight(nodes[root].children[i]));
	}
	return maxHeight + 1;// 当前节点的高度为子节点最大高度加1
}

int main()
{
	int n, k, child;
	scanf("%d", &n);

	for (int i = 0; i < n; i++)
	{
		scanf("%d", &k);
		for (int j = 0; j < k; j++)
		{
			scanf("%d", &child);
			nodes[i].children.push_back(child);
		}
	}

	printf("%d", getHeight(0));//计算并输出树的高度

	return 0;
}

5.树的结点层号

这道题没什么好说的 

#define _CRT_SECURE_NO_WARNINGS
#include <cstdio>
#include <vector>
#include <queue>
using namespace std;

const int MAXN = 50;

struct Node
{
	vector<int> children;
}nodes[MAXN];

int layers[MAXN];

void layerOrder(int root)
{
	queue<int> q;//创建队列用于BFS
	q.push(root);//将根节点加入队列当中

	int layer = 1;//初始层号为1

	while (!q.empty())
	{
		int cnt = q.size();//当前层的节点数量
		for (int i = 0; i < cnt; i++)
		{
			int front = q.front();
			q.pop();

			layers[front] = layer;//记录当前结点的层号

			for (int i = 0; i < nodes[front].children.size(); i++)
			{
				q.push(nodes[front].children[i]);//将子结点加入队列
			}
		}
		layer++;//层号加1
	}
}

int main()
{
	int n, k, child;
	scanf("%d", &n);

	for (int i = 0; i < n; i++)
	{
		scanf("%d", &k);
		for (int j = 0; j < k; j++)
		{
			scanf("%d", &child);
			nodes[i].children.push_back(child);
		}
	}

	layerOrder(0);//从根节点开始进行层序遍历

	for (int i = 0; i < n; i++)
	{
		printf("%d", layers[i]);
		if (i < n - 1)
			printf(" ");
	}

	return 0;
}

6.树的路径和

二叉树的核心代码：

int treePathSum = 0;
void getTreePathSum(int root, int nodePathSum)
{
    if (root == -1) return; // 如果当前结点不存在，直接返回
 
    nodePathSum += nodes[root].data;// 累加当前结点的权值到路径和
 
    if (nodes[root].l == -1 && nodes[root].r == -1) // 如果当前结点是叶结点
    {
        treePathSum += nodePathSum; // 累加路径和到总路径和
    }
    else
    {
        getTreePathSum(nodes[root].l, nodePathSum);//递归遍历左子结点
        getTreePathSum(nodes[root].r, nodePathSum);//递归遍历右子结点
    }
} 

树（本题）的核心代码：

int treePathSume = 0;

void getTreePathSum(int root, int nodePathSum)
{
    //累加当前节点的权值到路径和
    nodePathSum += nodes[root].data;

    if (nodes[root].children.empty())
    {
        // 如果是叶子节点，累加路径和到总路径和
        treePathSume += nodePathSum;
    }

    //如果不是叶子结点，则需要继续遍历
    for (int i = 0; i < nodes[root].children.size(); i++)
    {
        getTreePathSum(nodes[root].children[i], nodePathSum);
    }
}

#define _CRT_SECURE_NO_WARNINGS
#include <cstdio>
#include <vector>
#include <algorithm>
using namespace std;

const int MAXN = 50;

struct Node
{
	int data;
	vector<int> children;
}nodes[MAXN];

int treePathSume = 0;

void getTreePathSum(int root, int nodePathSum)
{
	//累加当前节点的权值到路径和
	nodePathSum += nodes[root].data;

	if (nodes[root].children.empty())
	{
		// 如果是叶子节点，累加路径和到总路径和
		treePathSume += nodePathSum;
	}

	//如果不是叶子结点，则需要继续遍历
	for (int i = 0; i < nodes[root].children.size(); i++)
	{
		getTreePathSum(nodes[root].children[i], nodePathSum);
	}
}


int main()
{
	int n, k, child;
	scanf("%d", &n);

	for (int i = 0; i < n; i++)
	{
		scanf("%d", &nodes[i].data);
	}

	for (int i = 0; i < n; i++)
	{
		scanf("%d", &k);
		for (int j = 0; j < k; j++)
		{
			scanf("%d", &child);
			nodes[i].children.push_back(child);
		}
	}

	getTreePathSum(0, 0);
	printf("%d", treePathSume);

	return 0;
}

 

7.树的带权路径长度

二叉树-核心代码：

//DFS函数，计算带权路径长度
void getTreeWeightedPathLength(int root, int nodePathLength) 
{
    if (root == -1)return;//如果结点不存在，返回
 
    if (nodes[root].l == -1 && nodes[root].r == -1)// 如果是叶节点
    {
        treeWeightedPathLength += nodes[root].data * nodePathLength;

        //计算带权路径长度并累加
    }
    else
    {
        nodePathLength++;//路径长度加一
        getTreeWeightedPathLength(nodes[root].l, nodePathLength);//递归访问左子结点
        getTreeWeightedPathLength(nodes[root].r, nodePathLength);//递归访问右子结点
    } 
}

 树-核心代码：

void getTreePathLength(int root, int edgeCount)
{
    if (nodes[root].children.empty())
    {
        // 如果是叶子节点，累加路径和到总路径和
        treePathLength += nodes[root].data*edgeCount;
    }

    //如果不是叶子结点，则需要继续遍历
    for (int i = 0; i < nodes[root].children.size(); i++)//遍历子结点
    {
        getTreePathLength(nodes[root].children[i], edgeCount+1);//递归调用
    }
}

#define _CRT_SECURE_NO_WARNINGS
#include <cstdio>
#include <vector>
#include <algorithm>
using namespace std;

const int MAXN = 50;

struct Node
{
	int data;
	vector<int> children;
}nodes[MAXN];

int treePathLength = 0;

void getTreePathLength(int root, int edgeCount)
{
	if (nodes[root].children.empty())
	{
		// 如果是叶子节点，累加路径和到总路径和
		treePathLength += nodes[root].data*edgeCount;
	}

	//如果不是叶子结点，则需要继续遍历
	for (int i = 0; i < nodes[root].children.size(); i++)//遍历子结点
	{
		getTreePathLength(nodes[root].children[i], edgeCount+1);//递归调用
	}
}


int main()
{
	int n, k, child;
	scanf("%d", &n);

	for (int i = 0; i < n; i++)
	{
		scanf("%d", &nodes[i].data);
	}

	for (int i = 0; i < n; i++)
	{
		scanf("%d", &k);
		for (int j = 0; j < k; j++)
		{
			scanf("%d", &child);
			nodes[i].children.push_back(child);
		}
	}

	getTreePathLength(0, 0);
	printf("%d", treePathLength);

	return 0;
}
Hilda Leung
关注
专栏目录
树的遍历
qq_40818336的博客
04-23 5545
树 树作为一种高效的查找数据结构，被广泛应用在各种查询场景。今天我们就来总结一下树的有关知识。
树的遍历算法
medouyoulo的博客
07-12 3861
树的遍历算法Python实现
树的几种遍历方法介绍
liitdar的博客
03-14 3846
与线性数据结构（如数组、链表、队列、栈）只有一种遍历逻辑方法不同，树可以通过不同的方法进行遍历。常见的树的遍历方法包括：中序遍历（InOrder Traversal）、前序遍历（PreOrder Traversal）及后序遍历（PostOrder Traversal）。
数据结构——树的遍历
不如打代码
05-02 3404
数据结构——树的遍历 1.树的基本概念 树是一种非常有用的数据结构，数据库的实现很多底层实现是基于树结构的，比如mysql innodb存储引擎的索引就是基于B+树的。树是一种由节点组成的数据结构，但它比链表更加高级，在链表中，一个节点连接着另一个节点，树也是由许多的节点构成的，唯一的区别就是一个树节点可以连接多个树节点，一颗树只有一个根节点，根节点作为起源，由它展开一个树状的数据结构。 在实现树之前，我们来了解一下树的基本定义： 在树中，每个节点都含有自己的数值，以及与之相连的子节点，连接节点的线叫做相连
java多叉树遍历算法_多叉树的深度优先遍历并输出叶子路径
weixin_33212799的博客
02-25 1261
在做项目的过程中，遇到了多叉树的访问问题，其中要求保存访问至叶子节点的路径，查找网上资料都不是很合心意，故而自己用比较笨的方法保存然后输出多叉树结构：class DataModel{public string name { get; set; }public List children { get; set; } = new List();}递归深度遍历多叉树，并保存路径public static...
树的层次遍历
热门推荐
听得到微笑的博客
02-15 4万+
二叉树的前序、中序、后序遍历我想大家应该都很熟悉了，那我们今天就来讲一下二叉树的层次遍历。 二叉树的前序、中序、后序遍历需要用到栈（递归的过程也就是一个栈），层次遍历需要借助队列这个数据结构。 层次遍历的思路 我们给出一个二叉树： 这棵二叉树的层次遍历次序为：A、B、C、D、F、G 以人的思维来看层次遍历貌似比前、中、后序遍历更加简单易懂，但是程序到底如何实现这样的效果呢...
c语言——树的遍历
weixin_61375386的博客
03-19 4052
最近学习了树和二叉树的知识，所以今天写了一个关于树的创建和遍历的代码。树的三种遍历方式，分别是，先序遍历：根左右，中序遍历：左根右，后序遍历：左右根。然后需要创建链表，存放根结点和左右孩子。 递归遍历： #include<stdio.h> #include<stdlib.h> struct bitnode { char Date;//根结点 struct bitnode* Lchild;//左子树 struct bitnode* Rchild;//右子树 }; //创..
B+树遍历与查找
XiaoGong1688的博客
08-30 8125
这一次我们来介绍 B+ 树。 一个m阶的B树具有如下几个特征： 1.根结点至少有两个子女。 2.每个中间节点都包含k-1个元素和k个孩子，其中 m/2 <= k <= m 3.每一个叶子节点都包含k-1个元素，其中 m/2 <= k <= m 4.所有的叶子结点都位于同一层。 5.每个节点中的元素从小到大排列，节点当中k-1个元素正好是k个孩子包...
Python 树的遍历
zhaohui blog
12-06 5156
二叉树的遍历 递归和非递归实现 N叉树的遍历实现
多叉树的前序遍历
Pichairen
11-07 1351
参考连接https://www.jianshu.com/p/b6dd69a80ce6 这里需要注意一下，二叉树的前序遍历中直接右子节点先入栈然后左子节点入栈，在多叉树中，某个节点存在多个子节点，使用for循环逆序遍历入栈即可。 ...
三叉树多叉树遍历
04-21
三叉树多叉树遍历 c# 2.0
基于Python的多叉树遍历算法.zip
10-16
本资料包"基于Python的多叉树遍历算法.zip"主要探讨如何在Python中实现多叉树的遍历算法。下面我们将详细讨论多叉树的概念、遍历方法以及如何用Python来实现这些算法。 一、多叉树的基本概念 多叉树是由节点和边...
Python解析树及树的遍历
09-21
本文将详细介绍如何在Python中实现解析树，并探讨如何进行二叉树的三种遍历：先序遍历、中序遍历和后序遍历。 首先，让我们深入解析树的概念。在图1中，展示了一个简单句子的解析树，它清楚地表达了句子的组成部分...
多叉树 遍历
05-25
在IT领域，多叉树是一种数据结构，它...总之，多叉树遍历是理解和操作这种数据结构的关键。通过掌握不同类型的遍历方法，我们可以有效地在多种IT场景中利用多叉树解决问题，无论是数据处理、搜索算法还是其他复杂任务。
【算法】双指针
2303_80828380的博客
10-13 801
力扣oj题之双指针算法
C++中的vector介绍（常用函数）
zxybf_的博客
10-15 785
vector的文档介绍vector是序列容器，表示可以改变大小的数组。(constructor)构造函数声明接口说明vector()（重点）无参构造构造并初始化n个val（重点）拷贝构造使用迭代器进行初始化构造int main()//无参的构造//n个val的构造//拷贝构造//迭代器区间构造return 0;
Python 使用 Jarvis 算法或包装的凸包（Convex Hull using Jarvis’ Algorithm or Wrapping）
csdn_aspnet的专栏
10-14 1221
例如，当输入 (0, 3), (0, 0), (0, 1), (3, 0), (3, 3) 时，它产生 (0, 3) (0, 0) (3, 0) (3, 3) 的输出；当输入 (0, 3), (0, 1), (0, 0), (3, 0), (3, 3) 时，输出为 (0, 3) (0, 1) (0, 0) (3, 0) (3, 3)。下一个点被选为在逆时针方向上领先于所有其他点的点，即，如果对于任何其他点 r，我们有“orientation(p, q, r) = 逆时针”，则下一个点是 q。
数据结构常考基础代码题-数组倒置
最新发布
qq_52291558的博客
10-16 456
根据题目中的“将数组中的元素顺序反转”，我们需要实现一个函数Reverse，用于反转数组中从start到end的元素。// 函数用于反转数组A中从start到end的元素int temp;// 使用while循环进行元素交换，直到start和end相遇或交叉// 保存A[start]的值// 将A[end]的值赋给A[start]// 将temp（原A[start]的值）赋给A[end]start++;// 移动start指针end--;// 移动end指针。
深入探索数据结构：冒泡与树遍历源代码
资源摘要信息:"本资源包是一系列关于数据结构的C++源代码，包含了多种测试用例和算法实现，其中最为核心的部分是冒泡排序算法和树的遍历方法。冒泡排序是一种简单的排序算法，它重复地遍历要排序的数列，一次比较两...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值