【数据结构】二叉树

最新推荐文章于 2024-07-23 12:29:02 发布
最新推荐文章于 2024-07-23 12:29:02 发布
阅读量126 收藏
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构 算法 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Aimee_jaye/article/details/130447502
版权

二叉树的介绍

（摘自网络）

二叉树是一种由节点构成的树形数据结构，其中每个节点最多有两个子节点。其中一个被称为左子节点，另一个被称为右子节点。在二叉树中，每个节点可以有零个、一个或两个子节点。根据子节点的数量，可以将二叉树分类为满二叉树、完全二叉树和普通二叉树。二叉树通常用于搜索和排序算法，并且在编程中被广泛应用。
在这里插入图片描述

二叉树的构建是指将一些节点按照某种规则组织成一个二叉树的过程。二叉树遍历是指按照预先定义好的方式，对构建好的二叉树进行遍历访问每个节点的过程。
具体来说，二叉树遍历一般分为前序遍历、中序遍历和后序遍历三种方式。
其中前序遍历是指先访问根节点，然后再访问左子树和右子树；中序遍历是指先访问左子树，然后再访问根节点和右子树；后序遍历是指先访问左子树和右子树，最后再访问根节点。

代码实现

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

#define QUEUE_SIZE 5

/**
 * Binary tree node.
 */
typedef struct BTNode 
{
	char element;
	BTNode* left;
	BTNode* right;
}BTNode, * BTNodePtr;

/**
 * A queue with a number of pointers.
 */
typedef struct BTNodePtrQueue
 {
	BTNodePtr* nodePtrs;
	int front;
	int rear;
}BTNodePtrQueue, * QueuePtr;

/**
 * Initialize the queue.
 */
QueuePtr initQueue()
 {
	QueuePtr resultQueuePtr = (QueuePtr)malloc(sizeof(struct BTNodePtrQueue));
	resultQueuePtr->nodePtrs = (BTNodePtr*)malloc(QUEUE_SIZE * sizeof(BTNodePtr));
	resultQueuePtr->front = 0;
	resultQueuePtr->rear = 1;
	return resultQueuePtr;
}//Of initQueue

/**
 * Is the queue empty?
 */
bool isQueueEmpty(QueuePtr paraQueuePtr) {
	if ((paraQueuePtr->front + 1) % QUEUE_SIZE == paraQueuePtr->rear) {
		return true;
	}//Of if

	return false;
}//Of isQueueEmpty

/**
 * Add a pointer to the queue.
 */
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;
	}//Of if
	paraQueuePtr->nodePtrs[paraQueuePtr->rear] = paraBTNodePtr;
	paraQueuePtr->rear = (paraQueuePtr->rear + 1) % QUEUE_SIZE;
	printf("enqueue %c ends.\r\n", paraBTNodePtr->element);
}//Of enqueue

/**
 * Remove an element from the queue and return.
 */
BTNodePtr dequeue(QueuePtr paraQueuePtr) {
	if (isQueueEmpty(paraQueuePtr)) {
		printf("Error, empty queue\r\n");
		return NULL;
	}//Of if

	paraQueuePtr->front = (paraQueuePtr->front + 1) % QUEUE_SIZE;
	//BTNodePtr tempPtr = paraQueuePtr->nodePtrs[paraQueuePtr->front + 1];

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

/**
 * Construct a BTNode using the given char.
 */
BTNodePtr constructBTNode(char paraChar) {
	BTNodePtr resultPtr = (BTNodePtr)malloc(sizeof(BTNode));
	resultPtr->element = paraChar;
	resultPtr->left = NULL;
	resultPtr->right = NULL;
	return resultPtr;
}//Of constructBTNode

/**
 * Construct a binary tree using the given string.
 */
BTNodePtr stringToBTree(char* paraString) {
	int i;
	char ch;

	//Use a queue to manage the pointers
	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);

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


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

	return resultHeader;
}//Of stringToBTree

/**
 * Levelwise.
 */
void levelwise(BTNodePtr paraTreePtr) {
	//Use a queue to manage the pointers
	char tempString[100];
	int i = 0;
	QueuePtr tempQueuePtr = initQueue();
	BTNodePtr tempNodePtr;
	enqueue(tempQueuePtr, paraTreePtr);
	while (!isQueueEmpty(tempQueuePtr)) {
		tempNodePtr = dequeue(tempQueuePtr);

		//For output.
		tempString[i] = tempNodePtr->element;
		i++;

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

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

/**
 * Preorder.
 */
void preorder(BTNodePtr tempPtr) {
	if (tempPtr == NULL) {
		return;
	}//Of if

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

/**
 * Inorder.
 */
void inorder(BTNodePtr tempPtr) {
	if (tempPtr == NULL) {
		return;
	}//Of if

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

/**
 * Post order.
 */
void postorder(BTNodePtr tempPtr) {
	if (tempPtr == NULL) {
		return;
	}//Of if

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

/**
 * The entrance.
 */
int main() {
	BTNodePtr tempHeader;
	tempHeader = constructBTNode('c');
	printf("There is only one node. Preorder visit: ");
	preorder(tempHeader);
	printf("\r\n");

	char* tempString = "acde#bf######";

	tempHeader = stringToBTree(tempString);
	printf("Preorder: ");
	preorder(tempHeader);
	printf("\r\n");
	printf("Inorder: ");
	inorder(tempHeader);
	printf("\r\n");
	printf("Postorder: ");
	postorder(tempHeader);
	printf("\r\n");
	printf("Levelwise: ");
	levelwise(tempHeader);
	printf("\r\n");

	return 1;
}//Of main

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

代码分析

1. 定义二叉树节点和队
/**
 * Binary tree node.
 */
typedef struct BTNode {
	char element;
	BTNode* left;
	BTNode* right;
}BTNode, * BTNodePtr;

/**
 * A queue with a number of pointers.
 */
typedef struct BTNodePtrQueue {
	BTNodePtr* nodePtrs;
	int front;
	int rear;
}BTNodePtrQueue, * QueuePtr;

其中BTNode二叉树的节点，包了节点所存储的元素，以及左子节点和右子节点。
其中BTNodePtrQueue 的front 和rear 分别指向队列队头和队尾

2.初始化
QueuePtr initQueue()
 {
	QueuePtr resultQueuePtr = (QueuePtr)malloc(sizeof(struct BTNodePtrQueue));
	resultQueuePtr->nodePtrs = (BTNodePtr*)malloc(QUEUE_SIZE * sizeof(BTNodePtr));
	resultQueuePtr->front = 0;
	resultQueuePtr->rear = 1;
	return resultQueuePtr;
}//Of initQueue
  1. 首先使用 malloc() 函数动态分配了一个队列指针resultQueuePtr所指向的结构体的内存空间。然后，为 nodePtrs 数组动态分配了 QUEUE_SIZE 个 BTNodePtr 类型的内存空间。最后，将队首 front 设为 0，队尾 rear 设为 1，并返回该结构体指针。
  2. 能够保证队列的可拓展性，同时还避免了内存浪费的情况。
3. 判断队列是否为空
/**
 * Is the queue empty?
 */
bool isQueueEmpty(QueuePtr paraQueuePtr) {
	if ((paraQueuePtr->front + 1) % QUEUE_SIZE == paraQueuePtr->rear) {
		return true;
	}//Of if

	return false;
}//Of isQueueEmpty

检查队头的下一个位置是否等于队尾的位置

4. 添加
/**
 * Add a pointer to the queue.
 */
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;
	}//Of if
	paraQueuePtr->nodePtrs[paraQueuePtr->rear] = paraBTNodePtr;
	paraQueuePtr->rear = (paraQueuePtr->rear + 1) % QUEUE_SIZE;
	printf("enqueue %c ends.\r\n", paraBTNodePtr->element);
}//Of enqueue
  1. 添加指针到队列，通过传入一个队列指针和一个二叉树节点指针，将节点指针添加到队列中。
  2. 首先，函数会打印出当前队列的头和尾。然后，判断队列是否已满，如果已经满了则打印错误信息并返回；
  3. 如果队列没有满，则将节点指针添加到队列中，并更新队列尾的位置。
5. 移出
/**
 * Remove an element from the queue and return.
 */
BTNodePtr dequeue(QueuePtr paraQueuePtr) {
	if (isQueueEmpty(paraQueuePtr)) {
		printf("Error, empty queue\r\n");
		return NULL;
	}//Of if

	paraQueuePtr->front = (paraQueuePtr->front + 1) % QUEUE_SIZE;
	//BTNodePtr tempPtr = paraQueuePtr->nodePtrs[paraQueuePtr->front + 1];

	printf("dequeue %c ends.\r\n", paraQueuePtr->nodePtrs[paraQueuePtr->front]->element);
	return paraQueuePtr->nodePtrs[paraQueuePtr->front];
}//Of dequeue
  1. 若队列为空则输出错误信息并返回空指针。
  2. 对于非空队列，更新队首指针，并返回队首指向的元素。
6.构建二叉树结点
/**
 * Construct a BTNode using the given char.
 */
BTNodePtr constructBTNode(char paraChar) {
	BTNodePtr resultPtr = (BTNodePtr)malloc(sizeof(BTNode));
	resultPtr->element = paraChar;
	resultPtr->left = NULL;
	resultPtr->right = NULL;
	return resultPtr;
}//Of constructBTNode
  1. 首先通过malloc函数分配了一个BTNodePtr类型的空间并将其地址赋值给了resultPtr指针。然后将传入的paraChar赋值给了新建节点的element，左右子树指针均初始化为NULL。
  2. 最终返回resultPtr指针，即新建节点的地址。
7.将给定字符串转化为二叉树
/**
 * Construct a binary tree using the given string.
 */
BTNodePtr stringToBTree(char* paraString) {
	int i;
	char ch;

	//Use a queue to manage the pointers
	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);

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


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

	return resultHeader;
}//Of stringToBTree

首先初始化一个空的队列，然后按照前序遍历的方式逐个处理字符，如果该字符是“#”，则表示该节点没有子节点，否则构建一个新的节点，并将其插入到队列尾部，同时将该节点作为父节点的左子节点或右子节点。最后返回二叉树的头节点。

8. 遍历
levelwise、preorder、inorder、postorder

levelwise函数用于按层遍历二叉树，它使用了一个队列来管理节点指针。首先将根节点入队，然后进入循环。在循环中，取出队首的节点指针，将其值存入临时字符串中，并将其左右子节点入队，直到队列为空。最后输出存储在字符串中的值。

preorder函数用于先序遍历二叉树，它首先判断当前节点是否为空，如果为空则直接返回。否则先输出当前节点的值，然后递归调用左子节点和右子节点。

inorder函数用于中序遍历二叉树，它也首先判断当前节点是否为空，如果为空则直接返回。否则先递归调用左子节点，然后输出当前节点的值，最后递归调用右子节点。

postorder函数用于后序遍历二叉树，它也首先判断当前节点是否为空，如果为空则直接返回。否则先递归调用左子节点和右子节点，最后输出当前节点的值。

Aimee_jaye
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构——二叉树先序、中序、后序及层次四种遍历（C语言版）
正弦定理的博客
12-09 35万+
数据结构——二叉树先序、中序、后序三种遍历二叉树先序、中序、后序三种遍历三、代码展示： 二叉树先序、中序、后序三种遍历 先序遍历：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
数据结构二叉树题库
闲狗的博客
08-01 1万+
《数据结构二叉树之闲死攻略（一）》 目录 华文课后题 王道课后题 华文课后题 1、一棵有512个结点的完全二叉树的高度为多少？（独根树高度为1） 解析： 答案： 10 2、请写出下面这棵二叉树的中序遍历 解析： 左-根-右 left-root-right 答案： LXMECKPBQHDA 3、下列关于二叉树性质的说法正确的有： A、非空满二叉树的结点个数...
【数据结构】——二叉树详解
热门推荐
atwdy的博客
07-28 5万+
二叉树(Binary Tree)是由n个结点构成的有限集(n≥0)，n=0时为空树，n>0时为非空树。对于非空树TTT有且仅有一个根结点；除根结点外的其余结点又可分为两个不相交的子集TLT_LTL​和TRT_RTR​，分别称为TTT的左子树和右子树，且TLT_LTL​和TRT_RTR​本身又都是二叉树。很明显该定义属于递归定义，所以有关二叉树的操作使用递归往往更容易理解和实现。从定义也可以看出二叉树与一般树的区别主要是两点，一是每个结点的度最多为2；
数据结构之二叉树
qq_37080455的博客
06-27 5960
1、基本概念：树就是一种类似现实生活中的树的数据结构（倒置的树）。任何一颗非空树只有一个根节点。2、一棵树具有以下特点：3、树的形状如下图所示： 4、区别： 层数：从根节点开始算，为第一层。 高度：从最下面的叶子节点开始算，且从0开始计数。 深度：从根节点开始算，从0开始计数。树的基本名词解释：二叉树（Binary tree）是每个节点最多只有两个分支（即不存在分支度大于 2 的节点）的树结构。二叉树 的分支通常被称作“左子树”或“右子树”。并且，二叉树 的分支具有
数据结构二叉树实验报告
weixin_45590210的博客
11-22 4514
第一个实验是求一颗树的结点个数,叶子结点个数,某一个结点的深度,以及整颗树的宽度. 先来考虑一下如何读入一颗树.其实递归的读入左右子树即可. 参考代码: 树的结构体: struct Tree{ char data; Tree * lson,* rson; }; 读入部分 bool input(Tree *now){ // 这部分只是读入这颗树,不一定要这么写 cin >> now->data; if(now->data == '0') return
【数据结构】二叉树详解
waywt1的博客
11-14 3884
二叉树概念及结构 二叉树：树中节点的度不大于2的有序树，它是一种最简单且最重要的树。. 二叉树的递归定义为：二叉树是一棵空树，或者是一棵由一个根节点和两棵互不相交的，分别称作根的左子树和右子树组成的非空树；左子树和右子树又同样都是二叉树。 二叉树的性质 1. 若规定根节点的层数为1，则一棵非空二叉树的第 i 层上最多有 个结点 2. 若规定根节点的层数为1，则深度为 h 的二叉树的最大结点数是 3. 对任何一棵二叉树, 如果度为0其叶结点个数为 , 度为2的分支结点个数为 ,则有 =＋...
数据结构：二叉树的链式结构
Yikefore的博客
06-03 5592
链式二叉树创建非常详细的过程：包含如何前序遍历创建二叉树、对二叉树的前、中、后序遍历、二叉树节点个数、二叉树叶子节点个数、二叉树的高度、第k层节点个数、查找节点、层序遍历、判断二叉树是否为完全二叉树、二叉树的销毁.....附带完整代码以及图解
【数据结构】二叉树的遍历
有道无术, 术尚可求。有术无道, 止于术。
01-13 8964
本章将会详细讲解二叉树的遍历的四种方式，分别为前序遍历、中序遍历、后续遍历和层序遍历。在学习遍历之前，会先带大家回顾一下二叉树的基本概念。学习二叉树的基本操作前，需要先创建一颗二叉树，然后才能学习其相关的基本操作，考虑到我们刚刚接触二叉树，为了能够先易后难地进行讲解，我们将暂时手动创建一颗简单的二叉树，用来方便大家学习。等二叉树结构了解的差不多后，后期我们会带大家研究二叉树地真正的创建方式。
数据结构二叉树的相关代码（伪码）
桃子的博客
12-18 2250
数据结构考研代码伪码总结 二叉树的递归遍历 1.前序遍历 void PerOrder(BiTree T){ BiTree p=T; if(p){ visit(p);//访问节点并输出 PerOrder(p->lchild);//递归访问左子树 PerOrder(p->rchild);//递归访问右子树 } } 2.中序遍历 void InOrder(BiTree T){ BiTree p=T; if(p){ InOrder(p->lchild);//
数据结构二叉树功能展示
06-02
数据结构二叉树功能展示包括以完全前序序列创建二叉树"; cout以前序和中序序列创建二叉树"; cout前序遍历二叉树"; cout中序遍历二叉树"; cout后序遍历二叉树"; cout广度优先遍历二叉树"; cout求某结点的双亲";...
头歌数据结构二叉树的顺序存储及基本操作
05-18
在计算机科学中，二叉树是一种重要的数据结构，它的每个节点最多有两个子节点，分别称为左子树和右子树。这种特殊的树形结构在很多领域都有应用，特别是在文件系统和数据库系统中，利用二叉树可以实现高效的排序和...
数据结构 二叉树
03-20
数据结构中的二叉树是一种非常重要的非线性数据结构，其在计算机科学中扮演着核心角色，尤其是在数据存储和检索方面。本文将深入探讨二叉树的定义、特性、操作及其实现细节，旨在帮助读者全面理解二叉树及其在实际...
c++数据结构二叉树
01-06
数据结构课程设计 1. 创建二叉树的链表存储结构； 2． 实现二叉链表的初始化算法、二叉树空的判断算法； 3． 实现二叉树的先序遍历算法、中序遍历算法和后序遍历算法； 4． 利用某遍历算法实现计算二叉树中叶子结点...
数据结构二叉树家谱
12-17
数据结构二叉树家谱：文件操作功能，家谱操作功能
c语言（7.23）
最新发布
fhgfyrsg的博客
07-23 399
【代码】c语言（7.23）
数据结构---二叉树
weixin_47808575的博客
07-22 334
参考：二叉树遍历方法——前、中、后序遍历（图解）_二叉树遍历前序中序后序-CSDN博客
重生之“我打数据结构，真的假的？”--3.栈和队列
2301_80374809的博客
07-21 764
栈：一种特殊的线性表，其只允许在进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守LIFO（Last In First Out）的原则。
【数据结构-前缀和】力扣2550.统计范围内的元音字符串数
sjsjs11的博客
07-22 511
计算前缀和数组的时间是 O(n)，然后计算 q 个查询的答案，计算每个查询的答案的时间是 O(1)，因此时间复杂度是 O(n+q)。输入：words = [“aba”,“bcb”,“ece”,“aa”,“e”], queries = [[0,2],[1,4],[1,1]]输入：words = [“a”,“e”,“i”], queries = [[0,2],[0,1],[2,2]]查询 [1,4] 结果为 3（字符串 “ece”、“aa”、“e”）。返回结果 [2,3,0]。输出：[3,2,1]
数据结构二叉树详解
"数据结构二叉树优选ppt资料.ppt" 这份资料主要涵盖了数据结构中的核心概念——二叉树。二叉树是数据结构中的一个重要组成部分，它是一种特殊的树形结构，每个节点最多有两个子节点，通常称为左子节点和右子节点。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值