数据结构与算法（6-3）二叉树的遍历（前序遍历、中序遍历、后序遍历、层序遍历）（层序遍历分别用队列和链队列实现）

最新推荐文章于 2024-07-28 17:42:24 发布
最新推荐文章于 2024-07-28 17:42:24 发布
阅读量3.7k 收藏 16
点赞数 3
分类专栏： # 数据结构与算法 文章标签： 数据结构 算法 c++ c语言 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/great_yzl/article/details/119323855
版权

目录

一、前序遍历

二、中序遍历

三、后序遍历

 前中后序遍历总代码

四、层序遍历（队列实现(主流)）

总代码 

五、层序遍历（链队列实现(自创)）

 总代码

二叉树的遍历分为前序、中序、后序以及层序遍历。

前中后序是按照根结点的访问顺序来确定的，前中后序遍历的核心都是递归。

一、前序遍历

访问顺序：根->左->右

普通二叉树遍历（前序）：ABDCG

扩展二叉树遍历（前序）：ABD###C#G##

实现顺序：

1、生成根结点

2、递归遍历左子树

3、递归遍历右子树

代码：

//先序遍历（根->左->右）
void PreOrderTraverse(BiTree* T)
{
	//空
	if (T->data == ' ' || T->data == '#')
	{
		printf("%c", T->data);
		return;
	}
	//非空
	printf("%c", T->data);					//访问根结点
	PreOrderTraverse(T->lchild);		//左子树
	PreOrderTraverse(T->rchild);		//右子树
}

二、中序遍历

访问顺序：左->根->右

普通二叉树遍历（中序）：DBACG

扩展二叉树遍历（中序）：#D#B#A#C#G#

实现顺序：

1、递归遍历左子树

2、生成根结点

3、递归遍历右子树

代码：

//中序遍历（左->根->右）
void InOrderTraverse(BiTree* T)
{
	//空
	if (T->data == ' ' || T->data == '#')
	{
		printf("%c", T->data);
		return;
	}
	//非空
	InOrderTraverse(T->lchild);		//左子树
	printf("%c", T->data);					//访问根结点
	InOrderTraverse(T->rchild);		//右子树
}

三、后序遍历

访问顺序：左->右->根

普通二叉树遍历（后序）：DBGCA

扩展二叉树遍历（后序）：##D#B###GCA

实现顺序：

1、递归遍历左子树

2、递归遍历右子树

3、生成根结点

代码：

//后序遍历（左->右->根）
void PostOrderTraverse(BiTree* T)
{
	int i = 0;
	//空
	if (T->data == ' ' || T->data == '#')
	{
		printf("%c", T->data);
		return;
	}
	//非空
	PostOrderTraverse(T->lchild);		//左子树
	PostOrderTraverse(T->rchild);		//右子树
	printf("%c", T->data);				//访问根结点
}

 前中后序遍历总代码

//二叉树的遍历
//先序遍历：根左右			中序遍历：左根右			后序遍历：左右根
//(创建默认先序遍历)
#include<stdio.h>
#include<malloc.h>

int flag = 0, index = 0;
char str[30];

//二叉树结点
typedef struct BiTree
{
	char data;
	struct BiTree* lchild, * rchild;
}BiTree;
BiTree* head = NULL;


void Init_Bitree()
{
	head = (BiTree*)malloc(sizeof(BiTree));
}

//创建树（先序遍历）
void Create_BiTree(BiTree* T)
{
	char ch;
	scanf_s("%c", &ch);

	//退出递归
	if (ch == '\n' || flag == 1)
	{
		flag = 1;
		return;
	}

	//空元素
	if (ch == ' ' || ch == '#')
	{
		T->data = ch;
		return;
	}
	//非空元素
	T->data = ch;										//构造根结点
	T->lchild = (BiTree*)malloc(sizeof(BiTree));
	T->rchild = (BiTree*)malloc(sizeof(BiTree));
	Create_BiTree(T->lchild);						//构造左子树
	Create_BiTree(T->rchild);						//构造右子树
}

//先序遍历（根->左->右）
void PreOrderTraverse(BiTree* T)
{
	//空
	if (T->data == ' ' || T->data == '#')
	{
		printf("%c", T->data);
		return;
	}
	//非空
	printf("%c", T->data);					//访问根结点
	PreOrderTraverse(T->lchild);		//左子树
	PreOrderTraverse(T->rchild);		//右子树
}

//中序遍历（左->根->右）
void InOrderTraverse(BiTree* T)
{
	//空
	if (T->data == ' ' || T->data == '#')
	{
		printf("%c", T->data);
		return;
	}
	//非空
	InOrderTraverse(T->lchild);		//左子树
	printf("%c", T->data);					//访问根结点
	InOrderTraverse(T->rchild);		//右子树
}

//后序遍历（左->右->根）
void PostOrderTraverse(BiTree* T)
{
	int i = 0;
	//空
	if (T->data == ' ' || T->data == '#')
	{
		printf("%c", T->data);
		return;
	}
	//非空
	PostOrderTraverse(T->lchild);		//左子树
	PostOrderTraverse(T->rchild);		//右子树
	printf("%c", T->data);				//访问根结点
}


int main()
{
	Init_Bitree();
	printf("请按照扩展二叉树前序遍历顺序输入需要创建的二叉树结点：\n");
	Create_BiTree(head);						//创建二叉树

	flag = 0;
	printf("\n先序遍历：\n");
	PreOrderTraverse(head);							//先序遍历

	printf("\n中序遍历：\n");
	InOrderTraverse(head);							//中序遍历

	printf("\n后序遍历：\n");
	PostOrderTraverse(head);						//后序遍历

	return 0;
}

四、层序遍历（队列实现(主流)）

访问顺序：逐层从左往右访问。

 思想：利用队列，把根结点入队，再依次出队，再让其左右孩子结点入队，以此类推。

普通二叉树遍历（层序）：ABCDG

扩展二叉树遍历（后序）：ABCD##G 

代码：

//层序遍历
void LevelOrderTraverse(BiTree* N)
{
	EnQueue(N);								//根元素入队
	while (Q.front != Q.rear)				//队列不为空
	{
		*N = DeQueue();						//队首元素出队（并以它为根，进行遍历）
		if (N->lchild != NULL)
			EnQueue(N->lchild);			//入队左结点
		if (N->rchild != NULL)
			EnQueue(N->rchild);			//入队右结点
		cout << N->data;
	}
}

总代码 

//二叉树的层序遍历（队列）
//先放入根结点，然后判断是否有孩子结点，有则放入队列。
//最后取出队列的首结点，把它作为根继续遍历
//这样就达到了按层依次遍历的效果
//附加内容：二级指针（可以修改地址）
#include<iostream>
#include<malloc.h>
using namespace std;

#define MAXSIZE 100
int index = 0;

//二叉树
typedef struct BiTree
{
	char data;
	struct BiTree* lchild, * rchild;
}BiTree, * pBiTree;
BiTree* head;				//二叉树根结点

//队列
typedef struct
{
	BiTree node[MAXSIZE];
	int front;
	int rear;
}Queue;
Queue Q;


void Init()
{
	//二叉树
	head = (BiTree*)malloc(sizeof(BiTree));
	head->lchild = NULL;
	head->rchild = NULL;

	//队列
	Q.front = -1;
	Q.rear = -1;
}

//创建二叉树
void Create_BiTree(pBiTree* N)
{
	char ch;
	cin >> ch;
	if (ch != '#')				//不为空
	{
		(*N)->lchild = (BiTree*)malloc(sizeof(BiTree));
		(*N)->rchild = (BiTree*)malloc(sizeof(BiTree));
		Create_BiTree(&(*N)->lchild);
		(*N)->data = ch;
		Create_BiTree(&(*N)->rchild);
	}
	else
	{
		(*N) = NULL;			//地址赋空			（二级指针，可以改变地址）
	}
}

//入队
void EnQueue(BiTree* node)
{
	Q.node[++Q.rear] = *node;
}

//出队
BiTree DeQueue()
{
	return Q.node[++Q.front];
}

//层序遍历
void LevelOrderTraverse(BiTree* N)
{
	EnQueue(N);								//根元素入队
	while (Q.front != Q.rear)				//队列不为空
	{
		*N = DeQueue();						//队首元素出队（并以它为根，进行遍历）
		if (N->lchild != NULL)
			EnQueue(N->lchild);			//入队左结点
		if (N->rchild != NULL)
			EnQueue(N->rchild);			//入队右结点
		cout << N->data;
	}
}

int main()
{
	Init();

	cout << "请输入需要创建二叉树的字符串：\n";
	Create_BiTree(&head);

	LevelOrderTraverse(head);

	return 0;
}

五、层序遍历（链队列实现(自创)）

每2^(n-1)个元素为一层，按照层序遍历的方式输入，存入链队列，最后层序输出。

 总代码

//二叉树的层序遍历（链队列）
#include<stdio.h>
#include<malloc.h>
#include<string>
#include<iostream>
#include<math.h>
using namespace std;

int flag = 0;
std::string str;

//队列（用于存放元素）
typedef struct Queue
{
	char data;
	struct Queue* next;
	int level;						//层数
	int num;						//序号
}Queue;
Queue* front, * rear;

void Init_Queue()
{
	front = (Queue*)malloc(sizeof(Queue));
	rear = (Queue*)malloc(sizeof(Queue));
	rear = front;
}

//入队
void EnQueue()
{
	int i, j, level = 0, count = 0;

	printf("请按照层序遍历顺序输入需要创建的二叉树结点(普通二叉树，空结点以#代替)：\n");
	cin >> str;
	i = 0;
	while (pow(2, i) <= strlen(str.c_str()) - 2)
		i++;
	level = i;

	for (i = 0; i < level; i++)						//层
	{
		for (j = 0; j < pow(2, i); j++)				//序号
		{
			if (str[count] == '\0')			//退出
				return;
			Queue* q = (Queue*)malloc(sizeof(Queue));
			q = rear;
			q->data = str[count++];
			q->level = i + 1;					//层
			q->num = j + 1;					//序号
			q->next = NULL;
			if (i == 0)						//首次
				front = q;
			rear->next = (Queue*)malloc(sizeof(Queue));
			rear = rear->next;		//后移
			rear->next = NULL;
		}
	}
}

//层序遍历
void LevelOrderTraverse()
{
	Queue* q = front;
	while (q->next != NULL)
	{
		if (q->data != '#')
			printf("%c的层：%d,   序号：%d\n", q->data, q->level, q->num);
		q = q->next;
	}
}

int main()
{
	Init_Queue();
	EnQueue();					//入队
	LevelOrderTraverse();	//层序遍历

	return 0;
}

_(*^▽^*)_
关注
专栏目录
遍历二叉树
weixin_52555350的博客
03-25 5241
二叉树遍历
二叉树的遍历
虫师
04-18 219
二叉树的遍历有三种方式，如下： （1）前序遍历（DLR），首先访问根结点，然后遍历左子树，最后遍历右子树。简记根-左-右。 （2）中序遍历（LDR），首先遍历左子树，然后访问根结点，最后遍历右子树。简记左-根-右。 （3）后序遍历（LRD），首先遍历左子树，然后遍历右子树，最后访问根结点。简记左-右-根。 例1：如上图所示的二叉树，若按前序遍历，则其输出...
二叉树的遍历（先序、中序、后序、层次）
最新发布
kusunoki的博客
07-28 7133
参照王道数据结构辅导书以及哔哩哔哩大学的部分视频，对二叉树遍历的重要知识点进行归纳，并总结做题技巧。
用C++实现的完全二叉树，实现前序遍历，中序遍历，后序遍历。
EncodedStar的博客
04-17 2048
用C++实现的完全二叉树，实现前序遍历，中序遍历，后序遍历。
6.3 二叉树的层序遍历——【LeetCode】
DZSpace，专注于计算机科学与技术领域的技术博主，致力于分享实用知识与技巧，帮助读者快速掌握技术要点，共同探索计算机世界的无限可能。欢迎访问DZSpace的博客，一起学习进步！
02-28 264
public class four { } //102.二叉树的层序遍历 class Solution { public List<List<Integer>> resList = new ArrayList<List<Integer>>(); public List<List<Integer>> levelOrder(TreeNode root){ checkFun01(root, 0); checkFun0.
6-3 遍历二叉树
Log.e的博客
04-19 1779
1.遍历概念： 顺着某一条搜索路径巡访二叉树中的结点，使得每个结点均被访问一次，而且仅被访问一次。 2.“访问”的含义很广，可以是对结点作各种处理， 如：输出结点的信息、修改结点的数据值等，但要求这种访问不破坏原来的数据结构。 （他是一个引用型操作） 遍历目的： 得到树中所有结点的一个线性排列。 4.遍历方法： DLR —— 先（根）序遍历， ...
二叉树遍历
weixin_43763430的博客
05-01 611
1、二叉树遍历 二叉树的性质：二叉树（binary tree）是指树中节点的度不大于2的有序树，即每个结点都不能有多于两个结点。如下图所示为一颗二叉树： 二叉树的遍历分为先序遍历、中序遍历、后序遍历。先序、中序、后序是对于根节点（父节点）访问顺序来确定的。 先序遍历思想：先访问根结点；再访问当前结点的左子树；再访问当前节点的右子树。如上图的二叉树先序遍历为：1，2，4，5，3，6，7 中序遍历思想：先访问当前结点的左子树；再访问当前节点；最后访问当前节点的右子树。如上图二叉树中序遍历为：4
Python二叉树的遍历操作示例【前序遍历,中序遍历,后序遍历,层序遍历】
09-19
本文将深入探讨Python中的二叉树及其遍历方法，包括前序遍历、中序遍历、后序遍历以及层序遍历。通过具体的代码示例，我们将更好地理解这些遍历方法的工作原理和应用场景。 #### 二、二叉树基础知识回顾 二叉树是由...
数据结构实验报告6-树-二叉树的遍历算法-实验内容及要求.docx
07-06
根据给定文件的信息，我们可以详细地探讨一下关于二叉树的遍历算法这一主题，包括实验的目的、数据结构的设计、算法的设计以及输入/输出的设计等内容。 ### 实验目的 本次实验的主要目的是让学生深入理解并掌握...
JavaScript数据结构与算法之二叉树遍历算法详解【先序、中序、后序】
12-09
本文实例讲述了JavaScript数据结构与算法之二叉树遍历算法。分享给大家供大家参考，具体如下： javascript数据结构与算法–二叉树遍历（先序） 先序遍历先访问根节点， 然后以同样方式访问左子树和右子树 代码如下...
二叉树遍历（前序、中序、后序、层次遍历、深度优先、广度优先）
热门推荐
My_Jobs的专栏
02-03 38万+
二叉树是一种非常重要的数据结构，很多其它数据结构都是基于二叉树的基础演变而来的。对于二叉树，有深度遍历和广度遍历，深度遍历有前序、中序以及后序三种遍历方法，广度遍历即我们平常所说的层次遍历。因为树的定义本身就是递归定义，因此采用递归的方法去实现树的三种遍历不仅容易理解而且代码很简洁，而对于广度遍历来说，需要其他数据结构的支撑，比如堆了。所以，对于一段代码来说，可读性有时候要比代码本身的效率要重要的
6.3二叉树的遍历
WithoutEndFree的博客
07-03 944
6.3二叉树的遍历 二叉树的遍历是指按一定规律对二叉树中的每个结点进行访问且仅访问一次。二叉树 是非线性数据结构，遍历操作就是将二叉树中结点按一定规律线性化的操作，目的在于将非 线性化结构变成线性化的访问序列。二叉树的遍历操作是二叉树中最基本的运算。 一、二叉树遍历的定义 二叉树的遍历是指按一定规律对二叉树中的每个结点进行访问且仅访问一次。其中的访问可指计算二叉树中结点的数据信息，打印该结点的信息，也包括对结点进行任何其他操作。 为什么需要遍历二叉树？二叉树是非线性数据结构，通过遍历可以将二叉树中的结点访问
二叉树遍历实现：前序、中序、后序与层序
"这篇资料主要介绍了数据结构中的二叉树遍历方法，包括前序遍历、中序遍历、后序遍历和层序遍历，并提供了相关的C语言实现代码。" 在计算机科学中，数据结构是组织和管理数据的重要方式，而二叉树作为一种特殊的...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

_(*^▽^*)_

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

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

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

打赏作者

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

抵扣说明：

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

余额充值