二叉树的遍历（节点个数及层序遍历）

最新推荐文章于 2024-05-20 19:43:04 发布

Cocobol0

最新推荐文章于 2024-05-20 19:43:04 发布

阅读量460

点赞数 16

分类专栏：数据结构文章标签： c语言 c++ 算法二叉树

本文链接：https://blog.csdn.net/weixin_73612682/article/details/130168904

版权

数据结构专栏收录该内容

16 篇文章 0 订阅

订阅专栏

简易树的图形：

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

//重定义数据类型
typedef char DataType;
//创建简易的二叉树结构体
typedef struct BTNode
{
	struct BTNode* left;
	struct BTNode* right;
	DataType data;
}BTNode;
//前序（根左右）
void Prev(BTNode* root)
{
	//判空
	if (root == NULL)
	{
		printf("NULL ");
		return;
	}
	printf("%c ", root->data);
	Prev(root->left);
	Prev(root->right);
}
//中序（左根右）
void Inmid(BTNode* root)
{
	//判空
	if (root == NULL)
	{
		printf("NULL ");
		return 0;
	}
	Inmid(root->left);
	printf("%c ", root->data);
	Inmid(root->right);
}
//后序（左右根）
void Pose(BTNode* root)
{
	//判空
	if (root == NULL)
	{
		printf("NULL ");
		return;
	}
	Pose(root->right);
	printf("%c ", root->data);
	Pose(root->left);
}
//返回节点个数
int TreeSize(BTNode* root)
{
	return root == NULL ? 0 : TreeSize(root->left) + TreeSize(root->right) + 1;
}
//初始化以及赋值树
int main()
{
	BTNode* A = (BTNode*)malloc(sizeof(BTNode));
	A->left = NULL;
	A->right = NULL;
	A->data = 'A';
	BTNode* B = (BTNode*)malloc(sizeof(BTNode));
	B->left = NULL;
	B->right = NULL;
	B->data = 'B';
	BTNode* C = (BTNode*)malloc(sizeof(BTNode));
	C->left = NULL;
	C->right = NULL;
	C->data = 'C';
	BTNode* D = (BTNode*)malloc(sizeof(BTNode));
	D->left = NULL;
	D->right = NULL;
	D->data = 'D';
	BTNode* E = (BTNode*)malloc(sizeof(BTNode));
	E->left = NULL;
	E->right = NULL;
	E->data = 'E';
	//赋值
	A->data = 'A';
	A->left = B;
	A->right = C;
	B->data = 'B';
	B->left = D;
	B->right = E;
	/*Prev(A);
	printf("\n");
	Inmid(A);
	printf("\n");*/
	printf("TreeSize:%d\n", TreeSize(A));
	printf("TreeSize:%d\n", TreeSize(B));
	return 0;
}

运行实例：

以A节点开始运算的节点个数

以B节点开始运算的节点个数

解释（图解+文字解释）：

把A传过去A不为空，进入left，A的left为B不为空，B的left为D不为空，D的left和right都为空返回0+0+1，在进入B的right，B的right为E不为空，E的left和right都为空返回0+0+1，B的left和right都返回1，运行完B，B再返回1+1+1=3，再进入A right->C,Cleft,right都为空返回1，最后A返回left（3）+right（1）+1=5.

求叶子节点个数：

//叶子节点的个数
int TreeLeafSize(BTNode* root)
{
	if (root = NULL)
		return 0;
	if (root->left == NULL && root->right == NULL)
		return 1;
	return TreeLeafSize(root->left) + TreeLeafSize(root->right);
}

传A过去，先判断A不为空，也不为叶子，则返回A的left+right，进入left为B，不为空和叶子，返回B的left和right，进入B left为D为叶子返回1，再进入B的right为E叶子返回1，则B返回2，在进入A的right C，C为叶子返回1，最终A返回3.

注意：（计算节点麻烦的用法）

1.定义全局变量来统计

因为要每次把size归零比较麻烦

2.传地址

传地址过去然后每次遇见一个节点++

层序遍历法：（符合队列的先进先出）

概念：及从第一行开始，一行一行的统计，每行从左到右，如我们最开始的例图层序遍历完后为ABCDE。

举例解释：

讲解：先代入A，A不为空，拿出A且代入A的子节BC，B不为空，拿出B再代入B的子节DE，C不为空拿出C再代入C的子节FG，D不为空拿出（D没有子节不用带入了），E不为空拿出，代入E的子节H，FGH都不为空且都没有子节了再依次拿出到空为止。

实现：

头文件：

#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <stdbool.h>
//前置声明（防止头文件Quene.h在2复制过去后往上找的时候找不到我们创建的树的结构体BTNode）
struct BTNode;

//重命名类型
typedef struct BTNode* QDataType;
//创建队列结构体
typedef struct QueueNode
{
	struct QueueNode* next;
	QDataType data;
}QNode;
//创建指针
typedef struct Queue
{
	QNode* head;
	QNode* tail;
}Queue;

//初始化
void QueueInit(Queue* pq);
//销毁
void QueueDestory(Queue* pq);
//队尾入队列
void QueuePush(Queue* pq,QDataType x);
//队头出队列
void QueuePop(Queue* pq);
//取数据队头
QDataType QueueFront(Queue* pq);
//取数据队尾
QDataType QueueBack(Queue* pq);
//数据的有效值
int QueueSize(Queue* pq);
//判空
bool QueueEmpty(Queue* pq);

队列文件：

#include "Queue.h"

//初始化
void QueueInit(Queue* pq)
{
	assert(pq);
	pq->head = pq->tail = NULL;
}
//销毁
void QueueDestory(Queue* pq)
{
	assert(pq);
	QNode* cur=pq->head;
	while (cur)
	{
		QNode* next = cur->next;//先保存下一个再释放自己，再让next赋值给cur
		free(cur);
		cur = next;
	}
	//结束后再把head和tail置空
	pq->head = pq->tail = NULL;
}
//队尾入队列
void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	else
	{
		newnode->data = x;
		newnode->next = NULL;
	}
	if (pq->tail==NULL)
	{
		pq->head = pq->tail = newnode;
	}
	else
	{
		pq->tail->next = newnode;
		pq->tail = newnode;
	}
}
//队头出队列
void QueuePop(Queue* pq)
{
	assert(pq);
	assert(pq->head);
	if (pq->head->next == NULL)//这里我们要判断一下head的next是否为空，如果为空说明只有一个节点了，我们直接释放，否则tail变成了野指针
	{
		free(pq->head);
		pq->head = pq->tail = NULL;
	}
	else
	{
		QNode* next = pq->head->next;
		free(pq->head);
		pq->head = next;
	}
}
//取数据队头
QDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(pq->head);//先判断头是否已经为空
	return pq->head->data;
}
//取数据队尾
QDataType QueueBack(Queue* pq)
{
	assert(pq);
	return pq->tail->data;
}
//数据的有效值
int QueueSize(Queue* pq)
{
	assert(pq);
	int size = 0;
	QNode* cur = pq->head;
	while (cur)//我们直接遍历一遍知道cur为空的时候停止
	{
		size++;
		cur = cur->next;
	}
	return size;
}
//判空
bool QueueEmpty(Queue* pq)
{
	assert(pq);
	return pq->head == NULL;//判断如果为空则返回真，否则为假
}

树文件

#include <stdio.h>
#include  <stdlib.h>
#include "Queue.h"
//重定义数据类型
typedef char DataType;
//创建简易的二叉树结构体
typedef struct BTNode
{
	struct BTNode* left;
	struct BTNode* right;
	DataType data;
}BTNode;
//前序（根左右）
void Prev(BTNode* root)
{
	//判空
	if (root == NULL)
	{
		printf("NULL ");
		return;
	}
	printf("%c ", root->data);
	Prev(root->left);
	Prev(root->right);
}
//中序（左根右）
void Inmid(BTNode* root)
{
	//判空
	if (root == NULL)
	{
		printf("NULL ");
		return 0;
	}
	Inmid(root->left);
	printf("%c ", root->data);
	Inmid(root->right);
}
//后序（左右根）
void Pose(BTNode* root)
{
	//判空
	if (root == NULL)
	{
		printf("NULL ");
		return;
	}
	Pose(root->right);
	printf("%c ", root->data);
	Pose(root->left);
}
//返回节点个数
int TreeSize(BTNode* root)
{
	return root == NULL ? 0 : TreeSize(root->left) + TreeSize(root->right) + 1;
}
//叶子节点的个数
int TreeLeafSize(BTNode* root)
{
	if (root = NULL)
		return 0;
	if (root->left == NULL && root->right == NULL)
		return 1;
	return TreeLeafSize(root->left) + TreeLeafSize(root->right);
}
//层序遍历
void LevelOrder(BTNode* root)
{
	Queue q;
	QueueInit(&q);
	if (root)//如果队列为空则入值
		QueuePush(&q, root);
	while (!QueueEmpty(&q))
	{
		BTNode* front = QueueFront(&q); 
		QueuePop(&q);//取出来
		printf("%c ", front->data);
		if (front->left)
		{
			QueuePush(&q, front->left);
		}if (front->right)
		{
			QueuePush(&q, front->right);
		}
	}
	printf("\n");
	QueueDestory(&q);
}
//初始化以及赋值树
int main()
{
	BTNode* A = (BTNode*)malloc(sizeof(BTNode));
	A->left = NULL;
	A->right = NULL;
	A->data = 'A';
	BTNode* B = (BTNode*)malloc(sizeof(BTNode));
	B->left = NULL;
	B->right = NULL;
	B->data = 'B';
	BTNode* C = (BTNode*)malloc(sizeof(BTNode));
	C->left = NULL;
	C->right = NULL;
	C->data = 'C';
	BTNode* D = (BTNode*)malloc(sizeof(BTNode));
	D->left = NULL;
	D->right = NULL;
	D->data = 'D';
	BTNode* E = (BTNode*)malloc(sizeof(BTNode));
	E->left = NULL;
	E->right = NULL;
	E->data = 'E';
	//赋值
	A->data = 'A';
	A->left = B;
	A->right = C;
	B->data = 'B';
	B->left = D;
	B->right = E;
	/*Prev(A);
	printf("\n");
	Inmid(A);
	printf("\n");*/
	printf("TreeSize:%d\n", TreeSize(A));
	printf("TreeSize:%d\n", TreeSize(B));
	LevelOrder(A);
	return 0;
}