二叉树的遍历：先序 中序 后序遍历的递归与非递归实现及层序遍历

最新推荐文章于 2024-02-20 15:41:44 发布
最新推荐文章于 2024-02-20 15:41:44 发布
阅读量1k 收藏 13
点赞数
分类专栏： 知识积累 文章标签： 二叉树遍历 前序中序后序遍历 递归 非递归 二叉树层序遍历 层序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yzf279533105/article/details/89304277
版权

二叉树的定义：一种基本的数据结构，是一种每个节点的儿子数目都不多于2的树

树节点的定义如下：

// 树(节点)定义
struct TreeNode 
{
	int		data; // 值
	TreeNode*	left; // 左节点
	TreeNode*	right;// 右节点
};

创建树（从上而下构建，我们以0表空节点）

结果如下图：

代码如下：

// 按照前序建立二叉树，这里我们建立下面的树
//			8
//		6		11
//	  4	  7			12
// 所以输入顺序是：864007001101200
void createTree(TreeNode*& t)
{	
	cout<<"请输入数据："<<endl;
	int val = 0;
	cin>>val;

	// 0表结束
	if (0 == val)
	{
		t = NULL;
	}
	else 
	{
		t = new TreeNode();
		t->data = val;
		cout<<"开始建立:"<<val<<"的左节点：";
		createTree(t->left);
		cout<<"开始建立:"<<val<<"右节点：";
		createTree(t->right);
	}
}

前序遍历的递归法和非递归法：

结果如下图：

代码如下：

		前序遍历		/
// 递归法
void Pre_Recursive(TreeNode* pTree)
{	
	if (pTree != NULL)
	{
		cout<<pTree->data<<endl;	// 根节点
		Pre_Recursive(pTree->left);		// 左子
		Pre_Recursive(pTree->right);	// 右子
	}
}

// 非递归法
void Pre_No_Recursive(TreeNode* pTree)
{	
	TreeNode* pTemp = pTree;
	stack<TreeNode*> treeStack;

	
	while(pTemp || !treeStack.empty())
	{
		// pTemp有效时就访问，入栈，指向左子，一直这样
		while(pTemp != NULL)
		{
			// 访问
			cout<<pTemp->data<<endl;
			// 压入
			treeStack.push(pTemp);
			// 指向左子
			pTemp = pTemp->left;
		}

		// 栈非空时，回退一个节点，指向右子
		if (pTemp == NULL && !treeStack.empty())
		{
			pTemp = treeStack.top();
			// 指向右子
			pTemp = pTemp->right;
			// 弹出
			treeStack.pop();
		}
	}
}

中序遍历的递归法和非递归法：

结果如下图：

代码如下：

		中序遍历		/
// 递归法
void Mid_Recursive(TreeNode* pTree)
{	
	if (pTree != NULL)
	{
		Mid_Recursive(pTree->left);		// 左子
		cout<<pTree->data<<endl;		// 根节点
		Mid_Recursive(pTree->right);	// 右子
	}
}

// 非递归法
void Mid_No_Recursive(TreeNode* pTree)
{	
	TreeNode* pTemp = pTree;
	stack<TreeNode*> treeStack;


	while(pTemp || !treeStack.empty())
	{
		// pTemp有效时就入栈，指向左子，一直这样
		while(pTemp != NULL)
		{
			// 压入
			treeStack.push(pTemp);
			// 指向左子
			pTemp = pTemp->left;
		}

		if (pTemp == NULL && !treeStack.empty())
		{
			pTemp = treeStack.top();
			cout<<pTemp->data<<endl;
			// 指向右子
			pTemp = pTemp->right;
			// 弹出
			treeStack.pop();
		}
	}
}

后序遍历的递归法和非递归法：

结果如下图：

代码如下：

		后序遍历		/
// 递归法
void After_Recursive(TreeNode* pTree)
{	
	if (pTree != NULL)
	{
		After_Recursive(pTree->left);	// 左子
		After_Recursive(pTree->right);	// 右子
		cout<<pTree->data<<endl;		// 根节点
	}
}

// 非递归法
void After_No_Recursive(TreeNode* pTree)
{	
	TreeNode* pTemp = pTree;
	stack<TreeNode*> treeStack1;// 临时存储节点
	stack<TreeNode*> treeStack2;// 存储所有的节点，顺序：根节点，右子，左子，后面只需打印即可


	while(pTemp || !treeStack1.empty())
	{
		// pTemp有效时就入栈，指向左子，一直这样
		while(pTemp != NULL)
		{
			// 压入本节点
			treeStack1.push(pTemp);
			treeStack2.push(pTemp);
			
			// 指向右子
			pTemp = pTemp->right;
		}

		if(pTemp == NULL && !treeStack1.empty()) 
		{
			pTemp = treeStack1.top();
			pTemp = pTemp->left;
			treeStack1.pop();
		}
	}

	// 由于存储顺序是:根节点，右子，左子，这里只需逐个打印
	while(!treeStack2.empty())
	{
		pTemp = treeStack2.top();
		cout<<pTemp->data<<endl;
		treeStack2.pop();
	}
}

层序遍历的非递归法：

结果如下图：

代码如下：

// 层序遍历
void Level_Recursive(TreeNode* pTree)
{
	if (pTree == NULL)
	{
		return;
	}
	
	queue<TreeNode*> que;
	que.push(pTree);

	while(!que.empty())
	{
		// 取得队列头部元素，后把节点出队
		TreeNode* pTemp = que.front();
		que.pop();

		cout<<pTemp->data<<endl;

		// 压入左子，右子
		if (pTemp->left != NULL)
		{
			que.push(pTemp->left);
		}
		if (pTemp->right != NULL)
		{
			que.push(pTemp->right);
		}
	}
}

完整代码如下：

#include <iostream>
#include <stack>
#include <queue>
using namespace std;

// 树(节点)定义
struct TreeNode 
{
	int			data;
	TreeNode*	left;
	TreeNode*	right;
};

// 按照前序建立二叉树，这里我们建立下面的树
//			8
//		6		11
//	  4	  7			12
// 所以输入顺序是：864007001101200
void createTree(TreeNode*& t)
{	
	cout<<"请输入数据："<<endl;
	int val = 0;
	cin>>val;

	// 0表结束
	if (0 == val)
	{
		t = NULL;
	}
	else 
	{
		t = new TreeNode();
		t->data = val;
		cout<<"开始建立:"<<val<<"的左节点：";
		createTree(t->left);
		cout<<"开始建立:"<<val<<"右节点：";
		createTree(t->right);
	}
}

		前序遍历		/
// 递归法
void Pre_Recursive(TreeNode* pTree)
{	
	if (pTree != NULL)
	{
		cout<<pTree->data<<endl;	// 根节点
		Pre_Recursive(pTree->left);		// 左子
		Pre_Recursive(pTree->right);	// 右子
	}
}

// 非递归法
void Pre_No_Recursive(TreeNode* pTree)
{	
	TreeNode* pTemp = pTree;
	stack<TreeNode*> treeStack;

	
	while(pTemp || !treeStack.empty())
	{
		// pTemp有效时就访问，入栈，指向左子，一直这样
		while(pTemp != NULL)
		{
			// 访问
			cout<<pTemp->data<<endl;
			// 压入
			treeStack.push(pTemp);
			// 指向左子
			pTemp = pTemp->left;
		}

		// 栈非空时，回退一个节点，指向右子
		if (pTemp == NULL && !treeStack.empty())
		{
			pTemp = treeStack.top();
			// 指向右子
			pTemp = pTemp->right;
			// 弹出
			treeStack.pop();
		}
	}
}

		中序遍历		/
// 递归法
void Mid_Recursive(TreeNode* pTree)
{	
	if (pTree != NULL)
	{
		Mid_Recursive(pTree->left);		// 左子
		cout<<pTree->data<<endl;		// 根节点
		Mid_Recursive(pTree->right);	// 右子
	}
}

// 非递归法
void Mid_No_Recursive(TreeNode* pTree)
{	
	TreeNode* pTemp = pTree;
	stack<TreeNode*> treeStack;


	while(pTemp || !treeStack.empty())
	{
		// pTemp有效时就入栈，指向左子，一直这样
		while(pTemp != NULL)
		{
			// 压入
			treeStack.push(pTemp);
			// 指向左子
			pTemp = pTemp->left;
		}

		if (pTemp == NULL && !treeStack.empty())
		{
			pTemp = treeStack.top();
			cout<<pTemp->data<<endl;
			// 指向右子
			pTemp = pTemp->right;
			// 弹出
			treeStack.pop();
		}
	}
}

		后序遍历		/
// 递归法
void After_Recursive(TreeNode* pTree)
{	
	if (pTree != NULL)
	{
		After_Recursive(pTree->left);	// 左子
		After_Recursive(pTree->right);	// 右子
		cout<<pTree->data<<endl;		// 根节点
	}
}

// 非递归法
void After_No_Recursive(TreeNode* pTree)
{	
	TreeNode* pTemp = pTree;
	stack<TreeNode*> treeStack1;// 临时存储节点
	stack<TreeNode*> treeStack2;// 存储所有的节点，顺序：根节点，右子，左子，后面只需打印即可


	while(pTemp || !treeStack1.empty())
	{
		// pTemp有效时就入栈，指向左子，一直这样
		while(pTemp != NULL)
		{
			// 压入本节点
			treeStack1.push(pTemp);
			treeStack2.push(pTemp);
			
			// 指向右子
			pTemp = pTemp->right;
		}

		if(pTemp == NULL && !treeStack1.empty()) 
		{
			pTemp = treeStack1.top();
			pTemp = pTemp->left;
			treeStack1.pop();
		}
	}

	// 由于存储顺序是:根节点，右子，左子，这里只需逐个打印
	while(!treeStack2.empty())
	{
		pTemp = treeStack2.top();
		cout<<pTemp->data<<endl;
		treeStack2.pop();
	}
}

// 层序遍历
void Level_Recursive(TreeNode* pTree)
{
	if (pTree == NULL)
	{
		return;
	}
	
	queue<TreeNode*> que;
	que.push(pTree);

	while(!que.empty())
	{
		// 取得队列头部元素，后把节点出队
		TreeNode* pTemp = que.front();
		que.pop();

		cout<<pTemp->data<<endl;

		// 压入左子，右子
		if (pTemp->left != NULL)
		{
			que.push(pTemp->left);
		}
		if (pTemp->right != NULL)
		{
			que.push(pTemp->right);
		}
	}
}

int main()
{
	TreeNode* pTree = NULL;
	createTree(pTree);

	// 前序-递归法
	cout<<"\n递归法前序遍历树"<<endl;
	Pre_Recursive(pTree);

	// 前序-非递归法
	cout<<"\n非递归法前序遍历树"<<endl;
	Pre_No_Recursive(pTree);

	// 中序-递归法
	cout<<"\n递归法中序遍历树"<<endl;
	Mid_Recursive(pTree);

	// 中序-非递归法
	cout<<"\n非递归法中序遍历树"<<endl;
	Mid_No_Recursive(pTree);

	// 后序-递归法
	cout<<"\n递归法后序遍历树"<<endl;
	After_Recursive(pTree);

	// 后序-非递归法
	cout<<"\n非递归法后序遍历树"<<endl;
	After_No_Recursive(pTree);

	// 层序遍历-非递归法
	cout<<"\n非递归法层序遍历树"<<endl;
	Level_Recursive(pTree);

	system("pause");
}

 

YZF_Kevin
关注
专栏目录
二叉树先序遍历的非递归算法
行者
01-06 1万+
在前面一文，说过二叉树的递归遍历算法（二叉树先根（先序）遍历的改进 ），此文主要讲二叉树的非递归算法，采用栈结构 总结先根遍历得到的非递归算法思想如下： 1）入栈，主要是先头结点入栈，然后visit此结点 2）while，循环遍历当前结点，直至左孩子没有结点 3）if结点的右孩子为真，转入1）继续遍历，否则退出当前结点转入父母结点遍历转入1） 先看符合此思想的算法： int PreO
数据结构——二叉树先序、中序、后序及层次四种遍历（C语言版）
热门推荐
正弦定理的博客
12-09 36万+
数据结构——二叉树先序、中序、后序三种遍历二叉树先序、中序、后序三种遍历三、代码展示： 二叉树先序、中序、后序三种遍历 先序遍历：3 2 2 3 8 6 5 4 中序遍历：2 2 3 3 4 5 6 8 后序遍历: 2 3 2 4 5 6 8 3 三种遍历不同之处在，输出数据放在不同之处 三、代码展示： #include<stdio.h> #include<stdlib.h> typedef struct Tree{ int
二叉树三种遍历的非递归算法
alfredtofu的专栏
01-11 834
<br />1.先序遍历非递归算法 #define maxsize 100 typedef struct { Bitree Elem[maxsize]; int top; }SqStack; void PreOrderUnrec(Bitree t) { SqStack s; StackInit(s); p=t; while (p!=null || !StackEmpty(s)) { while (
二叉树先序、中序、后序遍历的非递归实现，纯c代码
zgangz的专栏
10-23 915
遍历是二叉树操作的基础，在学习数据结构的过程中，很多人对递归遍历烂熟于心而忽略了非递归方式。非递归相对于递归有更高的效率而且不会出现递归可能产生的栈溢出，这里我们采用非递归的方式来进行二叉树的遍历，以下是C代码，水平有限，若有问题，不吝赐教。 btree.c /*************************************************************
程序实现二叉树遍历：先序/中序/后序/层次（递归/非递归）
JJ-Li的博客
12-14 557
数据结构上机问题：程序实现二叉树遍历。有先序，中序，后序和层次遍历，基于递归和非递归
二叉树的前序、中序、后序的遍历(递归&非递归)
HanSion.Z
08-21 1231
前言：二叉树的非递归遍历需要用到栈的一些操作，所以贴出栈的相关操作的链接 https://blog.csdn.net/hansionz/article/details/81636557 定义数据结构 typedef char BTDataType; typedef struct BinaryTreeNode { BTDataType _data; struct Bin...
数据结构试验报告用先序中序建立二叉树后序遍历非递归.pdf
09-27
后序遍历非递归算法的实现相对复杂，需要利用栈的操作来实现。 4. 结构体的定义和使用：在C语言的实现中，结构体（struct）被用来定义树节点，其中包含了数据域（如字符型的data域）和指针域（lchild和rchild分别...
先序中序后序遍历二叉树的递归算法C语言,编写一个程序，实现二叉树的先序遍历，中序遍历，后序遍历的各种递归和非递归算法，以及层次遍历的算法...
weixin_39792803的博客
05-24 3184
满意答案文件 main.cpp 代码如下：#include // malloc()等#include // 标准输入输出头文件，包括EOF(=^Z或F6)，NULL等#include // atoi()，exit()#include // 数学函数头文件，包括floor()，ceil()，abs()等#define ClearBiTree DestroyBiTree // 清空二叉树和销毁二叉树的...
二叉树的三种遍历（先序中序后序）——递归非递归算法
筱羊冰冰
08-02 1111
回忆 在上一个关于树的博客提到了二叉树的三种遍历方式，还有一个单独的层次遍历。 先序、中序、后序本质山就是根、左、右的顺序问题 先序：根左右 中序：左根右 后序：左右根 递归算法 因为二叉树的定义（其实应该说树的定义）里面有递归的影子：每一个子树也要符合上述条件 （具体参见上一篇博客） 所以递归算法应该是最先想到的，而且因为递归的性质，函数形式也是最简单的。 先序： 在这里插入代码片 中序： ...
二叉树必学算法（一）：二叉树的先序中序后序遍历 - 递归
AuthurLEE's Blogs
05-19 662
二叉树先序中序后序遍历的递归算法
先序遍历二叉树的非递归算法程序
01-25
编写先序遍历二叉树的非递归算法程序，要求： （1）以二叉链表建立二叉树。 （2）输出遍历的结点序列。 （3）有实例验算。
二叉树遍历 递归与非递归 先序-中序-后序
指尖飞舞
03-01 647
序 题目： 分别用递归和非递归的方式实现二叉树先序、中序、后序遍历！ 二叉树节点结构 struct TreeNode{ int val; TreeNode *left; TreeNode *right; TreeNode(int v) :val(v), left(NULL), right(NULL){} }; 先序遍历 递归实现 /*递归先序遍历*/ void pr
二叉树的前序、中序、后续遍历及非递归实现代码（C++实现）
qq_45095696的博客
11-26 220
树的结构定义 每一个树节点包括自己存储的数据和左右孩子的地址。 struct treenode { int data; //默认存储int类型，需要更改模板类 treenode* left; treenode* right; treenode() :data(0), left(nullptr), right(nullptr) {} treenode(int data) :data(data), left(nullptr), right(nullptr) {} };
二叉树先序、中序、后序遍历 递归非递归实现
达文西的博客
06-20 137
import java.util.LinkedList; import java.util.Queue; import java.util.Stack; public class TreeTest { /** * BFS * 先序遍历 */ public static void preOrderRecursion(TreeNode root) { if (ro...
二叉树的先序、中序、后序遍历算法【递归、非递归】
最新发布
宇宙超粒终端控制中心的博客
02-20 639
遍历，就是按照某种次序把所有的节点都访问一遍如果是空二叉树，无序遍历；如果是非空二叉树，可以按照先序、中序、后序遍历。
实现二叉树的先序、中序、后序遍历，包括递归方式和非递归方式
qq_43193797的博客
02-04 529
节点类： public class Node {    private int data;     private Node left;     private Node right;     public Node(int data){         this.data = data;     }     public Node(){     }     public int g...
二叉树的先序,中序,后序遍历(非递归算法)
weixin_44203609的博客
09-24 3950
二叉树的非递归前、中、后序遍历算法详解及代码实现（C语言） 1. 前序遍历和中序遍历非递归算法思路 前序和中序非递归遍历的C代码 2. 后序遍历非递归算法思路 后序非递归遍历的C代码 1. 前序遍历和中序遍历非递归算法思路 遍历过程：（如图所示） 图1 前序遍历和中序遍历流程图 从当前节点开始遍历：（当入栈时访问节点内容，则为前序遍历；出栈时访问，则为中序遍历） 1. 若当前节点存在，就存入栈中，并访问左子树； 2. 直到当前节点不存在，就出栈，并通过栈顶节点访问右子树； 3.
二叉树的先序遍历，中序遍历，后序遍历（递归和非递归）
花小七
03-29 611
先序遍历（递归） def preOrderTraverse(node): if node is None: return None print(node.val) preOrderTraverse(node.left) preOrderTraverse(node.right) 先序遍历（非递归） def preOrderTravese(no...
二叉树的先序、中序、后序遍历的递归及非递归形式以及一些树的题目
yinyang_ddl的博客
03-24 677
二叉树的节点遍历顺序，节点遍历顺序是不变的，问题在于将打印节点的语句放在哪里，因此将打印时机放在第几次来到这个节点会造成遍历顺序的不同；第一次来到这个节点，被称作先序遍历，第二次来到这个节点被称作中序遍历，第三次来到这个节点被称作后序遍历！ 递归式的二叉树遍历，每一个节点都将出现3次！ 非递归的先序遍历： stack 弹出并打印当前节点，针对于当前节点，以先右后左的顺序...
非递归C语言实现二叉树遍历：先序、中序、后序
"二叉树的建立和非递归遍历是数据结构中的重要概念，本文将探讨如何在C语言中实现非递归版本的先序、中序和后序遍历。" 在计算机科学中，二叉树是一种常用的数据结构，它由节点组成，每个节点有两个子节点：左子...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值