构建二叉树&宽度优先遍历&深度优先遍历-儿童编程

最新推荐文章于 2024-05-04 17:55:32 发布
最新推荐文章于 2024-05-04 17:55:32 发布
阅读量147 收藏
点赞数
分类专栏： 少儿编程 文章标签： 二叉树 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/pkuyjxu/article/details/116397590
版权 
#include <bits/stdc++.h>

using namespace std;

 typedef struct TreeNode{
		int data =0;
		TreeNode *left_child = NULL;
		TreeNode *right_child = NULL;
} TreeNode;

 

层序遍历/宽度优先遍历/BFS


void bfs(TreeNode *head){
	queue<TreeNode *> q;
	q.push(head);
	while(!q.empty()){
		TreeNode * tn = q.front();
		q.pop();
		if(tn != NULL){
			cout<<tn->data<<" ";
			if(tn->left_child != NULL)
				q.push(tn->left_child);
			if(tn->right_child != NULL)
				q.push(tn->right_child);
		}

	}
}

深度优先搜索 DFS : 前序优先

void preDFS(TreeNode *head){
	if(head == NULL){
		return;
	}
	else{
		cout<<head->data<<" ";
		preDFS(head->left_child);
		preDFS(head->right_child);
	}
}

深度优先搜索 DFS : 中序优先 和后序优先

void inDFS(TreeNode *head){
	if(head == NULL){
		return;
	}
	else{
		
		inDFS(head->left_child);
		cout<<head->data<<" ";
		inDFS(head->right_child);
	}
}


void postDFS(TreeNode *head){
	if(head == NULL){
		return;
	}
	else{
		
		postDFS(head->left_child);
		
		postDFS(head->right_child);
		cout<<head->data<<" ";
	}
}

 

 

main函数 & 构建二叉树： 数组方式

int main(){
	
	int n =0;	
	tn[1].data = 1;
	tn[2].data = 2;
	tn[3].data = 7;
	tn[1].left_child = &tn[2];
	tn[1].right_child = &tn[3];
	tn[4].data = 3;
	tn[5].data = 6;
	tn[2].left_child= &tn[4];
	tn[2].right_child = &tn[5];
	tn[6].data = 4;
	tn[7].data = 5;
	tn[4].left_child = &tn[6];
	tn[4].right_child = &tn[7];


	
	bfs(&tn[1]);
	
	return 0;
}

 

main函数 & 构建二叉树： 指针方式（节省内存）

int main(){

	TreeNode *head = (TreeNode *)malloc(sizeof(TreeNode));
	head->data = 1;
	TreeNode *temp_left;
	TreeNode *temp_right;
	TreeNode *left = (TreeNode *)malloc(sizeof(TreeNode));
	TreeNode *right = (TreeNode *)malloc(sizeof(TreeNode));
	left->data = 2;
	left->left_child = NULL;
	left->right_child = NULL;
	right->data = 7;
	right->left_child = NULL;
	right->right_child = NULL;
	head->left_child = left;
	head->right_child = right;
	temp_left = left;
	temp_right = right;
	left = (TreeNode *)malloc(sizeof(TreeNode));
	right = (TreeNode *)malloc(sizeof(TreeNode));
	left->data = 3;
	left->left_child = NULL;
	left->right_child = NULL;
	right->data = 6;
	right->left_child = NULL;
	right->right_child = NULL;
	temp_left->left_child = left;
	temp_left->right_child = right;
	temp_left = left;
	temp_right = right;
		left = (TreeNode *)malloc(sizeof(TreeNode));
	right = (TreeNode *)malloc(sizeof(TreeNode));
	left->data = 4;
	left->left_child = NULL;
	left->right_child = NULL;
	right->data = 5;
	right->left_child = NULL;
	right->right_child = NULL;
	temp_left->left_child= left;
	temp_left->right_child = right;
	
	bfs(head);
	cout<<endl;
	preDFS(head);
	cout<<endl;
	inDFS(head);
	cout<<endl;
	postDFS(head);
	cout<<"test";
	return 0;
}

 

代码完整版1

#include <bits/stdc++.h>

using namespace std;

 typedef struct TreeNode{
		int data =0;
		TreeNode *left_child = NULL;
		TreeNode *right_child = NULL;
} TreeNode; 






void bfs(TreeNode *head){
	queue<TreeNode *> q;
	q.push(head);
	while(!q.empty()){
		TreeNode * tn = q.front();
		q.pop();
		if(tn != NULL){
			cout<<tn->data<<" ";
			if(tn->left_child != NULL)
				q.push(tn->left_child);
			if(tn->right_child != NULL)
				q.push(tn->right_child);
		}

	}
}

void preDFS(TreeNode *head){
	if(head == NULL){
		return;
	}
	else{
		cout<<head->data<<" ";
		preDFS(head->left_child);
		preDFS(head->right_child);
	}
}

void inDFS(TreeNode *head){
	if(head == NULL){
		return;
	}
	else{
		
		inDFS(head->left_child);
		cout<<head->data<<" ";
		inDFS(head->right_child);
	}
}


void postDFS(TreeNode *head){
	if(head == NULL){
		return;
	}
	else{
		
		postDFS(head->left_child);
		
		postDFS(head->right_child);
		cout<<head->data<<" ";
	}
}

TreeNode tn[100];

int main(){
	
	int n =0;	
	tn[1].data = 1;
	tn[2].data = 2;
	tn[3].data = 7;
	tn[1].left_child = &tn[2];
	tn[1].right_child = &tn[3];
	tn[4].data = 3;
	tn[5].data = 6;
	tn[2].left_child= &tn[4];
	tn[2].right_child = &tn[5];
	tn[6].data = 4;
	tn[7].data = 5;
	tn[4].left_child = &tn[6];
	tn[4].right_child = &tn[7];


	
	bfs(&tn[1]);
	cout<<endl;
	preDFS(&tn[1]);
	cout<<endl;
	inDFS(&tn[1]);
	cout<<endl;
	postDFS(&tn[1]);
	cout<<"test";
	return 0;
}

代码完整版2： 指针方式

#include <bits/stdc++.h>

using namespace std;

 typedef struct TreeNode{
		int data =0;
		TreeNode *left_child = NULL;
		TreeNode *right_child = NULL;
} TreeNode; 






void bfs(TreeNode *head){
	queue<TreeNode *> q;
	q.push(head);
	while(!q.empty()){
		TreeNode * t = q.front();
		q.pop();
		if(t != NULL){
			cout<<t->data<<" ";
			if(t->left_child != NULL)
				q.push(t->left_child);
			if(t->right_child != NULL)
				q.push(t->right_child);
		}

	}
}

void preDFS(TreeNode *head){
	if(head == NULL){
		return;
	}
	else{
		cout<<head->data<<" ";
		preDFS(head->left_child);
		preDFS(head->right_child);
	}
}

void inDFS(TreeNode *head){
	if(head == NULL){
		return;
	}
	else{
		
		inDFS(head->left_child);
		cout<<head->data<<" ";
		inDFS(head->right_child);
	}
}


void postDFS(TreeNode *head){
	if(head == NULL){
		return;
	}
	else{
		
		postDFS(head->left_child);
		
		postDFS(head->right_child);
		cout<<head->data<<" ";
	}
}

//TreeNode tn[100];

int main(){

	TreeNode *head = (TreeNode *)malloc(sizeof(TreeNode));
	head->data = 1;
	TreeNode *temp_left;
	TreeNode *temp_right;
	TreeNode *left = (TreeNode *)malloc(sizeof(TreeNode));
	TreeNode *right = (TreeNode *)malloc(sizeof(TreeNode));
	left->data = 2;
	left->left_child = NULL;
	left->right_child = NULL;
	right->data = 7;
	right->left_child = NULL;
	right->right_child = NULL;
	head->left_child = left;
	head->right_child = right;
	temp_left = left;
	temp_right = right;
	left = (TreeNode *)malloc(sizeof(TreeNode));
	right = (TreeNode *)malloc(sizeof(TreeNode));
	left->data = 3;
	left->left_child = NULL;
	left->right_child = NULL;
	right->data = 6;
	right->left_child = NULL;
	right->right_child = NULL;
	temp_left->left_child = left;
	temp_left->right_child = right;
	temp_left = left;
	temp_right = right;
		left = (TreeNode *)malloc(sizeof(TreeNode));
	right = (TreeNode *)malloc(sizeof(TreeNode));
	left->data = 4;
	left->left_child = NULL;
	left->right_child = NULL;
	right->data = 5;
	right->left_child = NULL;
	right->right_child = NULL;
	temp_left->left_child= left;
	temp_left->right_child = right;
	
	bfs(head);
	cout<<endl;
	preDFS(head);
	cout<<endl;
	inDFS(head);
	cout<<endl;
	postDFS(head);
	cout<<"test";
	return 0;
}

 

 

 

 

pkuyjxu
关注
专栏目录
【华为OD机试】二叉树的广度优先遍历（二叉树的构建和层次遍历—Java&Python&C++&JS实现）
一键难忘的博客
02-25 3318
【华为OD机试】二叉树的广度优先遍历（二叉树的构建和层次遍历—Java&Python&C++&JS实现） 有一棵二叉树，每个节点由一个大写字母标识(最多26个节点）。现有两组字母，分别表示后序遍历（左孩子->右孩子->父节点）和中序遍历（左孩子->父节点->右孩子）的结果，请输出层次遍历的结果。 输入描述： 输入为两个字符串，分别是二叉树的后续遍历和中序遍历结果。 输出描述： 输出二叉树的层次遍历结果。
二叉树遍历，宽度优先 （js实现）
tangjie109411的博客
11-18 1004
二叉树从左到右，按层遍历就是二叉树的宽度遍历 如下的二叉树图： 因为我是前端开发，所用语言是js，同时网页的dom节点正好是树形存储结构。因此我用js来实现。 实现目标：   遍历二叉树所有节点 分别打印各个树的id，分别是1，2，3，4，5，6，7，8，同时打印id所属的树的层级。 div树结构如下，完成上诉要求： &lt;div data-id=1 id="domparen...
二叉树宽度优先遍历
小宇学Java
05-21 169
import java.util.LinkedList; import java.util.Queue; public class Node { public int value; public Node left; public Node right; public Node(int data){ this.value=data; } //获取一个图的宽度优先遍历 public static void w(Node head){
二叉树的宽度优先遍历
weixin_41767070的博客
06-28 217
#include <iostream> #include <queue> using namespace std; struct TreeNode { int val; TreeNode* left; TreeNode* right; TreeNode(int a) :val(a), left(NULL), right(NULL) {}; }; 单纯的宽度优先 v...
二叉树的宽度优先遍历和深度优先遍历
愿得一人心&&的博客
07-05 4586
二叉树的宽度优先遍历和深度优先遍历 1.宽度优先遍历： 即从根节点开始依次遍历左子节点和右子节点，直到所有子节点都变遍历完为止。 例如： （此二叉树图片来源于网络） 遍历顺序为：从根节点1开始依次遍历左子节点2和右子节点3，下一步分别以左右子节点为根节点，分别遍历对应的左右子节点4,5和6,7。 即最终的遍历顺序为：1234567 2.深度优先搜索 即从根节点开始一直遍历左子节点，直到左子...
二叉树的创建与遍历简介
11-15
此外，还有一种层序遍历，也称为宽度优先遍历，从根节点开始，按照层次从左到右依次访问所有节点。这通常使用队列来实现。 在实际应用中，二叉树被广泛用于各种场景，如文件系统、数据库索引、编译器符号表管理等。...
Java实现求二叉树的深度和宽度
09-03
2. **二叉树宽度**： - 二叉树的宽度是指在某一层次上的节点数量的最大值，即最大宽度。为了计算宽度，我们可以采用层次遍历（BFS，广度优先搜索）的方法。同样，我们使用队列`Queue<TreeNode>`来辅助遍历： ```...
二叉树的建立与遍历以及广义表形式输出
11-27
可以通过自底向上的深度优先遍历来实现，每次遇到叶节点时更新最大深度，或者自顶向下的宽度优先遍历，记录每一层节点数量，最大层数即为深度。 至于“广义表形式输出”，广义表是一种可以表示任意层次嵌套的数据...
二叉树的创建与遍历实验报告
实验者需要通过键盘输入字符串来构建二叉树，并实现各种操作的代码。" 在数据结构领域，二叉树是一种重要的非线性数据结构，它由n（n>=0）个有限节点组成，这些节点通过边连接形成一个具有层次关系的集合。每个节点...
二叉树的宽度（广度）优先遍历C++
ymhdt的博客
07-26 1732
二叉树的宽度优先遍历，又叫广度优先遍历、层序优先遍历。二叉树的宽度优先遍历可以使用队列完成。
算法学习14：二叉树的宽度优先遍历
effort_study的博客
03-09 218
分析 宽度优先遍历使用队列，先进先出，弹出就先放左再放右 代码 void levelOrder(Tree* head){ queue<Tree*> t; if(head==nullptr){ return; } t.push(head); while(!t.empty()){ head=t.front(); cout<<t.front()->val; if(head->left!=nullptr){ t.push(head->left
二叉树遍历（宽度优先）入门
dh7995的博客
03-13 116
二叉树遍历（宽度优先）入门 算法思路: 使用一个队列（可以是数组或链表）来完成。初始时只有一个根节点，然后每次取出一个结点，就把它的左右儿子（如果有）放入队列。 源代码如下： 　　 封装成头文件 "BinaryTree.h" 和与之对应的实现文件 1 #ifndef BINARYTREE_H 2 #define BINARYTREE_H 3 ...
二叉树广度优先遍历算法
YZxiaoJT的博客
02-03 344
源代码： #include <iostream> #include <cstdlib> #include <queue> using namespace std; typedef struct Node { char root; struct Node *lchild; struct Node *rchild; } *Tree; //广度优先遍历 void breadthFirstSearch(Tree root) { if (!roo
算法部分之二叉树的深度优先、宽度优先遍历。
Jerry 没有 Tom
01-03 693
 一直对深度优先和广度优先搜索的概念不是很清楚， 代码上也不是很懂。 今天终于是有时间来仔细的了解一下了。 看了不少博客，很多都是直接随便甩个代码看着很纠结， 那我就自己写吧！ 循环的效率比递归要高，所以我就用循环来写。  我们先给出一个树，以及需要用到的STL模板类 //出给用到两个STL模板类 #include &lt;stack&gt; #include &lt;queue&gt; ...
二叉树的深度优先遍历和广度优先遍历
weixin_43614465的博客
03-25 419
#!/usr/bin/env python3 class binaryTreeNone(object): def __init__(self,x): self.val = x self.left =None self.right = None ##递归实现 def pre(self,root): ##先序遍历 i...
二叉树广度优先遍历（BFS） & 深度优先遍历（DFS）
qq_41930096的博客
02-22 216
二叉树的遍历    树的遍历是一种重要的运算。所谓遍历是指对树中所有节点信息的访问，即一次对树中每个接地访问一次且仅访问一次，将这种对所有节点的访问称为遍历（travelsal）。 树的两种重要遍历模式是深度优先遍历（DFS）和广度优先遍历（BFS），BFS 一般用遍历，DFS一般用队列。一般情况下能用递归实现的算法大部分也可以用堆栈实现。 广度优先遍历（层次遍历） ...
【力扣算法】105-从前序与中序遍历序列构造二叉树
ZeromaXHe的博客
06-20 530
题目 根据一棵树的前序遍历与中序遍历构造二叉树。 注意: 你可以假设树中没有重复的元素。 例如，给出 前序遍历 preorder = [3,9,20,15,7] 中序遍历 inorder = [9,3,15,20,7] 返回如下的二叉树： 3 / \ 9 20 / \ 15 7 来源：力扣（LeetCode） 链接：https://leetcode-cn...
树以及树的遍历：宽度优先搜索BFS c++的代码实现
最新发布
LovelyCat_mm的博客
05-04 1271
【输出格式】 输出一行，包括若干个大写字母，描述小球到达空洞的完整移动步骤，其中'U'代表向上走，'D'代表向下走，'L'代表向左走，'R'代表向右走。针对刚刚的图是有的，我们好好观察一下就会发现按照BFS的访问顺序就是1，2，3，4，5，6。他的原理是，先将父节点入队，判断是否符合要求，如果符合就可以退出循环了，如果不符，就继续将父节点的两个儿子入队，直到找到符合要求的结果为止。第2到n+1行 ，每行m个字母，描述棋盘的具体信息，其中'.'代表空格⼦，'#'代表障碍，'O'代表空洞，'B'代表球。
通过中序前序遍历重构二叉树层次结构
"在Java编程中，我们遇到一个问题：给定一棵二叉树的中序遍历字符串和前序遍历字符串，要求恢复该树按照层次进行的遍历字符串。这个问题涉及到二叉树的重构，特别是基于二叉树的两种基本遍历方式——前序遍历（根-左...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值