用递归和栈实现二叉树遍历（先序、中序、后序、层次）

已于 2022-11-05 20:44:13 修改
阅读量2.7k 收藏 62
点赞数 4
分类专栏： 数据结构 文章标签： 算法 数据结构 c++
于 2022-11-05 20:24:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CXR_XC/article/details/127708099
版权

先序：根结点->左子树->右子树

中序：左子树->根结点->右子树

后序：左子树->右子树->根结点

层次：逐层访问，从左到右

这里我采用的是先序创建。用来测试程序的二叉树为ABD#G###CE##F##，如图所示：

 基本数据结构：

typedef struct BiTNode {
	char data;
	struct BiTNode* lchild;
	struct BiTNode* rchild;
}BiTNode, * BiTree;

下面就来看代码吧。

递归法实现二叉树遍历（先序、中序、后序）：

//先序遍历并打印
void PrePrint_Tree(BiTree T)  
{
	if (T != NULL) {
		cout << T->data;          //访问根节点
		PrePrint_Tree(T->lchild); //先序遍历左子树
		PrePrint_Tree(T->rchild); //先序遍历右子树
	}
}

//中序遍历并打印
void InPrint_Tree(BiTree T)  
{
	if (T != NULL) {
		InPrint_Tree(T->lchild);  //中序遍历左子树
		cout << T->data;          //访问根节点
		InPrint_Tree(T->rchild);  //中序遍历右子树
	}
}

//后序遍历并打印
void PostPrint_Tree(BiTree T)  
{
	if (T != NULL) {
		PostPrint_Tree(T->lchild); //后序遍历左子树
		PostPrint_Tree(T->rchild); //后序遍历右子树
		cout << T->data;           //访问根节点
	}
}

 栈实现二叉树遍历（先序、中序、后序）：

//先序遍历并打印（非递归）（直接使用了C++STL自带的栈）
void SPrePrint_Tree(BiTree T)  
{
	if (T == NULL) {
		return;
	}
	else {
		stack<BiTree>S;
		S.push(T);          //根结点入栈
		while (!S.empty()) {  
			T = S.top();    
			S.pop();     
			cout << T->data;        //访问结点
			if (T->rchild) {
				S.push(T->rchild);  //右子树进栈
			}
			if (T->lchild) {
				S.push(T->lchild);  //左子树进栈
			}
		}
	}
}

//中序遍历并打印（非递归）（直接使用了C++STL自带的栈）
void SInPrint_Tree(BiTree T)  
{
	if (T == NULL) {
		return;
	}
	else {
		stack<BiTree>S;
		S.push(T);          //根结点先入栈
		T = T->lchild;      //先遍历左子树
		while (T || !S.empty()) {
			while (T) {       //先遍历左子树
				S.push(T);
				T = T->lchild;
			}
			T = S.top();      //打印结点
			cout << T->data;
			S.pop();
			T = T->rchild;   //遍历右子树
		}
	}
}

//后序遍历并打印（非递归）（直接使用了C++STL自带的栈）
void SPostPrint_Tree(BiTree T)  
{
	if (T == NULL) {
		return;
	}
	else {
		stack<BiTree>S;
		S.push(T);
		T = T->lchild;
		while (!S.empty()) {
			while (T) {         //先遍历左子树
				S.push(T);
				T = T->lchild;
			}
			T = S.top();         
			T = T->rchild;     //遍历右子树
			if (T == NULL) {   //左右子树皆为空
				T = S.top();
				cout << T->data;   
				S.pop();
				while (!S.empty() && T == S.top()->rchild) {  //如果T原本就是右子树，
					T = S.top();                              //则该层已遍历完毕
					cout << T->data;                          //输出根结点
					S.pop();                                  //继续向上一层 
				}
				if (!S.empty()) {
					T = S.top()->rchild; //遍历右子树
				}
			}
		}
	}
}

队列实现二叉树层次遍历：

 //层次遍历并打印
void LevelPrint_Tree(BiTree T) 
{
	BiTree p;
	queue<BiTree>qu;  //定义队列，存放二叉树结点指针（这里使用了STL的queue类型）
	qu.push(T);       //根节点入队
	while (!qu.empty()) {
		p = qu.front();
		cout << p->data;  //访问队首结点
		qu.pop();         //队首结点出队
		if (p->lchild != NULL) {
			qu.push(p->lchild);  //若结点有左孩子，则左孩子入队
		}
		if (p->rchild != NULL) {
			qu.push(p->rchild);  //若结点有右孩子，则左孩子入队
		}
	}
}

 

全部代码（包括程序测试）： 

//实现二叉树的先序、中序、后序遍历，用递归和非递归方法；实现层次遍历
# include <iostream>
# include <stdlib.h>
# include <stack>
# include <queue>
using namespace std;
typedef struct BiTNode {
	char data;
	struct BiTNode* lchild;
	struct BiTNode* rchild;
}BiTNode, * BiTree;

void Init_Tree(BiTree& T)  //初始化
{
	T = (BiTree)malloc(sizeof(BiTNode));
	T->data = '#';
	T->lchild = NULL;
	T->rchild = NULL;
}

void Destroy_Tree(BiTree& T) //销毁（基于后序顺序）
{
	if (T) {
		Destroy_Tree(T->lchild);
		Destroy_Tree(T->rchild);
		free(T);
	}
}

void Create_Tree(BiTree& T) //创建（基于先序顺序）
{
	char c;
	cin >> c;
	if (c == '#') {
		T = NULL;
	}
	else {
		T = (BiTree)malloc(sizeof(BiTNode));
		T->data = c;
		Create_Tree(T->lchild);
		Create_Tree(T->rchild);
	}
}

void PrePrint_Tree(BiTree T)  //先序遍历并打印（递归）
{
	if (T == NULL) {
		return;
	}
	else {
		cout << T->data;
		PrePrint_Tree(T->lchild);
		PrePrint_Tree(T->rchild);
	}
}

void SPrePrint_Tree(BiTree T)  //先序遍历并打印（非递归）（栈）
{
	if (T == NULL) {
		return;
	}
	else {
		stack<BiTree>S;
		S.push(T);          //根结点入栈
		while (!S.empty()) {  
			T = S.top();    
			S.pop();     
			cout << T->data;        //访问结点
			if (T->rchild) {
				S.push(T->rchild);  //右子树进栈
			}
			if (T->lchild) {
				S.push(T->lchild);  //左子树进栈
			}
		}
	}
}

void InPrint_Tree(BiTree T)  //中序遍历并打印（递归）
{
	if (T == NULL) {
		return;
	}
	else {
		InPrint_Tree(T->lchild);
		cout << T->data;
		InPrint_Tree(T->rchild);
	}
}

void SInPrint_Tree(BiTree T)  //中序遍历并打印（非递归）（栈）
{
	if (T == NULL) {
		return;
	}
	else {
		stack<BiTree>S;
		S.push(T);          //根结点先入栈
		T = T->lchild;      //先遍历左子树
		while (T || !S.empty()) {
			while (T) {       //先遍历左子树
				S.push(T);
				T = T->lchild;
			}
			T = S.top();      //打印结点
			cout << T->data;
			S.pop();
			T = T->rchild;   //遍历右子树
		}
	}
}

void PostPrint_Tree(BiTree T)  //后序遍历并打印（递归）
{
	if (T == NULL) {
		return;
	}
	else {
		PostPrint_Tree(T->lchild);
		PostPrint_Tree(T->rchild);
		cout << T->data;
	}
}

void SPostPrint_Tree(BiTree T)  //后序遍历并打印（非递归）（栈）
{
	if (T == NULL) {
		return;
	}
	else {
		stack<BiTree>S;
		S.push(T);
		T = T->lchild;
		while (!S.empty()) {
			while (T) {         //先遍历左子树
				S.push(T);
				T = T->lchild;
			}
			T = S.top();         
			T = T->rchild;     //遍历右子树
			if (T == NULL) {   //左右子树皆为空
				T = S.top();
				cout << T->data;   
				S.pop();
				while (!S.empty() && T == S.top()->rchild) {  //如果T原本就是右子树，
					T = S.top();                              //则该层已遍历完毕
					cout << T->data;                          //输出根结点
					S.pop();                                  //继续向上一层 
				}
				if (!S.empty()) {
					T = S.top()->rchild; //遍历右子树
				}
			}
		}
	}
}

void LevelPrint_Tree(BiTree T)  //层次遍历并打印
{
	queue<BiTree>Q;
	Q.push(T);
	while (!Q.empty()) {
		T = Q.front();
		Q.pop();
		cout << T->data;
		if (T->lchild) {
			Q.push(T->lchild);
		}
		if (T->rchild) {
			Q.push(T->rchild);
		}
	}
}

int main()
{
	BiTree T;
	Init_Tree(T);                //初始化
	cout << "按先序顺序输入元素:";
	Create_Tree(T);              //创建
	cout << "先序遍历二叉树（递归）:";
	PrePrint_Tree(T);            //先序遍历并打印
	cout << endl;
	cout << "先序遍历二叉树（用栈）:";
	SPrePrint_Tree(T);           //先序遍历并打印
	cout << endl;
	cout << "中序遍历二叉树（递归）:";
	InPrint_Tree(T);             //中序遍历并打印
	cout << endl;
	cout << "中序遍历二叉树（用栈）:";
	SInPrint_Tree(T);            //中序遍历并打印
	cout << endl;
	cout << "后序遍历二叉树（递归）:";
	PostPrint_Tree(T);           //后序遍历并打印
	cout << endl;
	cout << "后序遍历二叉树（用栈）:";
	SPostPrint_Tree(T);          //后序遍历并打印
	cout << endl;
	cout << "层次遍历二叉树:";
	LevelPrint_Tree(T);         //层次遍历并打印
	cout << endl;
	return 0;
}

运行结果：

按先序顺序输入元素:ABD#G###CE##F##
先序遍历二叉树（递归）:ABDGCEF
先序遍历二叉树（用栈）:ABDGCEF
中序遍历二叉树（递归）:DGBAECF
中序遍历二叉树（用栈）:DGBAECF
后序遍历二叉树（递归）:GDBEFCA
后序遍历二叉树（用栈）:GDBEFCA
层次遍历二叉树:ABCDEFG

小结：通过递归来实现先序、中序、后序遍历，优点在于写起来比较简单，但实际运行中时间复杂度会比较高。用非递归方法，也就是栈的方法，写起来比较复杂，但实际运行中的时间复杂度较低。而层次遍历是借助队列来实现的，和BFS的道理相同。

以上是我的个人学习成果，很高兴能与大家分享。

CXR_XC
关注
  • 4
    点赞
  • 踩
  • 62
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树的中序遍历算法
fly_view的博客
09-16 2902
二叉树的中序遍历算法
算法1—递归实现二叉树的前序、中序、后序遍历
龚小帅的博客
10-23 2289
仅个人理解，计算机特点就是处理速度级快，为了不遗漏、不重复处理二叉树的每一个节点，总得按照某种顺序吧，前辈们发明了处理二叉树节点的顺序：前序遍历、中序遍历、后续遍历，经过时间的检验还是可以的。二叉树的前序、中序、后序遍历的作用都是不遗漏且不重复地处理二叉树的每一个结点。
6-4 二叉树的递归遍历(C语言解法)(PTA)
最新发布
u012137663的博客
05-23 185
个人认为这是最简单的关于二叉树的应用了,只需要理解概念,带点感觉就能把这个递归写出来。
用递归方法对二叉树进行先序、中序和后序遍历
热门推荐
认知 行动 坚持
11-01 1万+
二叉树为： 1 2 3 4 5 6 7 程序如下： #include #define N 7 using namespace std; typedef struct node {
【简单】用递归方式实现二叉树先序、中序和后序遍历－Java
了解➔熟悉➔掌握➔精通
05-29 370
package live.every.day.ProgrammingDesign.CodingInterviewGuide.BinaryTree; /** * 分别用递归方式和非递归方式实现二叉树先序、中序和后序遍历 * * 【题目】 * 用递归和非递归方式，分别按照二叉树先序、中序和后序打印所有的节点。我们约定：先序遍历顺序为根、左、右；中序遍历顺序为 * 左、根、右；后序遍历顺序为左、右、根。 * * 【难度】 * 简单 * * 【解答】 * 用递归方式实现三种遍历是教材上的基础
二叉树遍历-层序-递归
he_xin2009的专栏
04-14 2368
二叉树遍历、层序遍历：从上往下，从左到右。使用广度优先搜索算法
PHP基于非递归算法实现先序、中序及后序遍历二叉树操作示例
12-20
本文实例讲述了PHP基于非递归算法实现先序、中序及后序遍历二叉树操作。分享给大家供大家参考，具体如下： 概述： 二叉树遍历原理如下： 针对上图所示二叉树遍历： 1. 前序遍历：先遍历根结点，然后遍历左子树，...
数据结构试验报告用先序中序建立二叉树后序遍历非递归.pdf
09-27
数据结构试验报告用先序中序建立二叉树后序遍历非递归.pdf
二叉树的递归遍历，中序遍历，先序遍历，后序遍历
12-11
在本文的示例代码中，我们使用了递归函数来实现先序遍历、中序遍历和后序遍历。 先序遍历是指先访问根结点，然后递归地访问左子树和右子树。在先序遍历中，我们首先访问根结点，然后递归地访问左子树和右子树。例如...
二叉树先序遍历、中序遍历和后序遍历非递归算法 C++源码
08-25
用C++写的二叉树先序遍历、中序遍历和后序遍历非递归算法
链表先序建立二叉树，得到中序后序输出，递归和非递归实现(C++代码加设计报告)
07-15
采用二叉链表存储先序建立二叉树，非递归中序遍历二叉树算法实现
王道数据结构笔记05—树（c语言）
qq_28356977的博客
02-14 1429
本笔记仅供本人与大家学习使用，笔记内容全部来自于b站王道考研的白嫖课程。
C++二叉树递归实现各种遍历
qq_63058205的博客
11-12 1096
C++实现二叉树的如下操作： （1）初始化二叉链表：理解扩展二叉树及其前序遍历序列； （2）前序遍历二叉链表（递归实现）； （3）中序遍历二叉链表（递归实现）； （4）后序遍历二叉链表（递归实现）； （5）层序遍历二叉链表； （6）销毁二叉链表（递归实现）。
二叉树的先中后序遍历以及c语言实现二叉树
Whlit_Lie的博客
03-25 4997
二叉树的先中后序遍历以及c语言实现二叉树 目录二叉树的先中后序遍历以及c语言实现二叉树先序遍历中序遍历后序遍历规律分析代码实现（递归）二叉树完整代码 二叉树主要有三种遍历方式 先序遍历（根节点>左节点>右节点） 中序遍历（左节点>根节点>右节点） 后序遍历（左节点>右节点>根节点） ps：这个先中后其实是根据根节点的读取顺序定义的，根节点先遍历则为先序遍历，根节点后遍历则为后序遍历。 举个例子： 先序遍历：ABDGHKECFIJ 中序遍历：GDKHBEACIFJ 后序
二叉树的先序、中序、后续遍历（递归）
IamYZD的博客
04-16 4693
算法学习——二叉树的先序、中序、后续遍历（递归、非递归）一、基本概念二、使用步骤1.引入库2.读入数据总结欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 文章目录一、基本概念二、使用步骤1.引
二叉树遍历(递归实现前序/中序/后序遍历)
不见其长，日有所长
06-17 1257
1. 准备工作 我们先定义一棵普通的二叉树，如下图 2. 前序遍历 通过递归进行遍历： 如果二叉树为空，则操作返回； 如果非空，否则从根结点开始，然后遍历左子树，再遍历右子树。 前序遍历的结果是：ABDGHEICFJK 为什么会遍历出这种结果，请看上面对前序遍历的描述：先遍历左边，然后在遍历右边。 JAVA代码如下： //前序遍历 public static void preTraversal(Node node){ if(null!=node){ System.out.println(nod
二叉树前序-中序-后序遍历（递归、栈结构）
快乐学术猿
08-14 1960
目录栈的相关概念前序遍历（pre-order）递归（recursion）辅助栈中序遍历（in-order）递归（recursion）辅助栈后序遍历（post-order）递归（recursion）辅助栈 推荐两个up主： happygirlzt 图灵星球Turing Planet及其个人网站 本博文参考的视频： 二叉树前序中序后序遍历（深度优先搜索）的迭代解法 本博文参考的文章： 数据结构图文解析之：栈的简介及C++模板实现 动画演示+三种实现 94. 二叉树的中序遍历 栈的相关概念 栈顶与栈底：允许元
二叉树的中序遍历（递归）
muyu_muyu的博客
12-14 5344
中序遍历二叉树的过程如下： 二叉树的存储结构： typedef struct node{ int data; struct node * lchild; //指向左孩子的结点 struct node * rchild; //指向右孩子的结点 }BTNode; 思路： 1.遍历左子树节点 2.访问根节点 3.遍历右子树节点 C代码实现： void InOrder(BTNode * b){ //中序遍历 if(b != null){
二叉树遍历详解（递归遍历、非递归栈遍历，Morris遍历）
行走
07-01 3640
一、前言 《二叉查找树全面详细介绍》中讲解了二叉树操作：搜索（查找）、遍历、插入、删除。其中遍历深度优先遍历(DFS)按照实现方法可以分为：递归遍历实现、非递归遍历实现、Morris遍历实现，文中只给了代码，没有对实现过程进行讲解，本文将对递归遍历实现、非递归遍历栈实现、Morris遍历实现这三类实现方法进行讲解。 二、三类实现方法特点 递归实现 编码简单，易于理解； 隐式使用栈存储当前没有处理完的节点信息； 若树深度大，递归深度大可能会超过堆栈保留大小； 时间复杂度：O(n)，空间复杂度.
递归实现二叉树的先序中序后序遍历
06-10
好的，下面是递归实现二叉树的先序、中序和后序遍历的代码示例： ```python # 定义二叉树节点类 class TreeNode: def __init__(self, val=0, left=None, right=None): self.val = val self.left = left self.right = right # 先序遍历 def preOrder(root): if root: print(root.val, end=' ') preOrder(root.left) preOrder(root.right) # 中序遍历 def inOrder(root): if root: inOrder(root.left) print(root.val, end=' ') inOrder(root.right) # 后序遍历 def postOrder(root): if root: postOrder(root.left) postOrder(root.right) print(root.val, end=' ') ``` 其中，先序遍历先输出当前节点的值，再递归遍历左右子树；中序遍历先递归遍历左子树，再输出当前节点的值，最后递归遍历右子树；后序遍历先递归遍历左右子树，再输出当前节点的值。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值