二叉树创建，递归遍历，非递归遍历

最新推荐文章于 2024-09-19 13:36:34 发布
最新推荐文章于 2024-09-19 13:36:34 发布
阅读量777 收藏 15
点赞数 4
文章标签： c++ 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_63830846/article/details/126513221
版权

二叉树

博主是一个大一刚刚放暑假的大学生，大学我们只学习了c语言，现在这么卷只学c语言肯定不够，所以博主打算从零开始恶补c++顺便写文章记录一下，另外博主这个暑假还想记录一些算法基础内容欢迎关注哦。这些是是一些算法的记录和整理总结笔记要是什么时候忘记了这个算法那个算法怎么做就重新来看看，在csdn上面发是为了利用网址来编写思维导图的话比! 较方便~~~如果大家想跟着我一起学习也可以关注我~或者给这个文章点赞~~~谢谢大家了~

请添加图片描述

文章目录

二叉树的初始化

首先我们要先声明一个二叉树类里面要有数据节点，左节点，右节点。

#include <iostream>
#include <vector>
using namespace std;

class BinaryTree
{
public:
    char data;
    BinaryTree* left;
    BinaryTree* right;
};

二叉树的创建

递归创建二叉树(‘#’表示节点为空)：

void CreatBinaryTree(BinaryTree* &root) {//就相当于建立了一个root指针然后让root指针当一个tree的别名，root指针的本质就是对象指针
	char c;
	cin >> c;
	if (c == '#')	//当遇到#时，令树的根节点为NULL，从而结束该分支的递归
		root = NULL;
	else
	{
		root = new BinaryTree;//用指针存放new出来的对象的地址这个指针就相当于新对象的指针。
		root->data = c;	//指针指向对象中的data也可以写成(*root).data
		CreatBinaryTree(root->left);//递归构建左子树
		CreatBinaryTree(root->right);//递归构建右子树
	}
}

二叉树的遍历

前序遍历二叉树（先根再左再右）
//前序遍历二叉树

void Preorder(BinaryTree* root, vector<char> &path)//path作为形参的传递方式
{
	if (root != NULL) {
		path.push_back(root->data);//在vector的末尾添加一个数就是按序排列（后来的插在后面）
		Preorder(root->left, path);//访问左儿子
		Preorder(root->right, path);//访问右儿子
	}
}//调用完了vector中就有数字了~
中序遍历二叉树（先左再根再右）
//中序遍历二叉树

void Inorder(BinaryTree* root, vector<char> &path)//path作为形参的传递方式
{
	if (root != NULL) {
		Preorder(root->left, path);//访问左儿子
        path.push_back(root->data);//在vector的末尾添加一个数就是按序排列（后来的插在后面）
		Preorder(root->right, path);//添加右儿子
	}
}//调用完了vector中就有数字了~
后序遍历二叉树（先左再右再根）
//后序遍历二叉树

void Postorder(BinaryTree* root, vector<char> &path)//path作为形参的传递方式
{
	if (root != NULL) {
		Preorder(root->left, path);//访问左儿子
        Preorder(root->right, path);//访问右儿子
        path.push_back(root->data);//在vector的末尾添加这个节点 就是按序排列（后来的插在后面）
		
	}
}//调用完了vector中就有数字了~

整个代码如下

#include<iostream>
#include<vector>

using namespace std;

//声明类
class BinaryTree {
public:
	char data;
	BinaryTree* left, * right;
};

//按照前序遍历创建二叉树
void CreatBinaryTree(BinaryTree* &root) {//就相当于建立了一个root指针然后让root指针当一个tree的别名，root指针的本质就是对象指针
	char c;
	cin >> c;
	if (c == '#')	//当遇到#时，令树的根节点为NULL，从而结束该分支的递归
		root = NULL;
	else
	{
		root = new BinaryTree;//用指针存放new出来的对象的地址这个指针就相当于新对象的指针。
		root->data = c;	//指针指向对象中的data也可以写成(*root).data
		CreatBinaryTree(root->left);//递归构建左子树
		CreatBinaryTree(root->right);//递归构建右子树
	}
}

void PrintBinaryTree(vector<int> path);//声明打印二叉树函数

//前序遍历二叉树

void Preorder(BinaryTree* root, vector<char> &path)//path作为形参的传递方式
{
	if (root != NULL) {
		path.push_back(root->data);//在vector的末尾添加一个数就是按序排列（后来的插在后面）
		Preorder(root->left, path);//访问左儿子
		Preorder(root->right, path);//访问右儿子
	}
}//调用完了vector中就有数字了~

//中序遍历二叉树

void Inorder(BinaryTree* root, vector<char> &path)//path作为形参的传递方式
{
	if (root != NULL) {
		Inorder(root->left, path);//访问左儿子
        path.push_back(root->data);//在vector的末尾添加一个数就是按序排列（后来的插在后面）
		Inorder(root->right, path);//添加右儿子
	}
}//调用完了vector中就有数字了~

//后序遍历二叉树

void Postorder(BinaryTree* root, vector<char> &path)//path作为形参的传递方式
{
	if (root != NULL) {
		Postorder(root->left, path);//访问左儿子
        Postorder(root->right, path);//访问右儿子
        path.push_back(root->data);//在vector的末尾添加这个节点 就是按序排列（后来的插在后面）

	}
}//调用完了vector中就有数字了~
//打印函数
void PrintBinaryTree(vector<char> path) {
	int n = path.size();
	for (int i = 0;i < n;++i) {
		cout << path[i]<<' ';
	}
	cout<<endl;
}


int main()
{
	vector<char> path1, path2, path3;
	cout << "请使用前序遍历创建二叉树（若节点为空输入#代替）：" << endl;
	BinaryTree* root = NULL;
	CreatBinaryTree(root);
	cout << "二叉树创建完成！" << endl;
	cout << "前序遍历二叉树结果为：" << endl;
	Preorder(root, path1);
	PrintBinaryTree(path1);
	cout << "中序遍历二叉树结果为：" << endl;
	Inorder(root, path2);
	PrintBinaryTree(path2);
	cout << "后序遍历二叉树结果为：" << endl;
	Postorder(root, path3);
	PrintBinaryTree(path3);

	return 0;
}

输出结果为:

请添加图片描述

这样二叉树最简单的部分就学完了~~

测试数据：

1
2
3
# #
4
# #
5
6
# #
7
# #

二叉树的非递归遍历：

非递归先序遍历

怎么实现？先准备一个栈，然后把头解点放进去

  1. 从栈中弹出一个节点
  2. 打印处理节点
  3. 先右再左
  4. 重复
//先序遍历非递归
void preOrderUnRecur (BinaryTree root){
    cout<< "非递归先序遍历" << endl;
	BinaryTree *root1 = new BinaryTree;
	*root1 = root;
    if (root1 != NULL)
    {
		
		stack<BinaryTree> stack;
		stack.push(*root1);
		while (!stack.empty())
		{

			*root1 = stack.top();
			stack.pop();
			cout << root1->data <<' ';
			if (root1->right != NULL)
			{
				stack.push(*root1->right);
			}
			if (root1-> left != NULL)
			{
				stack.push(*root1->left);
			}
		}
		cout<< endl; 
            
    }

}
非递归后序遍历
  • 先序遍历的顺序不是头左右嘛，把左右换一下不就是头右左了嘛把头右左压到另一个栈里面不就是左右头了嘛，左右头不就是后序遍历了嘛~ 再把那个栈输出一遍不就完事了嘛~
//后序遍历非递归
void postOrderUnRecur(BinaryTree * root){
 cout<< "非递归后序遍历" << endl;
		BinaryTree *root1 = root;
    if (root1 != NULL)
    {

		stack<BinaryTree *> stack,stack2;
		stack.push(root1);
		while (!stack.empty())
		{

			root1 = stack.top();
			stack.pop();
			stack2.push(root1);
			if (root1-> left != NULL)
			{
				stack.push(root1->left);
			}
			if (root1->right != NULL)
			{
				stack.push(root1->right);
			}

		}
		while (!stack2.empty())
		{
			cout << stack2.top()->data << " ";
			stack2.pop();
		}

		cout<< endl;

    }
}
非递归中序遍历

逮住一棵树，先把左边界压到栈里去在弹出每一个节点的过程中让他的右树也这么干

  • 每棵子树，整棵树左边界进栈，然后依次弹出节点的过程打印中对弹出节点的右树重复
void inOrderUnRecur (BinaryTree* root){
    cout<< "非递归中序遍历" << endl;
	BinaryTree *root1 = root;//建个指针对象指向根节点
	stack<BinaryTree*> stack2;//建个栈
    if (root1 != NULL)//如果根节点不为空的话
    {

		while ( !stack2.empty() || root1)//当栈不为空并且根节点不为空时
		{
			if (root1)//如果这个节点不为空就把他压栈并且去看看他的左节点(不停地把左边界进栈)
			{
				stack2.push(root1);
				root1 = root1->left;
			}
			else//左边界为空了就开始弹出节点
			{
                root1 = stack2.top();
				cout << root1->data << ' ';
				stack2.pop();//弹出节点并打印
				root1 = root1->right;//对右树周而复始压左树
			}

		}


    }
		cout << endl;
}
//前左再头的弄出来但是右树后干这件事

本文全部代码：

#include<iostream>
#include<vector>
#include<stack>

using namespace std;

//声明类
class BinaryTree {
public:
	char data;
	BinaryTree* left, * right;
};

stack<BinaryTree> stack2;
//按照前序遍历创建二叉树
void CreatBinaryTree(BinaryTree* &root) {//就相当于建立了一个root指针然后让root指针当一个tree的别名，root指针的本质就是对象指针
	char c;
	cin >> c;
	if (c == '#')	//当遇到#时，令树的根节点为NULL，从而结束该分支的递归
		root = NULL;
	else
	{
		root = new BinaryTree;//用指针存放new出来的对象的地址这个指针就相当于新对象的指针。
		root->data = c;	//指针指向对象中的data也可以写成(*root).data
		CreatBinaryTree(root->left);//递归构建左子树
		CreatBinaryTree(root->right);//递归构建右子树
	}
}

void PrintBinaryTree(vector<int> path);//声明打印二叉树函数

//前序遍历二叉树

void Preorder(BinaryTree* root, vector<char> &path)//path作为形参的传递方式
{
	if (root != NULL) {
		path.push_back(root->data);//在vector的末尾添加一个数就是按序排列（后来的插在后面）
		Preorder(root->left, path);//访问左儿子
		Preorder(root->right, path);//访问右儿子
	}
}//调用完了vector中就有数字了~

//中序遍历二叉树

void Inorder(BinaryTree* root, vector<char> &path)//path作为形参的传递方式
{
	if (root != NULL) {
		Inorder(root->left, path);//访问左儿子
        path.push_back(root->data);//在vector的末尾添加一个数就是按序排列（后来的插在后面）
		Inorder(root->right, path);//添加右儿子
	}
}//调用完了vector中就有数字了~

//后序遍历二叉树

void Postorder(BinaryTree* root, vector<char> &path)//path作为形参的传递方式
{
	if (root != NULL) {
		Postorder(root->left, path);//访问左儿子
        Postorder(root->right, path);//访问右儿子
        path.push_back(root->data);//在vector的末尾添加这个节点 就是按序排列（后来的插在后面）

	}
}//调用完了vector中就有数字了~
//打印函数
void PrintBinaryTree(vector<char> path) {
	int n = path.size();
	for (int i = 0;i < n;++i) {
		cout << path[i]<<' ';
	}
	cout<<endl;
}
//先序遍历非递归
void preOrderUnRecur (BinaryTree *root){
    cout<< "非递归先序遍历" << endl;
	BinaryTree *root1 = root;
    if (root1 != NULL)//排除头结点为空的情况
    {

		stack<BinaryTree *> stack;//建栈
		stack.push(root1);//压头结点
		while (!stack.empty())//如果栈不为空就弹栈
		{

			root1 = stack.top();
			stack.pop();
			cout << root1->data <<' ';//打印了头结点
			if (root1->right != NULL)
			{
				stack.push(root1->right);
			}
			if (root1-> left != NULL)
			{
				stack.push(root1->left);
			}//这里是右边先进栈但是后出栈
		}

		cout<< endl;

    }

}
//中序遍历非递归
void inOrderUnRecur (BinaryTree* root){
    cout<< "非递归中序遍历" << endl;
	BinaryTree *root1 = root;//建个指针对象指向根节点
	stack<BinaryTree*> stack2;//建个栈
    if (root1 != NULL)//如果根节点不为空的话
    {

		while ( !stack2.empty() || root1)//当栈不为空并且根节点不为空时
		{
			if (root1)//如果这个节点不为空就把他压栈并且去看看他的左节点(不停地把左边界进栈)
			{
				stack2.push(root1);
				root1 = root1->left;
			}
			else//左边界为空了就开始弹出节点
			{
                root1 = stack2.top();
				cout << root1->data << ' ';
				stack2.pop();//弹出节点并打印
				root1 = root1->right;//对右树周而复始压左树
			}

		}


    }
		cout << endl;
}
//前左再头的弄出来但是右树后干这件事

//后序遍历非递归
void postOrderUnRecur(BinaryTree * root){
 cout<< "非递归后序遍历" << endl;
		BinaryTree *root1 = root;
    if (root1 != NULL)
    {

		stack<BinaryTree *> stack,stack2;
		stack.push(root1);
		while (!stack.empty())
		{

			root1 = stack.top();
			stack.pop();
			stack2.push(root1);
			if (root1-> left != NULL)
			{
				stack.push(root1->left);
			}
			if (root1->right != NULL)
			{
				stack.push(root1->right);
			}

		}
		while (!stack2.empty())
		{
			cout << stack2.top()->data << " ";
			stack2.pop();
		}

		cout<< endl;

    }
}
int main()
{
	vector<char> path1, path2, path3;
	cout << "请使用前序遍历创建二叉树（若节点为空输入#代替）：" << endl;
	BinaryTree* root = NULL;
	CreatBinaryTree(root);
	BinaryTree* root_save = root;

	cout << "二叉树创建完成！" << endl;
	
	
	cout << "前序遍历二叉树结果为：" << endl;
	Preorder(root, path1);
	PrintBinaryTree(path1);
	preOrderUnRecur(root);

	cout << "中序遍历二叉树结果为：" << endl;
	Inorder(root, path2);
	PrintBinaryTree(path2);
	inOrderUnRecur(root);

	cout << "后序遍历二叉树结果为：" << endl;
	Postorder(root, path3);
	PrintBinaryTree(path3);
    postOrderUnRecur(root);

	system("pause");
	return 0;
}
热爱可抵岁月漫长
c0re
关注
【数据结构】--- 二叉树的递归遍历和非递归遍历【C语言实现】
mike_jun的博客
07-17 3万+
目录 1. 创建一颗二叉树 2.递归前序遍历二叉树 3.递归中序遍历二叉树 4.递归后序遍历二叉树 5. 测试递归打印二叉树代码 6. 非-递归前序遍历二叉树 7.非-递归实现中序遍历二叉树 8.非 - 递归实现后序遍历【较为复杂的方法】 9.非 - 递归实现后序遍历【简单的方法】 10. 二叉树的层次遍历 11. 最后：附全部代码： 对于二叉树的非递归 深度优先遍历，使用的都是栈 对于二叉树的层次遍历，使用的是队列 1. 创建一颗二叉树 依据前序遍...
详解二叉树的递归遍历与非递归遍历
一扣解千愁的博客
08-02 7556
二叉树的遍历 所谓二叉树的遍历，是指按某条搜索路径访问树中的每个节点，使得每个节点均被访问一次，而且仅被访问一次。 遍历二叉树需要决定对根节点N、左子树L、右子树R的访问顺序（按照先遍历左子树在遍历右子树的原则），常见的遍历次序有先序（NLR）、中序（LNR）、后序（LRN）三种遍历算法，这也是最常见的二叉树遍历算法。 其中的“序”实际上就是根节点的访问时机。 1. ...
二叉树非递归遍历（C++）
lim6ere的博客
06-03 898
我们之前学习过用递归解决二叉树的前序，中序，后序。下面我们将用非递归，也就是遍历的方法对二叉树进行遍历以上就是今天要讲的内容，本文仅仅详细介绍了二叉树前序，中序，后序三种非递归遍历方式。希望对大家的学习有所帮助，仅供参考 如有错误请大佬指点我会尽快去改正 欢迎大家来评论~~ 😘 😘 😘。
二叉树的递归遍历详解
CodingLJ
08-16 1581
首先理解二叉树的遍历递归方法。这篇文章写的不错。 https://blog.csdn.net/allenchenhh133/article/details/80291252 看完这篇文章后，再总结下： 不要太在意细节问题，二叉树递归没那么难。只要知道过程，剩下的交给编译器。 ① 从根节点往左子树或者是右子树继续遍历。 举例： root.left遍历左子树，一直遍历到结点为空 或者停止的那个条件为止，左子树为空，右子树也为空，然后返回上一层。继续遍历当前结点的右子树，然后再继续遍...
二叉树非递归遍历
yue152152的博客
07-29 1379
带你理解二叉树的非递归遍历
C语言二叉树非递归遍历详解,C语言实现二叉树的递归遍历和非递归遍历
weixin_42551260的博客
05-20 1520
本文实现了二叉树的递归遍历和非递归遍历，当然，还包括一些堆栈操作.遍历二叉树本质上是一个堆栈和堆栈的问题. 递归算法简单易懂，但效率始终是一个问题. 非递归算法可以清楚地知道实现的每个步骤的细节，但是乍一看并不想很好地理解递归算法，每个都有其自己的好处. 接下来，根据下图讨论树遍历.1. 一阶遍历: 一阶遍历是首先输出根节点，然后是左子树，最后是右子树. 上图中的上一个遍历结果为: ABCDEF2...
python二叉树的非递归遍历
vir_lee的博客
07-24 996
​ 在树的深度优先遍历中（包括前序、中序、后序遍历），递归方法最为直观易懂，但考虑到效率，我们通常不推荐使用递归。 栈迭代方法虽然提高了效率，但其嵌套循环却非常烧脑，不易理解，容易造成“一看就懂，一写就废”的窘况。而且对于不同的遍历顺序（前序、中序、后序），循环结构差异很大，更增加了记忆负担。 因此，我在这里介绍一种“灰白标记法”，兼具栈迭代方法的高效，又像递归方法一样简洁易懂，更重要的是，这种方法对于前序、中序、后序遍历，能够写出完全一致的代码。 其核心思想如下： 使用颜色标记节点的状态，新节点为白色，已
二叉树非递归遍历实现（Java）
weixin_50813307的博客
09-25 1428
二叉树非递归遍历
二叉树的递归与非递归遍历
weixin_63802890的博客
09-27 1104
二叉树的遍历
二叉树的递归和非递归遍历
bubbleyang的博客
07-12 3011
二叉树递归和非递归遍历
二叉树非递归遍历-二叉树非递归遍历-二叉树非递归遍历-二叉树非递归遍历
09-09
/*********************************************************** ***********************************************************/ #include #include #include #define MS 50 struct BTreeNode ...
数据结构实用教程之二叉树，其中包含了：二叉树的定义、二叉树的递归遍历、二叉树基本操作。
07-01
数据结构实用教程之二叉树，其中包含了：二叉树的定义、二叉树的递归遍历、二叉树基本操作。 数据结构实用教程之二叉树，其中包含了：二叉树的定义、二叉树的递归遍历、二叉树基本操作。 数据结构实用教程之二叉树，...
C++实现二叉树非递归遍历方法实例总结
09-04
总结来说，C++实现二叉树非递归遍历的关键在于理解遍历的顺序，并巧妙地利用栈来模拟递归过程。这种方法不仅适用于面试，而且在实际编程中也具有较高的效率和灵活性。通过熟练掌握这些技巧，可以更好地理解和解决与...
二叉树非递归遍历.zip-/二叉树非递归遍历.zip-二叉树非递归遍历.zip 二叉树非递归遍历.zip
09-09
/*********************************************************** ***********************************************************/ #include #include #include #define MS 50 struct BTreeNode ...
【C++】 —— string的使用
LH__1314的博客
09-16 1543
string类虽然不在STL的容器中，但string类十分重要，string类是对字符串的存储和相关操作。
碰撞检测 | 图解线段几何与线段相交检测原理(附ROS C++可视化)
FRIGIDWINTER的博客
09-18 1880
线段相交检测是广义多边形计算几何的基础，本文图解线段几何的常见算法，例如线段与线段相交检测(快速排斥与跨立实验)；线段与圆的相交检测；线段与矩形的相交检测。通过ROS C++实现算法并辅以可视化演示加深理解
配置VS Code以进行C/C++编程：深入探讨与实操指南
GZM888888的博客
09-19 727
打开VS Code，点击左侧边栏中的Extensions图标（或按下快捷键），搜索“C/C++”，找到由Microsoft提供的官方扩展，点击Install按钮进行安装。在这个示例中，我们定义了一个名为“（gdb） Launch”的配置，它将使用GDB调试器来调试当前打开的文件。为了让VS Code知道如何构建你的项目，你需要创建一个名为的文件。在这个示例中，我们定义了一个名为“build”的任务，它将使用命令来编译当前打开的文件。如果你计划调试你的C/C++程序，你还需要创建一个名为的文件。
TMS Scripter Crack TMS Scripter is a Delphi C++ Builder
最新发布
q2315702359的博客
09-19 1062
　　The integrated development environment or the IDE allows the users in process of creating script jobs during the runtime with the help of multiple cross-language scripts such as de Pascal and the Basics.　　It has support for the cross-utilization of the s
二叉树非递归遍历实现与源码解析
"二叉树非递归遍历的源代码示例，包含先序、中序和后序遍历的实现。" 在计算机科学中，二叉树是一种数据结构，其中每个节点最多有两个子节点，通常称为左子节点和右子节点。二叉树的遍历是访问树中所有节点的过程，...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

c0re

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

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

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

打赏作者

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

抵扣说明：

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

余额充值