【数据结构】遍历二叉树（递归思想）--＞赋源码

已于 2024-06-19 23:33:14 修改
阅读量3.5k 收藏 89
点赞数 158
分类专栏： 数据结构 文章标签： 数据结构
于 2024-06-15 15:54:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Cayyyy/article/details/139703731
版权

欢迎来到我的Blog，点击关注哦💕

前言

二叉树遍历是指按照一定的顺序访问二叉树中的每个节点，使得每个节点恰好被访问一次。遍历是二叉树上最重要的运算之一，是二叉树上进行其他运算的基础。

一、二叉树遍历概念

在这里插入图片描述

二叉树遍历分类

  • 前序遍历 ：根节点–>左子树–>右子树。在前序遍历时，首先访问根节点，然后依次访问左子树和右子树。
  • 中序遍历 : 左子树–>根节点–>右子树。在中序遍历时，首先访问左子树，然后访问根节点，最后访问右子树。
  • 后序遍历：左子树–>右子树–>根节点。在后序遍历时，首先访问左子树和右子树，然后访问根节点。
  • 层序遍历： 由顶层到底层，一层一层遍历。

二叉树其他操作

树节点的个数，树深度，树 k 层的个数，查找节点。

二、二叉树遍历实现

我们以下面为例子：
1
2
3
4
5
6
7
8
9
2_right_NULL
3_left_NULL

2.1 二叉树建立

1.定义一个结构体，分别有左右两个指针。

2.为每一个节点创建孔家。

3.创建二叉树，并如上图连接。

//定义结构体

typedef int BTTypeData;

typedef struct BinaryTree
{
	BTTypeData data;

	struct BinaryTree* left;
	struct BinaryTree* right;
}BinaryTree;

//创建空间

BinaryTree* BuyBinaryTree(BTTypeData x)
{
	BinaryTree* node = (BinaryTree*)malloc(sizeof(BinaryTree));
	if (node == NULL)
	{
		perror("malloc fail");
		return NULL;
	}

	node->data = x;
	node->left = NULL;
	node->right = NULL;

	return node;
}

//建树

BinaryTree* CreateBinaryTree()
{

	BinaryTree* node1 = BuyBinaryTree(1);
	BinaryTree* node2 = BuyBinaryTree(2);
	BinaryTree* node3 = BuyBinaryTree(3);
	BinaryTree* node4 = BuyBinaryTree(4);
	BinaryTree* node5 = BuyBinaryTree(5);
	BinaryTree* node6 = BuyBinaryTree(6);
	BinaryTree* node7 = BuyBinaryTree(7);
	BinaryTree* node8 = BuyBinaryTree(8);
	BinaryTree* node9 = BuyBinaryTree(9);

	node1->left = node2;
	node1->right = node4;
	node2->left = node3;
	node4->left = node5;
	node4->right = node6;
	node3->right = node7;
	node6->left = node8;
	node6->right = node9;


	return node1;
}

2.2 前序遍历

在递归实现中，前序遍历的基本思想是对于每一个节点，先访问该节点，然后对其左子树进行前序遍历，最后对其右子树进行前序遍历。如果当前节点为空，则直接返回。这种方法的优点是代码简洁明了，易于理解，但缺点是可能导致栈溢出，特别是在处理深度较大的二叉树时。

遍历结果：1–> 2–> 3 –>7 –>4 –>5 –>6–> 8 –>9

//前序遍历
void PreOrder(BinaryTree* root)
{
	
	
	if (root == NULL)
	{
		//printf("NULL ");
		return;
	}

	printf("%d ", root->data);
	PreOrder(root->left);
	PreOrder(root->right);
}

2.2 中序遍历

首先对左子树进行中序遍历，然后访问根节点，最后对右子树进行中序遍历。

遍历结果：3 –>7–>2–> 1–> 5–> 4–>8–> 6–> 9

void InOrder(BinaryTree* root)
{


	if (root == NULL)
	{
		//printf("NULL ");
		return;
	}

	InOrder(root->left);
	printf("%d ", root->data);
	InOrder(root->right);

}

2.3 后序遍历

递归函数首先访问左子树，然后访问右子树，最后访问根节点。如果当前节点为空，则直接返回。

遍历结果：7–> 3–> 2–> 5–> 8 –>9 –>6 –>4 –>1

//后序遍历
void PostOrder(BinaryTree* root)
{


	if (root == NULL)
	{
		//printf("NULL ");
		return;
	}

	PostOrder(root->left);
	PostOrder(root->right);
	printf("%d ", root->data);

}

2.4 层序遍历

在二叉树的层序遍历是指按照树的层次顺序，从上到下、从左到右逐层访问二叉树的节点。这种遍历方式可以帮助我们了解二叉树的结构布局，特别是在处理树状数据结构时非常有用。

利用队列的特点，有关队列可参考 栈和队列

  • 将根节点入队。

  • 当队列不为空时，从队列中取出一个节点，访问该节点。

  • 将该节点的左右子节点（如果存在）入队。

  • 重复步骤2和3，直到队列为空。

遍历结果：1–> 2 –>4 –>3 –>5 –>6 –>7 –>8 –>9

//层序遍历

void LevelOrder(BinaryTree* root)
{
	if (root == NULL)
	{
		printf("NULL ");
		return;
	}
	Queue TBT;
	QueueInit(&TBT);

	if (root)
		QueuePush(&TBT, root);
	
	while (!QueueEmpty(&TBT))
	{
		BinaryTree* front = QueueTop(&TBT);
		QueuePop(&TBT);
		printf("%d ", front->data);

		if (front->left)
			QueuePush(&TBT, front->left);
		if (front->right)
			QueuePush(&TBT, front->right);

	}

	QueueDestroy(&TBT);

}

2.5 二叉树的节点个数

利用递归的方法，左右子树调用，如果该节点为NULL 便会返回0，否则返回1。

//树的结点个数

int TreeSize(BinaryTree* root)
{

	return root == 0 ? 0:TreeSize(root->left) + TreeSize(root->right) + 1;

}

2.6 二叉树的深度

利用 left和right记录左右子树的个数，然后比较 选择较大的一个。

如图：在这里插入图片描述

//树的高度

int TreeHeight(BinaryTree* root)
{
	if (root == NULL)
	{
		return 0;
	}

	int left = TreeHeight(root->left) ;
	int right = TreeHeight(root->right);

	return left > right ? left + 1 : right + 1;

}

2.7 二叉树第K层的个数

假设查找第三层，K为3 ，每次递归K–，知道K== 1 的时候 返回1。

//层的个数

int TreeKLevel(BinaryTree* root, int k)
{
	if (root == NULL)
	{
		return 0;
	}

	if (k == 1)
	{
		return 1;
	}


	return TreeKLevel(root->left, k - 1) + TreeKLevel(root->right, k - 1);


}

2.8 二叉树查找结点

节点的查找，如果节点为NULL饭后NULL，如果此节点的data等于x，返回节点的地址。

//查找节点

BinaryTree* TreeFind(BinaryTree* root, BTTypeData x)
{

	if (root == NULL)
	{
		return NULL;
	}

	if (root->data == x)
	{
		return root;
	}

	BinaryTree* lret = TreeFind(root->left, 7);
	if (lret)
		return lret;
	BinaryTree* rret = TreeFind(root->right, 7);
	if (rret)
		return rret;
	return NULL;
}

源码

queue.c

#define _CRT_SECURE_NO_WARNINGS

#include "queue.h"



//初始化
void QueueInit(Queue* ps)
{
	assert(ps);

	ps->head = ps->tail = NULL;

	ps->szie = 0;

}

//销毁
void QueueDestroy(Queue* ps)
{
	assert(ps);
	QNode* cur = ps->head;
	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}

	ps->head = ps->tail = NULL;
	ps->szie = 0;
}

//入队
void QueuePush(Queue* ps,QDataType x)
{
	assert(ps);

	QNode* newcode = (QNode*)malloc(sizeof(QNode));
	if (newcode == NULL)
	{
		perror("malloc fail");
		return ;
	}
	newcode->next = NULL;
	newcode->data = x;

	if (ps->head == NULL)
	{
		ps->head = ps->tail = newcode;
		
	}
	else

	{
		
		ps->tail->next = newcode;
		ps->tail = newcode;
	}

	ps->szie++;

}

//删除
void QueuePop(Queue* ps)
{
	assert(ps);
	assert(ps->head != NULL);
	assert(!QueueEmpty(ps));

	if (ps->head->next == NULL)
	{
		free(ps->head);
		ps->head = ps->tail = NULL;
	}
	else
	{
		QNode* next = ps->head->next;
		free(ps->head);
		ps->head = next;

	}
	ps->szie--;
}

//大小
int QueueSize(Queue* ps)
{
	assert(ps);

	return ps->szie;
}

//判空队
bool QueueEmpty(Queue* ps)
{
	assert(ps);

	return ps->szie == 0;
}

//出队头
QDataType QueueTop(Queue* ps)
{
	assert(ps);
	assert(!QueueEmpty(ps));

	return ps->head->data;
}

//出队尾
QDataType QueueBack(Queue* ps)
{
	assert(ps);

	return ps->tail->data;
}

queue.h

#pragma once

#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <stdbool.h>

typedef struct BinaryTree* QDataType;

typedef struct QNode
{
	struct QNode* next;
	QDataType data;

}QNode;

typedef struct Queue
{
	QNode*head;
	QNode*tail;
	 
	int szie;
}Queue;


//单链表的实现，FIFO

//初始化
void QueueInit(Queue* ps);
//销毁
void QueueDestroy(Queue* ps);
//入队
void QueuePush(Queue* ps, QDataType x);
//删除
void QueuePop(Queue* ps);
//大小
int QueueSize(Queue* ps);
//判空队
bool QueueEmpty(Queue* ps);
//出队头
QDataType QueueTop(Queue* ps);
//出队尾
QDataType QueueBack(Queue* ps);

travelling_binary_tree

#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

#include "queue.h"

//定义结构体

typedef int BTTypeData;

typedef struct BinaryTree
{
	BTTypeData data;

	struct BinaryTree* left;
	struct BinaryTree* right;
}BinaryTree;

//创建空间

BinaryTree* BuyBinaryTree(BTTypeData x)
{
	BinaryTree* node = (BinaryTree*)malloc(sizeof(BinaryTree));
	if (node == NULL)
	{
		perror("malloc fail");
		return NULL;
	}

	node->data = x;
	node->left = NULL;
	node->right = NULL;

	return node;
}

//建树

BinaryTree* CreateBinaryTree()
{

	BinaryTree* node1 = BuyBinaryTree(1);
	BinaryTree* node2 = BuyBinaryTree(2);
	BinaryTree* node3 = BuyBinaryTree(3);
	BinaryTree* node4 = BuyBinaryTree(4);
	BinaryTree* node5 = BuyBinaryTree(5);
	BinaryTree* node6 = BuyBinaryTree(6);
	BinaryTree* node7 = BuyBinaryTree(7);
	BinaryTree* node8 = BuyBinaryTree(8);
	BinaryTree* node9 = BuyBinaryTree(9);

	node1->left = node2;
	node1->right = node4;
	node2->left = node3;
	node4->left = node5;
	node4->right = node6;
	node3->right = node7;
	node6->left = node8;
	node6->right = node9;


	return node1;
}

//前序遍历
void PreOrder(BinaryTree* root)
{
	
	
	if (root == NULL)
	{
		//printf("NULL ");
		return;
	}

	printf("%d ", root->data);
	PreOrder(root->left);
	PreOrder(root->right);
}

//中序遍历

void InOrder(BinaryTree* root)
{


	if (root == NULL)
	{
		//printf("NULL ");
		return;
	}

	InOrder(root->left);
	printf("%d ", root->data);
	InOrder(root->right);

}

//后序遍历
void PostOrder(BinaryTree* root)
{


	if (root == NULL)
	{
		//printf("NULL ");
		return;
	}

	PostOrder(root->left);
	PostOrder(root->right);
	printf("%d ", root->data);

}

//层序遍历

void LevelOrder(BinaryTree* root)
{
	if (root == NULL)
	{
		printf("NULL ");
		return;
	}
	Queue TBT;
	QueueInit(&TBT);

	if (root)
		QueuePush(&TBT, root);
	
	while (!QueueEmpty(&TBT))
	{
		BinaryTree* front = QueueTop(&TBT);
		QueuePop(&TBT);
		printf("%d ", front->data);

		if (front->left)
			QueuePush(&TBT, front->left);
		if (front->right)
			QueuePush(&TBT, front->right);

	}

	QueueDestroy(&TBT);

}

//树的结点个数

int TreeSize(BinaryTree* root)
{

	return root == 0 ? 0:TreeSize(root->left) + TreeSize(root->right) + 1;

}

//树的高度

int TreeHeight(BinaryTree* root)
{
	if (root == NULL)
	{
		return 0;
	}

	int left = TreeHeight(root->left) ;
	int right = TreeHeight(root->right);

	return left > right ? left + 1 : right + 1;

}

//层的个数

int TreeKLevel(BinaryTree* root, int k)
{
	if (root == NULL)
	{
		return 0;
	}

	if (k == 1)
	{
		return 1;
	}


	return TreeKLevel(root->left, k - 1) + TreeKLevel(root->right, k - 1);


}

//查找节点

BinaryTree* TreeFind(BinaryTree* root, BTTypeData x)
{

	if (root == NULL)
	{
		return NULL;
	}

	if (root->data == x)
	{
		return root;
	}

	BinaryTree* lret = TreeFind(root->left, 7);
	if (lret)
		return lret;
	BinaryTree* rret = TreeFind(root->right, 7);
	if (rret)
		return rret;
	return NULL;
}

int main()
{
	BinaryTree* root = CreateBinaryTree();


	PreOrder(root);
	printf("\n");
	InOrder(root);
	printf("\n");
	PostOrder(root);
	printf("\n");
	LevelOrder(root);
	printf("\n");


	printf("TreeSize : %d\n", TreeSize(root));

	printf("TreeHeight : %d\n", TreeHeight(root));

	printf("TreeKLevel : %d\n", TreeKLevel(root, 3));

	printf("TreeFind : %p\n", TreeFind(root, 1));




	return 0; 
}

}

//查找节点

BinaryTree* TreeFind(BinaryTree* root, BTTypeData x)
{

if (root == NULL)
{
	return NULL;
}

if (root->data == x)
{
	return root;
}

BinaryTree* lret = TreeFind(root->left, 7);
if (lret)
	return lret;
BinaryTree* rret = TreeFind(root->right, 7);
if (rret)
	return rret;
return NULL;

}

int main()
{
BinaryTree* root = CreateBinaryTree();

PreOrder(root);
printf("\n");
InOrder(root);
printf("\n");
PostOrder(root);
printf("\n");
LevelOrder(root);
printf("\n");


printf("TreeSize : %d\n", TreeSize(root));

printf("TreeHeight : %d\n", TreeHeight(root));

printf("TreeKLevel : %d\n", TreeKLevel(root, 3));

printf("TreeFind : %p\n", TreeFind(root, 1));




return 0;

}
chian-ocean
关注
专栏目录
数据结构（十三） -- C语言版 -- 树 - 二叉树的遍历（递归、非递归）
青椒*^_^*凤爪爪的博客
05-23 7932
二叉树是一种非线性的数据结构，在怼他进行操作时，总是需要注意对每个元素进行操作，这样就存在一个操作的顺序的问题，由此提出二叉树的遍历的操作。 所谓二叉树的遍历就是按照一定的顺序访问二叉树的每一个节点一次且仅一次的过程，这里的访问可以是输出、比较、更新、查看元素内容等等操作。
数据结构——图的遍历
Benson的博客
02-02 660
图的遍历      树常见的遍历方式有先序、中序、后序以及层次遍历，同样，图也有常见的两种遍历方式，分别是深度优先搜索(DFS)和广度优先搜索(BFS)。见名知意，深搜的策略就是从一个节点开始，访问到一个节点就标记一下，向第一个邻接节点方向搜，如果第一个邻接节点已经被标记访问过了，就向每二个邻接节点方向搜等等，再后再向第一个邻接节点的第一个邻接节点搜，这样递归搜索，直到当前访问的节点的所有邻接节
数据结构之图的遍历
qq_43607916的博客
07-31 1154
图的遍历 文章目录 BFS的算法思想 BFS的代码执行 BFS的相关问题 DFS的算法思想 DFS的代码执行 DFS的相关问题 1.BFS算法思想 BFS，即图的广度优先搜索遍历，它类似于图的层次遍历，它的基本思想是：首先访问起始顶点v，然后选取v的所有邻接点进行访问，再依次对v的邻接点相邻接的所有点进行访问，以此类推，直到所有顶点都被访问过为止。 2.代码执行过程和具体实现 BFS和树的层次遍历一样，采取队列实现，这里添加一个标记数组，用来标记遍历过的顶点。 1.执行步骤： 首先任取图中一个顶点访
数据结构-遍历
qq_45769199的博客
07-20 725
所谓遍历(Traversal)，是指沿着某条搜索路线，依次对树（或图）中每个节点均做一次访问。访问结点所做的操作依赖于具体的应用问题， 具体的访问操作可能是检查节点的值、更新节点的值等。不同的遍历方式，其访问节点的顺序是不一样的。遍历是二叉树上最重要的运算之一（NLR,LNR,LRN），是二叉树上进行其它运算之基础。当然遍历的概念也适合于多元素集合的情况，如数组等。 ...
数据结构 图的遍历
学习日常分享
06-15 820
1. 图的遍历 从图中的某个顶点出发，按某方法多图中的所有结点访问且访问一次。 2. 图的复杂性 顶点关系任意、多对多的关系、连通图与非连通图、孤立结点、回路。 3. 访问标识数组visited[n] 为每一个顶点设置一个一个访问标识visited[i] ，初值设为0表示未访问，一旦访问则设为1表示已访问。 4. 遍历方法：深度优先搜索、广度优先搜索深度优先搜索(DFS)：类似树的先根遍历 (1) 基本思想 选择一个顶点作为起始点，首先访问该顶点。 依次以该顶点的邻接点作为出发点，深度优先搜索邻接点。 对于
【数据结构】二叉树（遍历，递归）
最新发布
qinjh_的博客
01-18 1453
💬 hello!各位铁子们大家好哇。今日更新了树的遍历，递归的相关内容。
遍历二叉树（数据结构，递归）
yanyanwenmeng的博客
08-30 375
在二叉树的应用中，常常要求在树中查找具有某种特征的结点，或者对全部结点逐一进行某种处理。这就是二叉树的遍历问题。所谓二叉树的遍历是指按一定的规律和次序访问树中的各个结点，而且每个结点仅被访问一次。“访问”的含义很广，可以是对结点作各种处理，如输出结点的信息等。遍历一般按照从左到右的顺序，共有3种遍历方法，先（根）序遍历，中（根）序遍历，后（根）序遍历。 先序：根、左、右； 中序：左、根、右；
数据结构——二叉树递归遍历
zxf15735185131的博客
04-06 496
一 二叉树的定义树（tree）是包含n（n&gt;0）个结点的有穷集，其中：（1）每个元素称为结点（node）；（2）有一个特定的结点被称为根结点或树根（root）。（3）除根结点之外的其余数据元素被分为m（m≥0）个互不相交的集合T1，T2，……Tm-1，其中每一个集合Ti（1&lt;=i&lt;=m）本身也是一棵树，被称作原树的子树（subtree）。二叉树是另外一种数据结构，他的贴点是每个结...
数据结构-递归遍历二叉树
李棚的CSDN专栏
07-08 649
#include #include #define STACK_INIT_SIZE 30 #define STACKINCREMENT 10 #define OK 1 #define ERROR -1 typedef char TElemType; typedef struct BiTNode{ TElemType data; struct BiTNode *lchild, *r
数据结构——树、树的遍历
Art1st_D的博客
10-18 502
二叉树、二叉排序树、线索树、树的遍历实现 /* * 二叉树 */ typedef struct BiTNode{ ElemType data; struct BiTNode *lchild, *rchild; }BiTNode, *BiTree; // 递归先序遍历 void PreOrder(BiTree T) { if(T!=NULL) { visit(T); PreO...
数据结构：树、图的遍历
sinat_36138358的博客
10-17 1103
树的遍历 先根遍历：树非空，先访问根节点，在按照从左到右的顺序遍历根节点的每一颗子树。这个访问顺序与这棵树对应的二叉树的先序遍历顺序相同。 后根遍历：树非空，则按照从左到右的顺序遍历根节点的每一颗子树，之后在访问根节点。其访问顺序和这棵树对应的二叉树的中序遍历顺序相同。 二叉树：先序遍历，后序遍历，中序遍历       图的遍历   广度优先遍历：类似于树的层次遍历，从数组中
数据结构-图的遍历操作
10-20
在数据结构中如何对图进行遍历操作，如何利用图的遍历来解决问题
易语言二叉树遍历源码-易语言
06-13
二叉树在计算机科学中是一种数据结构，它由节点组成，每个节点有两个子节点：一个称为左子节点，另一个称为右子节点。易语言是一种中国本土开发的编程语言，其语法简洁，适合初学者和专业人士。本文将深入探讨易语言...
数据结构二叉树——递归遍历
极地星辰
05-04 430
 #include <iostream> #include <cstdlib> using namespace std; struct BinTreeNode{ int date; BinTreeNode *liftChild, *rightChild; } class BinaryTree{ public: BinaryTree(); BinaryTre...
各种数据结构的遍历框架
dujuancao11的博客
08-13 846
《labuladong 的算法⼩抄》学习笔记 数组遍历框架，典型的线性迭代结构： void traverse(int[] arr) { for (int i = 0; i < arr.length; i++) { // 迭代访问 arr[i] } } 链表遍历框架，兼具迭代和递归结构： /* 基本的单链表节点 */ class ListNode { int val; ListNode next; } void traverse(ListNode head) { for (Lis.
数据结构 - 图 - 遍历方式
Hello World
03-31 443
图的遍历方式 图的遍历就是从图中某个顶点出发游历图，访遍图中其余顶点，并且使图中的每个顶点仅被访问一次的过程。 通常我们使用两种遍历方式： 深度优先遍历和广度优先遍历。 深度优先遍历 深度优先遍历（DepthFirstSearch）也称为深度优先搜索，简称DFS。 深度优先遍历从某个顶点出发，访问此顶点，然后从v的未被访问的邻接点触发深度优先遍历图，直至所有和v有路径想通的顶点都被访问到。 这样...
6.5 数据结构——图的遍历
weixin_45523296的博客
11-08 160
图的遍历
评论 65
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值