二叉树 (C++)

最新推荐文章于 2024-06-09 20:18:37 发布
最新推荐文章于 2024-06-09 20:18:37 发布
阅读量601 收藏 2
点赞数 3
分类专栏： 数据结构 文章标签： c++ 算法 数据结构 leetcode 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_60404548/article/details/128148595
版权

二叉树

1.前言

数据结构 二叉树

测试数据：利用先序遍历二叉树建树（包括所有空结点）
'*'表示空结点

①测试数据1

ABC**DE*G**F***
树1：
	    A
	 B
   C    D
      E   F
       G
树深度为5(根结点为1时)， 3个叶结点C、G、F
先序遍历：ABCDEGF
中序遍历：CBEGDFA
后序遍历：CGEFDBA
层序遍历：ABCDEFG

②测试数据2

AB**CD***
树2：
		A
	  B   C
	     D
树深度为3(根结点为1时)，2个叶结点B、D
先序遍历：ABCD
中序遍历：BADC
后序遍历：BDCA
层序遍历：ABCD

2.内容

1.二叉树的遍历

①先序遍历

[1]递归
//Recursion Preorder Traverse
void Preorder(const Tree& T, vector<ElemType>& v)
{
	if (T == nullptr) return;
	v.emplace_back(T->val);  //根
	Preorder(T->left, v);    //左
	Preorder(T->right, v);   //右
}
vector<ElemType> PreorderTraversal(const Tree& T)
{
	vector<ElemType> v;
	Preorder(T, v);
	return v;
}
[2]迭代
	stack<Tree> preOrderStk;
	vector<ElemType> preOrderVec;
	Tree preTree = T;
	while (preTree || preOrderStk.size())
	{
		while (preTree)
		{
			preOrderVec.emplace_back(preTree->val);
			preOrderStk.emplace(preTree);
			preTree = preTree->left;
		}
		preTree = preOrderStk.top();
		preOrderStk.pop();
		preTree = preTree->right;
	}
	printf("迭代先序遍历：");
	for (const ElemType& x : preOrderVec)
		cout << x;
	puts("");
力扣先序遍历

144. 二叉树的前序遍历

②中序遍历

[1]递归
//Recursion Inorder Traverse
void Inorder(const Tree& T, vector<ElemType>& v)
{
	if (T == nullptr) return;
	Inorder(T->left, v);    //左
	v.emplace_back(T->val); //根
	Inorder(T->right, v);   //右
}
vector<ElemType> InorderTraversal(const Tree& T)
{
	vector<ElemType> v;
	Inorder(T, v);
	return v;
}
[2]迭代
	stack<Tree> inOrderStk;
	vector<ElemType> inOrderVec;
	Tree inTree = T;
	while (inTree || inOrderStk.size())
	{
		while (inTree)
		{
			inOrderStk.emplace(inTree);
			inTree = inTree->left;
		}
		inTree = inOrderStk.top();
		inOrderStk.pop();
		inOrderVec.emplace_back(inTree->val);
		inTree = inTree->right;
	}
	printf("迭代中序遍历为：");
	for (const ElemType& x : inOrderVec)
		cout << x;
	puts("");
力扣中序遍历

94. 二叉树的中序遍历

③后序遍历

[1]递归
//Recursion Postorder Traverse
void Postorder(const Tree& T, vector<ElemType>& v)
{
	if (T == nullptr) return;
	Postorder(T->left, v);
	Postorder(T->right, v);
	v.emplace_back(T->val);
}
vector<ElemType> PostorderTraversal(const Tree& T)
{
	vector<ElemType> v;
	Postorder(T, v);
	return v;
}
[2]迭代
	stack<Tree> postOrderStk;
	vector<ElemType> postOrderVec;
	Tree postTree = T;
	Tree prev = nullptr;
	while (postTree || postOrderStk.size())
	{
		while (postTree)
		{
			postOrderStk.emplace(postTree);
			postTree = postTree->left;
		}
		postTree = postOrderStk.top();
		postOrderStk.pop();
		if (postTree->right == nullptr || postTree->right == prev) //无右子树 或 为第二次遍历的根
		{
			postOrderVec.emplace_back(postTree->val);
			prev = postTree;
			postTree = nullptr;
		}
		else {
			postOrderStk.emplace(postTree);
			postTree = postTree->right;
		}
	}
	printf("迭代后序遍历为：");
	for (const ElemType& x : postOrderVec)
		cout << x;
	puts("");
力扣后序遍历

145. 二叉树的后序遍历

④层序遍历

[1]队列
	//[1]队列  传空树时要特判
	queue<Tree> levelOrderQue;
	vector<vector<ElemType>> levelOrderVec;
	vector<ElemType> leafVec;   //叶结点
	levelOrderQue.emplace(T);
	while (levelOrderQue.size())
	{
		int sz = levelOrderQue.size();
		vector<ElemType> v;
		for (int i = 0; i < sz; ++i)
		{
			auto t = levelOrderQue.front();
			levelOrderQue.pop();

			v.emplace_back(t->val);
			if (t->left) levelOrderQue.emplace(t->left);
			if (t->right) levelOrderQue.emplace(t->right);
			if (t->left == nullptr && t->right == nullptr) leafVec.emplace_back(t->val);  //叶结点
		}
		levelOrderVec.emplace_back(v);
	}
	cout << "树的深度为: " << levelOrderVec.size() << endl;
	cout << "树的叶结点个数为: " << leafVec.size() << " 分别为: ";
	for (const ElemType& x : leafVec)
		cout << x << " ";
	puts("");
	printf("层序遍历为：");
	for (const vector<ElemType>& x : levelOrderVec)
		for (const ElemType& y : x)
			cout << y;
	puts("");
2.队列 + 哈希
	//[2]队列 + 哈希[注意传入空树时，要特判！]
	queue<Tree> q;
	unordered_map<int, vector<ElemType>> v;
	unordered_map<Tree, int> dep;
	vector<ElemType> leaf;
	q.emplace(T);
	dep[T] = 0;
	int depth = 0;
	while (q.size())
	{
		auto t = q.front();
		q.pop();

		int d = dep[t];
		v[d].emplace_back(t->val);
		if (t->left) q.emplace(t->left), dep[t->left] = d + 1;
		if (t->right) q.emplace(t->right), dep[t->right] = d + 1;
		if (t->left == nullptr && t->right == nullptr) leaf.emplace_back(t->val), depth = max(depth, d);
	}
	cout << "树的深度为：" << depth + 1 << endl;
	cout << "树的叶结点数为：" << leaf.size() << " 分别是：";
	for (auto l : leaf)
		cout << l << " ";
	puts("");
	printf("层序遍历为：");
	for (int i = 0; i <= depth; ++i)
		for (auto x : v[i])
			cout << x;
	puts("");
力扣层序遍历

102. 二叉树的层序遍历

※※二叉树遍历的完整代码

#define _CRT_SECURE_NO_WARNINGS 1

#include <iostream>
using namespace std;
#include <vector>  
#include <stack>  //迭代先序、中序、后序遍历
#include <queue> //层序遍历1
#include <unordered_map> //层序遍历2

//Definations
typedef char ElemType;
typedef struct TreeNode {
	ElemType val;
	struct TreeNode* left, * right;
	TreeNode() :val(-1), left(nullptr), right(nullptr) {}
	TreeNode(ElemType e) :val(e), left(nullptr), right(nullptr) {}
}TreeNode, *Tree;

//Build BiTree
void InitBiTree(Tree& T)
{
	char ch;
	scanf("%c", &ch);
	if (ch == '*') T = nullptr;
	else {
		T = (Tree)malloc(sizeof(TreeNode));
		if(T == NULL)exit(OVERFLOW);

		T->val = ch;
		InitBiTree(T->left);
		InitBiTree(T->right);
	}
}

//Recursion Preorder Traverse
void Preorder(const Tree& T, vector<ElemType>& v)
{
	if (T == nullptr) return;
	v.emplace_back(T->val);  //根
	Preorder(T->left, v);    //左
	Preorder(T->right, v);   //右
}
vector<ElemType> PreorderTraversal(const Tree& T)
{
	vector<ElemType> v;
	Preorder(T, v);
	return v;
}
//Recursion Inorder Traverse
void Inorder(const Tree& T, vector<ElemType>& v)
{
	if (T == nullptr) return;
	Inorder(T->left, v);    //左
	v.emplace_back(T->val); //根
	Inorder(T->right, v);   //右
}
vector<ElemType> InorderTraversal(const Tree& T)
{
	vector<ElemType> v;
	Inorder(T, v);
	return v;
}
//Recursion Postorder Traverse
void Postorder(const Tree& T, vector<ElemType>& v)
{
	if (T == nullptr) return;
	Postorder(T->left, v);
	Postorder(T->right, v);
	v.emplace_back(T->val);
}
vector<ElemType> PostorderTraversal(const Tree& T)
{
	vector<ElemType> v;
	Postorder(T, v);
	return v;
}

int main()
{
	//1.建树
	Tree T;
	InitBiTree(T);

	//2.递归遍历
	//[1]先序
	vector<ElemType> preOrderVector = PreorderTraversal(T);
	printf("递归先序遍历：");
	for (const ElemType ch : preOrderVector)
		cout << ch;
	puts("");
	//[2]中序
	vector<ElemType> inOrderVector = InorderTraversal(T);
	printf("递归中序遍历：");
	for (const ElemType ch : inOrderVector)
		cout << ch;
	puts("");
	//[3]后序
	vector<ElemType> postOrderVector = PostorderTraversal(T);
	printf("递归后序遍历：");
	for (const ElemType ch : postOrderVector)
		cout << ch;
	puts("");

	//3.迭代遍历
	//[1]先序
	stack<Tree> preOrderStk;
	vector<ElemType> preOrderVec;
	Tree preTree = T;
	while (preTree || preOrderStk.size())
	{
		while (preTree)
		{
			preOrderVec.emplace_back(preTree->val);
			preOrderStk.emplace(preTree);
			preTree = preTree->left;
		}
		preTree = preOrderStk.top();
		preOrderStk.pop();
		preTree = preTree->right;
	}
	printf("迭代先序遍历：");
	for (const ElemType& x : preOrderVec)
		cout << x;
	puts("");


	//中序
	stack<Tree> inOrderStk;
	vector<ElemType> inOrderVec;
	Tree inTree = T;
	while (inTree || inOrderStk.size())
	{
		while (inTree)
		{
			inOrderStk.emplace(inTree);
			inTree = inTree->left;
		}
		inTree = inOrderStk.top();
		inOrderStk.pop();
		inOrderVec.emplace_back(inTree->val);
		inTree = inTree->right;
	}
	printf("迭代中序遍历为：");
	for (const ElemType& x : inOrderVec)
		cout << x;
	puts("");

	//后序
	stack<Tree> postOrderStk;
	vector<ElemType> postOrderVec;
	Tree postTree = T;
	Tree prev = nullptr;
	while (postTree || postOrderStk.size())
	{
		while (postTree)
		{
			postOrderStk.emplace(postTree);
			postTree = postTree->left;
		}
		postTree = postOrderStk.top();
		postOrderStk.pop();
		if (postTree->right == nullptr || postTree->right == prev) //无右子树 或 为第二次遍历的根
		{
			postOrderVec.emplace_back(postTree->val);
			prev = postTree;
			postTree = nullptr;
		}
		else {
			postOrderStk.emplace(postTree);
			postTree = postTree->right;
		}
	}
	printf("迭代后序遍历为：");
	for (const ElemType& x : postOrderVec)
		cout << x;
	puts("");


	//4.层序遍历
	//[1]队列
	queue<Tree> levelOrderQue;
	vector<vector<ElemType>> levelOrderVec;
	vector<ElemType> leafVec;   //叶结点
	levelOrderQue.emplace(T);
	while (levelOrderQue.size())
	{
		int sz = levelOrderQue.size();
		vector<ElemType> v;
		for (int i = 0; i < sz; ++i)
		{
			auto t = levelOrderQue.front();
			levelOrderQue.pop();

			v.emplace_back(t->val);
			if (t->left) levelOrderQue.emplace(t->left);
			if (t->right) levelOrderQue.emplace(t->right);
			if (t->left == nullptr && t->right == nullptr) leafVec.emplace_back(t->val);  //叶结点
		}
		levelOrderVec.emplace_back(v);
	}
	cout << "树的深度为: " << levelOrderVec.size() << endl;
	cout << "树的叶结点个数为: " << leafVec.size() << " 分别为: ";
	for (const ElemType& x : leafVec)
		cout << x << " ";
	puts("");
	printf("层序遍历为：");
	for (const vector<ElemType>& x : levelOrderVec)
		for (const ElemType& y : x)
			cout << y;
	puts("");

	//[2]队列 + 哈希[注意传入空树时，要特判！]
	queue<Tree> q;
	unordered_map<int, vector<ElemType>> v;
	unordered_map<Tree, int> dep;
	vector<ElemType> leaf;
	q.emplace(T);
	dep[T] = 0;
	int depth = 0;
	while (q.size())
	{
		auto t = q.front();
		q.pop();

		int d = dep[t];
		v[d].emplace_back(t->val);
		if (t->left) q.emplace(t->left), dep[t->left] = d + 1;
		if (t->right) q.emplace(t->right), dep[t->right] = d + 1;
		if (t->left == nullptr && t->right == nullptr) leaf.emplace_back(t->val), depth = max(depth, d);
	}
	cout << "树的深度为：" << depth + 1 << endl;
	cout << "树的叶结点数为：" << leaf.size() << " 分别是：";
	for (auto l : leaf)
		cout << l << " ";
	puts("");
	printf("层序遍历为：");
	for (int i = 0; i <= depth; ++i)
		for (auto x : v[i])
			cout << x;
	puts("");
	return 0;
}

3.总结

绕行踩点法
递归方法较易，迭代需要思考

4.更新日志

2022.12.2 整理 二叉树的遍历

欢迎评论留言、指正~~

Utozyz
关注
  • 3
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
对称二叉树c++_对称的二叉树
weixin_34896969的博客
01-12 459
代码很简单，关键还是知道怎么样才能判断一个二叉树是否对称，只要采用前序、中序、后序、层次遍历等任何一种遍历方法，分为先左后右和先右后左两种方法，只要两次结果相等就说明这棵树是一颗对称二叉树。迭代版本class Solution {public:bool isSymmetric(TreeNode* root) {if(root==NULL) return true;queue q1,q2;TreeN...
二叉树 C++
11-21
二叉树的建立和遍历，完整的可以运行，没有错误
c++的二叉树
热门推荐
客舟中
01-01 1万+
目录 二叉树的定义 二叉树的分类 1. 完全二叉树 2. 满二叉树 3. 斜树 4. 二叉搜索树 5. 平衡二叉树 二叉树的存储方式 1. 数组存储 2. 链表存储 二叉树的遍历方式 1. 前序遍历 2. 中序遍历 3. 后序遍历 4. 层序遍历 二叉树的代码实现 总结 技术参考 二叉树的定义 二叉树是每个节点最多只有两个子树的数结构，两个子树称为左子树和右子树。 二叉树的分类 1. 完全二叉树 假设其深度为 d（d>1）。除了第 d 层外....
打印二叉树C++
刘望的博客
07-29 1854
作者：知乎用户 链接：https://www.zhihu.com/question/280630276/answer/415783268 来源：知乎 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。 struct node {int value; struct node *left, *right; }; // 一个数组，数组长度不低于二叉树的高度，为了简便起见，这里假设是一百, // 自己使用得时候可以改成动态数组(或链表) int vec_left[100] = {0}; //.
重建二叉树C++
heibai97的博客
02-20 574
重建二叉树C++题目：题解：代码： 题目： 输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。 题解： 代码： /** * Definition for binary tree * struct TreeNode { * int val; * TreeNode *left; * TreeN
蓝桥杯真题 多叉树转为二叉树 C++实现
m0_55955474的博客
04-02 1567
#include<iostream> #include<vector> using namespace std; const int N = 1e5 + 10; vector<int> g[N]; int dfs(int u) { int ans = 0; int len = g[u].size(); for (int i = 0; i < g[u].size(); i++) { ans = max(ans, dfs(g[u]...
【二叉树】前序遍历创建二叉树 C++
lynn_flame的博客
06-06 3526
前序遍历创建二叉树
654. 最大二叉树 C++
ZJU宁波理工
10-16 220
给定一个不含重复元素的整数数组。一个以此数组构建的最大二叉树定义如下： 二叉树的根是数组中的最大元素。 左子树是通过数组中最大值左边部分构造出的最大二叉树。 右子树是通过数组中最大值右边部分构造出的最大二叉树。 通过给定的数组构建最大二叉树，并且输出这个树的根节点。 示例 ： 输入：[3,2,1,6,0,5] 输出：返回下面这棵树的根节点： 6 / \ 3 5 \ / 2 ...
二叉树C++
2301_76221972的博客
02-08 473
二叉树C++
leetcode对称二叉树c++
陈乐乐的博客
04-28 254
对称二叉树 给定一个二叉树，检查它是否是镜像对称的。 解题思路： 若一个二叉树root是镜像对称的，则与克隆体rootcopy有： 根节点相同 root每个右子树与rootcopy左子树镜像对称 root每个左子树与rootcopy右子树镜像对称 实现代码： class Solution { public: bool isSymmetric(TreeNode* root) { ...
二叉树的基本操作.zip_二叉树 c++
07-15
二叉树的先序，中序，后序，层序递归和非递归实现，总节点个数和叶子节点个数，二叉树的高度等基本操作
二叉树C++代码
07-17
二叉树的建立、插入、查找、删除，C++语言描述。
二叉树 C++实现
10-25
用C++实现二叉树的构建，包括插入节点、删除节点、查找节点等各种操作，代码简单高效，的别是对学习理解二叉树原理的同学有很大的帮助
AVLTree 平衡二叉树c++实现
06-26
c++平衡二叉树的实现 带内存分配，非常全面 ，有错误欢迎留言
【C++】——Stack与Queue（含优先队列（详细解读）
最新发布
m0_74092462的博客
06-09 1018
优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。 队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。
C++——计算不同的非空子串个数
我发布的博客，快来抄答案吧
06-09 151
BCSP-X 11题 C++代码详解
LeetCode 算法：轮转数组c++
小金牛来了
06-09 693
LeetCode 算法：轮转数组c++
C++的算法：欧拉道路与欧拉回路
全栈工程师Linda的博客
06-09 1114
C++的算法：欧拉道路与欧拉回路
c++|unordered系列关联式容器(unordered_set、unordered_map介绍使用+哈希结构)
weixin_68201503的博客
06-09 761
1.unordered_set与set一样元素key与value是一一对应的，且是唯一的,set中的key不能在容器中修改(元素总是const)，但是可以插入和删除,且元素是去重的。2.unordered_set与set不一样的是，其底层是由数组实现，数组存储的是，且节点值的顺序没有按照特定的顺序排序，为了能在常数范围内找到可以所对应的key，unordered_set将相同哈希值的键值对放在相同的桶中(比较抽象，待后续分析)。
二叉树c++
05-30
在C++中，我们可以使用指针来实现二叉树。 首先，我们需要定义二叉树节点的结构体，例如： ``` struct TreeNode { int val; TreeNode* left; TreeNode* right; TreeNode(int x) : val(x), left(nullptr), ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值