数据结构-二叉树的构建与遍历

已于 2022-05-24 19:09:40 修改
阅读量1.3k 收藏 18
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构 c语言
于 2022-05-24 19:05:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/usiehheu/article/details/124949820
版权

文章目录

提示：以下是本篇文章正文内容，下面案例可供参考

一、二叉树的定义

图例：
在这里插入图片描述
二叉树是每个结点最多有两个子树的树结构，常被用于实现二叉查找树和二叉堆。二叉树是链式存储结构，用的是二叉链，本质上是链表。结构体定义二叉树节点：

typedef struct BTNode
{
	char element;
	struct BTNode* left;
	struct BTNode* right;
}BTNode,*BTNodePtr;

二、二叉树的建立

BTNodePtr constructBTNode(char paraChar)
{
	BTNodePtr resultPtr = (BTNodePtr)malloc(sizeof(struct BTNode));
	resultPtr->element = paraChar;
	resultPtr->left = NULL;
	resultPtr->right = NULL;
	return resultPtr;
}

三、二叉树的遍历

1.先序遍历

先序遍历的过程是首先访问根结点，然后先序遍历根的左子树，最后先序遍历根的右子树。对于根的左子树和右子树，遍历的过程相同。
代码如下（示例）：

void preorder(BTNodePtr tempPtr)//先序遍历 
{
	if (tempPtr == NULL)
	{
		return;
	}

	printf("%c", tempPtr->element);
	preorder(tempPtr->left);
	preorder(tempPtr->right);
}

2.中序遍历

中序遍历的过程是首先中序遍历左子树，然后访问根结点，最后中序遍历根的右子树。对于根的左子树和右子树，遍历的过程相同。
代码如下（示例）：

void inorder(BTNodePtr tempPtr)//中序遍历 
{
	if (tempPtr == NULL) 
	{
		return;
	}

	inorder(tempPtr->left);
	printf("%c", tempPtr->element);
	inorder(tempPtr->right);
}

3.后序遍历

后序遍历的过程是首先后序遍历左子树，然后后序遍历根的右子树，最后访问根结点。

void postorder(BTNodePtr tempPtr)//后序遍历 
{
	if (tempPtr == NULL) 
	{
		return;
	}

	postorder(tempPtr->left);
	postorder(tempPtr->right);
	printf("%c", tempPtr->element);
}

4.层序遍历

在进行层次遍历时，对一层结点访问完后再按照它们的访问次序对各个结点的左孩子和右孩子顺序访问，这样一层一层地进行，先遇到的结点先访问，先上到下，先左到右。实现层次遍历用队列比较方便，因为是先进先出（FIFO）。首先把队首元素入队，然后再输出队首元素，并且把队首元素的左结点和右结点入队（如果有的话），以此类推，输出的序列就是层次遍历。

void levelwise(BTNodePtr paraTreePtr)
{
	char tempString[100];
	int i = 0;
	QueuePtr tempQueuePtr = initQueue();
	BTNodePtr tempNodePtr;
	enqueue(tempQueuePtr, paraTreePtr);
	while(!isQueueEmpty(tempQueuePtr)) 
	{
		tempNodePtr = dequeue(tempQueuePtr);
		
		tempString[i] = tempNodePtr->element;
		i ++;

		if (tempNodePtr->left != NULL)
		{
			enqueue(tempQueuePtr, tempNodePtr->left);
		}
		if (tempNodePtr->right != NULL)
		{
			enqueue(tempQueuePtr, tempNodePtr->right);
		}
	}
	tempString[i] = '\0';

	printf("Levelwise: %s\r\n", tempString);
}

四、二叉树的叶、节点、深度

1、求叶子数目

int LeafCount(BTNodePtr tempPtr)
{
	if(tempPtr == NULL)
	{
		return 0;
	}
	else if(tempPtr->left == NULL && tempPtr->right == NULL)
	{
		return 1;
	}
	else
	{
		return LeafCount(tempPtr->left)+LeafCount(tempPtr->right);
	}
}

2、求节点数目

int Nodecount(BTNodePtr tempPtr) 
{
	if(tempPtr == NULL)
	{
		return 0;
	}
	else
	{
		return Nodecount(tempPtr->left)+Nodecount(tempPtr->right)+1;
	}
}

3、求二叉树深度

int Depth(BTNodePtr tempPtr)
{
	int m,n;
	if(tempPtr == NULL)
	{
		return 0;
	}
	else
	{
		m=Depth(tempPtr->left);
		n=Depth(tempPtr->right);
		if(m>n)
		{
			return m+1;
		}
		else
		{
			return n+1;
		}
	}
}

五、辅助函数

typedef struct BTNodePtrQueue
{
	BTNodePtr* nodePtr;
	int front;
	int rear;
}BTNodePtrQueue,*QueuePtr;//队列结构体

QueuePtr initQueue()
{
	QueuePtr resultQueuePtr = (QueuePtr)malloc(sizeof(struct BTNodePtrQueue));
	resultQueuePtr->front = 0;
	resultQueuePtr->rear = 1;
	resultQueuePtr->nodePtr = (BTNodePtr*)malloc(sizeof(struct BTNode)*QUEUE_SIZE);
	return resultQueuePtr;
}//初始化队列

BTNodePtr stringToBTree(char* paraString)
{
	int i;
	char ch;

	QueuePtr tempQueuePtr = initQueue();

	BTNodePtr resultHeader;
	BTNodePtr tempParent, tempLeftChild, tempRightChild;
	i = 0;
	ch = paraString[i];
	resultHeader = constructBTNode(ch);
	enqueue(tempQueuePtr, resultHeader);

	while(!isQueueEmpty(tempQueuePtr)) 
	{
		tempParent = dequeue(tempQueuePtr);

		i ++;
		ch = paraString[i];
		if (ch == '#')
		{
			tempParent->left = NULL;
		} 
		else 
		{
			tempLeftChild = constructBTNode(ch);
			enqueue(tempQueuePtr, tempLeftChild);
			tempParent->left = tempLeftChild;
		}

		i ++;
		ch = paraString[i];
		if (ch == '#') 
		{
			tempParent->right = NULL;
		} 
		else 
		{
			tempRightChild = constructBTNode(ch);
			enqueue(tempQueuePtr, tempRightChild);
			tempParent->right = tempRightChild;
		}
	}

	return resultHeader;
}//二叉树赋值

void enqueue(QueuePtr paraQueueptr,BTNodePtr paraBTNodePtr)
{
	printf("front=%d ,rear=%d.\r\n",paraQueueptr->front,paraQueueptr->rear);
	if((paraQueueptr->rear + 1) % QUEUE_SIZE == paraQueueptr->front % QUEUE_SIZE)
	{
		printf("Error, trying to enqueue %c. queue full.\r\n", paraBTNodePtr->element);
		return;
	}
	paraQueueptr->nodePtr[paraQueueptr->rear] = paraBTNodePtr;
	paraQueueptr->rear = (paraQueueptr->rear + 1) % QUEUE_SIZE;
	printf("enqueue %c ends.\r\n", paraBTNodePtr->element);
}//进队

BTNodePtr dequeue(QueuePtr paraQueuePtr)
{
	if (isQueueEmpty(paraQueuePtr)) 
	{
		printf("Error, empty queue\r\n");
		return NULL;
	}

	paraQueuePtr->front = (paraQueuePtr->front + 1) % QUEUE_SIZE;

	printf("dequeue %c ends.\r\n", paraQueuePtr->nodePtr[paraQueuePtr->front]->element);
	return paraQueuePtr->nodePtr[paraQueuePtr->front];
}//出队

bool isQueueEmpty(QueuePtr paraQueueptr)
{
	if((paraQueueptr->front + 1) % QUEUE_SIZE == paraQueueptr->rear) 
	{
		return true;
	}
	return false;
}//队列判空

六、完整代码

#include<stdio.h>
#include<malloc.h>
#include<stdbool.h>

#define QUEUE_SIZE 5

typedef struct BTNode
{
	char element;
	struct BTNode* left;
	struct BTNode* right;
}BTNode,*BTNodePtr;

typedef struct BTNodePtrQueue
{
	BTNodePtr* nodePtr;
	int front;
	int rear;
}BTNodePtrQueue,*QueuePtr;

QueuePtr initQueue()
{
	QueuePtr resultQueuePtr = (QueuePtr)malloc(sizeof(struct BTNodePtrQueue));
	resultQueuePtr->front = 0;
	resultQueuePtr->rear = 1;
	resultQueuePtr->nodePtr = (BTNodePtr*)malloc(sizeof(struct BTNode)*QUEUE_SIZE);
	return resultQueuePtr;
}

bool isQueueEmpty(QueuePtr paraQueueptr)
{
	if((paraQueueptr->front + 1) % QUEUE_SIZE == paraQueueptr->rear) 
	{
		return true;
	}
	return false;
}

void enqueue(QueuePtr paraQueueptr,BTNodePtr paraBTNodePtr)
{
	printf("front=%d ,rear=%d.\r\n",paraQueueptr->front,paraQueueptr->rear);
	if((paraQueueptr->rear + 1) % QUEUE_SIZE == paraQueueptr->front % QUEUE_SIZE)
	{
		printf("Error, trying to enqueue %c. queue full.\r\n", paraBTNodePtr->element);
		return;
	}
	paraQueueptr->nodePtr[paraQueueptr->rear] = paraBTNodePtr;
	paraQueueptr->rear = (paraQueueptr->rear + 1) % QUEUE_SIZE;
	printf("enqueue %c ends.\r\n", paraBTNodePtr->element);
}

BTNodePtr dequeue(QueuePtr paraQueuePtr)
{
	if (isQueueEmpty(paraQueuePtr)) 
	{
		printf("Error, empty queue\r\n");
		return NULL;
	}

	paraQueuePtr->front = (paraQueuePtr->front + 1) % QUEUE_SIZE;

	printf("dequeue %c ends.\r\n", paraQueuePtr->nodePtr[paraQueuePtr->front]->element);
	return paraQueuePtr->nodePtr[paraQueuePtr->front];
}

BTNodePtr constructBTNode(char paraChar)
{
	BTNodePtr resultPtr = (BTNodePtr)malloc(sizeof(struct BTNode));
	resultPtr->element = paraChar;
	resultPtr->left = NULL;
	resultPtr->right = NULL;
	return resultPtr;
}

BTNodePtr stringToBTree(char* paraString)
{
	int i;
	char ch;

	QueuePtr tempQueuePtr = initQueue();

	BTNodePtr resultHeader;
	BTNodePtr tempParent, tempLeftChild, tempRightChild;
	i = 0;
	ch = paraString[i];
	resultHeader = constructBTNode(ch);
	enqueue(tempQueuePtr, resultHeader);

	while(!isQueueEmpty(tempQueuePtr)) 
	{
		tempParent = dequeue(tempQueuePtr);

		i ++;
		ch = paraString[i];
		if (ch == '#')
		{
			tempParent->left = NULL;
		} 
		else 
		{
			tempLeftChild = constructBTNode(ch);
			enqueue(tempQueuePtr, tempLeftChild);
			tempParent->left = tempLeftChild;
		}

		i ++;
		ch = paraString[i];
		if (ch == '#') 
		{
			tempParent->right = NULL;
		} 
		else 
		{
			tempRightChild = constructBTNode(ch);
			enqueue(tempQueuePtr, tempRightChild);
			tempParent->right = tempRightChild;
		}
	}

	return resultHeader;
}

void levelwise(BTNodePtr paraTreePtr)
{
	char tempString[100];
	int i = 0;
	QueuePtr tempQueuePtr = initQueue();
	BTNodePtr tempNodePtr;
	enqueue(tempQueuePtr, paraTreePtr);
	while(!isQueueEmpty(tempQueuePtr)) 
	{
		tempNodePtr = dequeue(tempQueuePtr);
		
		tempString[i] = tempNodePtr->element;
		i ++;

		if (tempNodePtr->left != NULL)
		{
			enqueue(tempQueuePtr, tempNodePtr->left);
		}
		if (tempNodePtr->right != NULL)
		{
			enqueue(tempQueuePtr, tempNodePtr->right);
		}
	}
	tempString[i] = '\0';

	printf("Levelwise: %s\r\n", tempString);
}

void preorder(BTNodePtr tempPtr)//先序遍历 
{
	if (tempPtr == NULL)
	{
		return;
	}

	printf("%c", tempPtr->element);
	preorder(tempPtr->left);
	preorder(tempPtr->right);
}

void inorder(BTNodePtr tempPtr)//中序遍历 
{
	if (tempPtr == NULL) 
	{
		return;
	}

	inorder(tempPtr->left);
	printf("%c", tempPtr->element);
	inorder(tempPtr->right);
}

void postorder(BTNodePtr tempPtr)//后序遍历 
{
	if (tempPtr == NULL) 
	{
		return;
	}

	postorder(tempPtr->left);
	postorder(tempPtr->right);
	printf("%c", tempPtr->element);
}

int LeafCount(BTNodePtr tempPtr)
{
	if(tempPtr == NULL)
	{
		return 0;
	}
	else if(tempPtr->left == NULL && tempPtr->right == NULL)
	{
		return 1;
	}
	else
	{
		return LeafCount(tempPtr->left)+LeafCount(tempPtr->right);
	}
}

int Depth(BTNodePtr tempPtr)
{
	int m,n;
	if(tempPtr == NULL)
	{
		return 0;
	}
	else
	{
		m=Depth(tempPtr->left);
		n=Depth(tempPtr->right);
		if(m>n)
		{
			return m+1;
		}
		else
		{
			return n+1;
		}
	}
}

int Nodecount(BTNodePtr tempPtr) 
{
	if(tempPtr == NULL)
	{
		return 0;
	}
	else
	{
		return Nodecount(tempPtr->left)+Nodecount(tempPtr->right)+1;
	}
}


int main()
{
	BTNodePtr tempHeader;
	tempHeader = constructBTNode('c');
	printf("There is only one node. Preorder visit: ");
	preorder(tempHeader);
	printf("\r\n\n");
	
	char* tempString = "acde#bf######";
	tempHeader = stringToBTree(tempString);
	printf("先序: ");
	preorder(tempHeader);//先序：中左右 
	
	printf("\r\n\n");
	printf("中序: ");  
	inorder(tempHeader);//中序：左中右 
	
	printf("\r\n\n");
	printf("后序: ");
	postorder(tempHeader);//后序：左右中 
	
	printf("\r\n\n");
	printf("Lvelwise: ");  
	levelwise(tempHeader);//层序 
	
	printf("\r\n\n");
	int k;
	k = LeafCount(tempHeader);
	printf("树的叶子有：%d",k);
	
	printf("\r\n\n");
	int l;
	l = Depth(tempHeader);
	printf("树的深度：%d",l);
	
	printf("\r\n\n");
	int n;
	n = Nodecount(tempHeader);
	printf("树的节点数：%d",n);
	return 0;
}

运行结果：

There is only one node. Preorder visit: c

front=0 ,rear=1.
enqueue a ends.
dequeue a ends.
front=1 ,rear=2.
enqueue c ends.
front=1 ,rear=3.
enqueue d ends.
dequeue c ends.
front=2 ,rear=4.
enqueue e ends.
dequeue d ends.
front=3 ,rear=0.
enqueue b ends.
front=3 ,rear=1.
enqueue f ends.
dequeue e ends.
dequeue b ends.
dequeue f ends.
先序: acedbf

中序: ecabdf

后序: ecbfda

Lvelwise: front=0 ,rear=1.
enqueue a ends.
dequeue a ends.
front=1 ,rear=2.
enqueue c ends.
front=1 ,rear=3.
enqueue d ends.
dequeue c ends.
front=2 ,rear=4.
enqueue e ends.
dequeue d ends.
front=3 ,rear=0.
enqueue b ends.
front=3 ,rear=1.
enqueue f ends.
dequeue e ends.
dequeue b ends.
dequeue f ends.
Levelwise: acdebf


树的叶子有：3

树的深度：3

树的节点数：6
卖菜不涨价
关注
专栏目录
6.1: 二叉树的构建与遍历
qq_70137750的博客
05-24 931
引言 树是一种比较重要的数据结构，尤其是二叉树。在这里简单介绍二叉树。 二叉树是一种特殊的树，在二叉树中每个节点最多有两个子节点，一般称为左子节点和右子节点（或左孩子和右孩子），并且二叉树的子树有左右之分，其次序不能任意颠倒。 1. 二叉树的定义 二叉树是n(n>=0)个结点的有限集合，该集合或者为空集（称为空二叉树），或者由一个根结点和两棵互不相交的、分别称为根结点的左子树和右子树组成。 2. 二叉树的遍历 二叉树的存储分为顺序存储和链式存储。顺序存储在右斜树这种极端情况下，会十分浪费.
DS二叉树--二叉树构建与遍历（含代码框架）
m0_74040903的博客
10-23 611
数据结构二叉树
二叉树的构建与遍历
Sunny_Shu123的博客
09-27 286
根据数组创建二叉树，并对二叉树进行先序、中序和后序遍历。          代码实现： import java.util.LinkedList; import java.util.List; public class BinaryTree { private static List nodeList=null; /** * MethodName:main * De
二叉树的构建和遍历
正在挣扎中的人
04-03 931
二叉树的构建和多种遍历详解
数据结构--二叉树的构建与遍历
xiyandr的博客
05-24 199
二叉树的层次构建与先中后序遍历： 代码： #include <stdio.h> #include <stdlib.h> #include <malloc.h> #include <string.h> #include <math.h> #define OVERFLOW 1 #define MAX_SIZE 10 typedef struct Btnode_ { int elem; Btnode_ *left; Btnode_ *righ
算法与数据结构-二叉树的建立与遍历.pdf
10-28
二叉树是一种重要的数据结构，它由节点组成，每个节点包含一个值以及指向左右子节点的指针。在本文中，我们将深入探讨如何建立和遍历二叉树，特别是通过递归方法。实验目的是理解二叉树的节点结构，学会对其进行基本...
算法与数据结构-二叉树的建立与遍历.docx
10-28
总之，二叉树作为一种基本的数据结构，其建立和遍历是算法学习的重要部分。熟练掌握这些技能有助于解决各种实际问题，如搜索、排序、表达式解析等。在学习过程中，理解每一步操作的原因和逻辑是至关重要的，这样才能...
数据结构--清华严蔚敏版 --二叉树的遍历--案例实现
05-22
理解并掌握二叉树的遍历对于学习数据结构和算法至关重要，因为它是许多高级概念的基础，如树的搜索、复制和压缩存储等。在实际应用中，二叉树遍历也常用于解析XML文档、编译器符号表管理以及数据库索引等场景。因此...
二叉树的建立与遍历
10-15
按先序序列构造一棵二叉链表表示的二叉树T，并输出该T的中序遍历序列。实现提示： 1) 按先序序列建立一棵二叉树时，先构造根结点，再构造根的左子树，然后构造右子树；每棵子树又都是二叉树，所以构造一棵子树的过程与构造整棵二叉树的过程完全相同（采用递归形式直到叶子结点为止）。 2) 先序序列的输入：从键盘输入任意一棵二叉树的先序序列，用#代表空指针，如下图所示的二叉树，输入的先序序列为：ab#d##c##）。
数据结构二叉树的建立与遍历（两种中序）
12-18
包含了二叉树的建立与遍历，遍历包含前序，中序（两种），后序遍历，以及二叉树的深度计算。程序健壮性较强。
数据结构-二叉树的建立与遍历 (2).pdf
11-23
《数据结构-二叉树的建立与遍历》实验报告主要涵盖了如何使用链式存储结构构建二叉树以及非递归方式实现二叉树的先序遍历。实验旨在通过Visual C++6.0上机调试，提升对二叉树理论的理解及实际操作能力。 在实验需求...
二叉树的构建以及遍历
cang_ling的博客
01-02 406
二叉树的构建和遍历 package com.qcby.tree; public class TreeNode { public TreeNode leftChild; public TreeNode rightChild; public Integer value; public TreeNode(Integer value) { this.value = value; } } 然后需要一个测试类 package com...
DS二叉树--二叉树构建与遍历
weixin_33832340的博客
01-03 267
题目描述 给定一颗二叉树的逻辑结构如下图，（先序遍历的结果，空树用字符‘0’表示，例如AB0C00D00），建立该二叉树的二叉链式存储结构，并输出该二叉树的先序遍历、中序遍历和后序遍历结果 输入 第一行输入一个整数t，表示有t个二叉树 第二行起输入每个二叉树的先序遍历结果，空树用字符‘0’表示，连续输入t行 输出 输出每个二叉树的先序遍历、中序遍历和后序遍历结果 ...
【数据结构】二叉树的创建和遍历
ZXC
06-11 206
struct biTreeNode { char data; biTreeNode *lchild; biTreeNode *rchild; }; typedef biTreeNode* biNodePtr; struct biTree { biTreeNode *head; };结构定义，定义了树节点的结构体，以及树的结构体。void init_biTree(biTree *mytr...
二叉树的创建与遍历
qingtianweichong的专栏
05-03 7305
二叉树的创建与遍历是比较基本的问题，也是比较难的问题，在c语言中需要对指针和链表的操作比较熟悉，还要对递归有比较好的理解，下面用代码展示，在代码中有比较详细的注释。下面就贴出代码：            /* 关于非线性的数据结构当然树形结构最重要，而树里面又属二叉树最重要， 所以在后面将列出二叉树的各种使用方法，包括基本的遍历，和我在一些 资料上看到的关于二叉树的面试题型。至于一些很
二叉树的建立和遍历
最新发布
m0_56246173的博客
11-22 3233
在二叉树的存储中，我们发现在创建二叉树函数的时候，，它的参数是char* &str,此处的&是c++中的引用，什么是引用呢？ 格式为：类型 &引用变量名 = 已定义过的变量名。 例如：,此处的引用b便是a的重命名，怎么理解呢，其实a,b指的是同一个变量，a,b只是他不同的名字。 此处为什么用引用呢，如果去掉引用会发生什么呢？ 在数组元素等于ABC##DE##F##G#H## 的时候，输出值会发生错误，发现只在abc之间，不会遍历到后面的元素。怎么样的思路呢，我们递归调用函数时，比如A结点接下来进入左孩子调用
二叉树的创建和遍历
小白太白的博客
03-18 359
给定一个确定的数组，然后构建一棵二叉树，并分别使用递归和非递归的方式进行遍历。 import java.util.LinkedList; import java.util.List; import java.util.Stack; /** * 建树思路： * 首先把所有的数创建为节点依次存入有序集合中 * 对于数列中的前 n/2-1 个都为父节点，因此遍历父节点构建树 * 每一个父节...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值