【数据结构】二叉树的概念及实现

最新推荐文章于 2024-09-14 22:08:51 发布
最新推荐文章于 2024-09-14 22:08:51 发布
阅读量163 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42263122/article/details/104344125
版权

二叉树的定义：

二叉树T一个有穷的节点集合，这个集合可以为空，若不为空，则它由根节点和一个称为左子树TL 和 右子树TR的两个完全不相交的二叉树组成。

二叉树的顺序存储分析：

完全二叉树：
若设二叉树的深度为h，除第h层外，其他各层（1~h-1）的节点数都达到最大个数，第h层所有节点都连续集中在最左边，这就是完全二叉树
满二叉树：
除最后一层无任何子节点外，每一层上的所有结点都有两个子结点。满二叉树一定是完全二叉树，不同的是最后一层的所有节点都有两个字节点。
对于一个完全二叉树如何用顺序存储实现呢？
我们可以对完全二叉树进行从上到下，从左到右编号，然后以编号为下标将节点的值依次放入一个数组中，这时候下标之间的规律们可以反映二叉树的层次关系（比如根据双亲节点的下标，找到其左孩子和右孩子的下标）：
在这里插入图片描述
在这里插入图片描述
N个节点的完全二叉树的节点父子关系：
（1）非根节点，序号（i >1)父节点的序号为i/2；
（2）节点的序号为i，左孩子的序号为2 * i；
（3）节点的序号为i，右孩子的序号为2 * i + 1；
而对于非完全二叉树也可以用顺序存储的方法实现，空出来的节点序号为0；但是这样会浪费大量的存储空间；

二叉树的链式存储及实现：

#define Elemtype char 
#define Btree_Node STDataType
typedef struct Btree_Node{//二叉树节点的结构
	Elemtype data;
	Btree_Node* L_child;
	Btree_Node* R_child;
}Btree_Node;
typedef struct StackNode{//栈节点的结构
	STDataType* value; 
    struct StackNode *next;
}StackNode;
typedef struct QueueNode{//队列节点的结构
	STDataType* value;
	struct QueueNode* next;
}QueueNode;
typedef struct Queue{//队列的结构
	QueueNode* front;//队头
	QueueNode* rear;//队尾
}Queue;
//*******************栈的基本操作********************//
StackNode* StackInit();
void StackPush(StackNode**,STDataType*);
void StackPop(StackNode**);
STDataType* StackTop(StackNode* stack);
bool is_StackEmpty(StackNode* stack);
//*******************队列的基本操作****************//
Queue* QueueInit();// 创建队列
void QueuePush(Queue* q, STDataType* data);// 队尾入队列
void QueuePop(Queue* q);// 队头出队列
STDataType* QueueFront(Queue* q);// 获取队列头部元素
STDataType* Queuerear(Queue* q);// 获取队列队尾元素
bool is_QueueEmpty(Queue* q);// 检测队列是否为空
void QueueDestroy(Queue* q);// 销毁队列
//*******************二叉树的基本操作****************//
//创建一个完全二叉树
Btree_Node* Creat_BinTree();
//判断二叉树是否为空
bool is_empty_BinTree(Btree_Node*);
//生成一个节点
Btree_Node* Buy_New_Node(Elemtype data);
//销毁整个二叉树
void Free_tree(Btree_Node*);
//增加数据项到二叉树，即插入新的子树
void Insert_ChildTree(Btree_Node* ,Btree_Node* ,int n);
//n=1删除左子树，n=2删除右子树
void Delete_ChildTree(Btree_Node* ,int n);
//先序遍历的递归实现
void Pre_Order_BinTree(Btree_Node* ptr);
 //中序遍历的递归实现
void Mid_Order_BinTree(Btree_Node* ptr);
 //后序遍历的递归实现
void Post_Order_BinTree(Btree_Node* ptr);

//先序遍历的非递归实现
void NPre_Order_BinTree(Btree_Node* ptr);
 //中序遍历的非递归实现
void NMid_Order_BinTree(Btree_Node* ptr);
 //后序遍历的非递归实现
void NPost_Order_BinTree(Btree_Node* ptr);

/*******************层序遍历实现********/
void Level_Order_BinTree(Btree_Node* Ptr);


//*******************栈的基本操作********************//
StackNode* StackInit(){//栈的初始化
	StackNode* stack = NULL;
	return stack;
}
void StackPush(StackNode** stack,STDataType* data){
	assert(stack);
	StackNode* ptr = (StackNode*)malloc(sizeof(StackNode));
	ptr ->value = data; 
	ptr ->next = *stack;
	*stack = ptr;
}
void StackPop(StackNode** stack){
	if(is_StackEmpty(*stack)){
		printf("栈空\n");
	}else{
		StackNode* ptr = (*stack);
		(*stack) = ptr ->next;
		free(ptr);
	}
}
STDataType* StackTop(StackNode* stack){
	assert(!is_StackEmpty(stack));
	return stack ->value;
}
bool is_StackEmpty(StackNode* stack){
	if(stack == NULL){
		return true;
	}else{
		return false;
	}
}
//*******************队列的基本操作****************//
Queue* QueueInit(){// 创建队列
	Queue* q = (Queue*)malloc(sizeof(Queue));
	q ->front = q ->rear =NULL;
	return q;
}
void QueuePush(Queue* q, STDataType* value){// 队尾入队列
	assert(q);//队列不存在
	QueueNode* ptr = (QueueNode*)malloc(sizeof(QueueNode));
	ptr ->value = value;
	ptr ->next = NULL;
	if(is_QueueEmpty(q)){//队列为空
		q ->front = q ->rear = ptr;
	}else{
		q ->rear ->next = ptr;
		q ->rear = ptr;
	}
}
void QueuePop(Queue* q){// 队头出队列
	if(is_QueueEmpty(q)){
		printf("队列空");
	}else{
		QueueNode* ptr = q ->front;
		q ->front =q ->front ->next;
		if(q ->front == NULL){
			q ->rear = q ->front;
		}
		free(ptr);
	}

}
STDataType* QueueFront(Queue* q){// 获取队列头部元素
	assert(q);
	if(is_QueueEmpty(q)){
		printf("队列空\n");
	}else{
		return q ->front ->value;
	}
}
STDataType* Queuerear(Queue* q){// 获取队列队尾元素
	assert(q);
	if(is_QueueEmpty(q)){
		printf("队列空\n");
	}else{
		return (q ->rear)->value;
	}
}
bool is_QueueEmpty(Queue* q){// 检测队列是否为空
	assert(q);
	if(q ->front == NULL){
		return  true;
	}else{
		return false;
	}
}
void QueueDestroy(Queue* q){// 销毁队列
	assert(q);
	while(!is_QueueEmpty(q)){
		QueuePop(q);
	}
	free(q);
}
//*******************二叉树的基本操作********************//
Btree_Node* Creat_BinTree(){//创建一个完全二叉树                                            
	Elemtype *a = (Elemtype*)malloc(sizeof(Elemtype) * 50);//字符数组
	scanf("%s",a);
	int leng = strlen(a);
	//为了之后能够删除单个节点，所以节点空间需要一个个申请，那么就需要一个数组record记录各节点的地址
	Btree_Node** record = (Btree_Node**)malloc(sizeof(Btree_Node*) * leng);
	for(int i = 0; i < leng;i++ ){
		Btree_Node* ptr = (Btree_Node*)malloc(sizeof(Btree_Node));
		record[i] = ptr;
		ptr ->data = a[i];
		ptr ->L_child = ptr ->R_child = NULL;
	}
	for(int i = 0; i < leng;i++){
		if(2*i+1 < leng){//有左孩子
			record[i] ->L_child = record[2 * i + 1];
		}
		if(2*i + 2 < leng){//有右孩子
			record[i] ->R_child = record[2 * i + 2];
		}
	}
	if(leng == 0){
		return NULL;
	}else{
		return record[0];
	}
	
}

bool is_empty_BinTree(Btree_Node* ptr){//判断二叉树是否为空
	if(ptr == NULL){
		return true; 
	}else{
		return false;
	}
}
Btree_Node* Buy_New_Node(Elemtype data){//生成一个节点
	Btree_Node* ptr = (Btree_Node*)malloc(sizeof(Btree_Node));
	ptr ->data = data;
	ptr ->L_child = NULL;
	ptr ->R_child = NULL;
	return ptr;
}
void Free_tree(Btree_Node* ptr){//销毁整个二叉树
	//后续遍历销毁整个二叉树
	if(ptr){
		Free_tree(ptr ->L_child);
		Free_tree(ptr ->R_child);
		free(ptr);
	}
	//注意形成的野指针；
}
//增加数据项到二叉树，即插入新的子树
void Insert_ChildTree(Btree_Node* ptr,Btree_Node* insert,int n){
	if(ptr){
		if(ptr ->L_child == NULL && n == 1 ){
			ptr ->L_child = insert;
		}else if(ptr ->R_child == NULL && n == 2){
			ptr ->R_child = insert;
		}else if(ptr ->L_child != NULL && n == 1 ){
			printf("左孩子不为空\n");
		}else if(ptr ->R_child != NULL && n == 2){
			printf("右孩子不为空\n");
		}
	}
}
//n=1删除左子树，n=2删除右子树
void Delete_ChildTree(Btree_Node* ptr,int n){
	if(ptr == NULL){
		printf("树为空\n");
	}else{
		if(n == 1){
			Free_tree(ptr ->L_child);
			ptr ->L_child =NULL;//防止野指针的形成
		}else if(n == 2){
			Free_tree(ptr ->R_child);
			ptr ->R_child = NULL;//防止野指针的形成
		}
	}
}
//先序遍历的递归实现
void Pre_Order_BinTree(Btree_Node* ptr){
	if(ptr){
		printf("%c  ",ptr ->data);
		Pre_Order_BinTree(ptr ->L_child);
		Pre_Order_BinTree(ptr ->R_child);
	}
}
//中序遍历的递归实现
void Mid_Order_BinTree(Btree_Node* ptr){
	if(ptr){
		Mid_Order_BinTree(ptr ->L_child);
		printf("%c  ",ptr ->data);
		Mid_Order_BinTree(ptr ->R_child);
	}
}
 //后序遍历的递归实现
void Post_Order_BinTree(Btree_Node* ptr){
	if(ptr){
		Post_Order_BinTree(ptr ->L_child);
		Post_Order_BinTree(ptr ->R_child);
		printf("%c  ",ptr ->data);
	}
}
//先序遍历的非递归实现
void NPre_Order_BinTree(Btree_Node* ptr){
	Btree_Node* ptr1 = ptr;//用于迭代的变量
	StackNode* stack = StackInit();//创建一个栈
	while(1){
		if(ptr1){//当前节点不为空
			printf("%c  ",ptr1 ->data);
			if(ptr1 ->R_child){//右孩子存在
				StackPush(&stack,ptr1 ->R_child);//右孩子入栈
			}
			ptr1 = ptr1 ->L_child;
		}else{
			if(is_StackEmpty(stack)){//当ptr1为空 栈也为空时遍历结束。 跳出循环
				break;
			}else{
				ptr1 = StackTop(stack);
				StackPop(&stack);
			}
		}
	}
}
//中序遍历的非递归实现
void NMid_Order_BinTree(Btree_Node* ptr){
	Btree_Node* ptr1 = ptr;//用于迭代的变量
	StackNode* stack = StackInit();//创建一个栈
	while(1){
		if(ptr1){//当前节点不为空
			StackPush(&stack,ptr1);
			ptr1 = ptr1 ->L_child;
		}else{
			if(is_StackEmpty(stack)){//当ptr1为空 栈也为空时遍历结束。 跳出循环
				break;
			}else{
				ptr1 = StackTop(stack);
				StackPop(&stack);
				printf("%c  ",ptr1 ->data);
				ptr1 = ptr1 ->R_child;
			}
		}
	}
}
 //后序遍历的非递归实现
void NPost_Order_BinTree(Btree_Node* ptr){
	StackNode* stack = StackInit();//创建一个栈
	Btree_Node* before_ptr = NULL;
	while(1){
		if((ptr ->L_child == before_ptr && ptr ->R_child == NULL) || 
		   (ptr ->R_child == before_ptr && before_ptr != NULL) || 
		   ( ptr ->L_child == ptr ->R_child && ptr ->L_child == NULL)){
			//遍历自己的几种情况：
			//(1)左右孩子为空既(ptr->L_child==ptr->R_child && ptr->L_child==NULL)
			//(2)左右孩子都不为空，并且左右孩子都已经遍历 既(ptr ->R_child == before_ptr && before_ptr != NULL)
			//(3)左孩子为空右孩子不为空，且右孩子已经遍历 既（与2相同）
			//(4)左孩子不为空右孩子为空，且左孩子已经遍历 既((ptr ->L_child == before_ptr && ptr ->R_child == NULL))
			printf("%c  ",ptr ->data);
			before_ptr = ptr;
			if(is_StackEmpty(stack)){//截止条件
				break;
			}else{
				ptr = StackTop(stack);
				StackPop(&stack);
			}
		}else{//左右孩子至少有一个存在且没有遍历
			StackPush(&stack,ptr);//自己入栈
			if(ptr ->L_child){//左孩存在
				if(ptr ->R_child){//右孩子存在
					StackPush(&stack,ptr ->R_child);//右孩子入栈
				}
				ptr = ptr ->L_child;
			}else{
				ptr = ptr ->R_child;
			}
		}
	}
}

void Level_Order_BinTree(Btree_Node* ptr){//层次遍历的实现
	Queue* Qptr = QueueInit();//建立一个空队列
	if(ptr){
		QueuePush(Qptr,ptr);
		while(!is_QueueEmpty(Qptr)){
			ptr = QueueFront(Qptr);
			QueuePop(Qptr);
			printf("%c  ",ptr ->data);
			if(ptr ->L_child){
				QueuePush(Qptr,ptr ->L_child);	
			}
			if(ptr ->R_child){
				QueuePush(Qptr,ptr ->R_child);	
			}
		}
	}
	QueueDestroy(Qptr);
}
黑T毒物
关注
专栏目录
数据结构（C语言）二叉树的表示和实现
AtomQQ_2022313691的博客
07-06 1080
二叉树 二叉树的顺序存储 按满二叉树的结点层次编号，依次存放二叉树中的数据元素。 若有空节点则不能连续存储，空出位置！ 二叉树顺序存储缺点 最坏情况：右单支树，深度为k的且只有k个结点的单支树需要长度为2k-1的一维数组。 特点：结点间蕴含在其存储位置中浪费空间，适合存满二叉树和完全二叉树。 二叉树的链式存储 二叉链表 typedef struct BiNode { TElemType data; struct BiNode* lchild, * rchild;//左右孩子指针 }BiNode,
数据结构——二叉树的概念
Seven_Yang_C的博客
09-02 924
树是一种典型的数据结构（逻辑结构），可以用来描述分支结构，属于一种分层、非线性结构。树的定义是递归的，因此树是一种递归的数据结构。每个结点有唯一的前驱结点，有一个或多个后继结点。（nnn个节点有n−1n-1n−1条边） 基本术语： 度：结点的子结点的个数； 树的度：树种最大的度数； 分支结点：度大于000的结点； 叶子结点：度为000的结点； 结点层次：根结点为第一层，往下递增； 结点高度：从叶结点开始自底向上逐层累加； 结点深度：从根结点自顶向下逐层累加； 树的高度（深度）：树中结点的最大层数； 有序.
二叉树的表示和实现
weixin_33748818的博客
06-04 190
基本概念 　　在计算机科学中，二叉树是每个节点最多有两个子树的树结构。通常子树被称作“左子树”（left subtree）和“右子树”（right subtree）。二叉树常被用于实现二叉查找树和二叉堆。 本文地址：http://www.cnblogs.com/archimedes/p/binary-tree.html，转载请注明源地址。 　　二叉树的每个结点至多只有二棵子树(不存在度大于2...
二叉树的表示与实现（C语言）
weixin_43293451的博客
07-08 834
#include <stdio.h> #include <stdlib.h> #define TRUE 1 #define FALSE 0 #define OVERFLOW -2 #define OK 1 #define ERROR 0 typedef int Status; typedef int TElemType; /* * 链式存储结构代码 *存储结构 ...
March.29.2022——二叉树的相关概念及实现判断（一）
TuZiBuQing的博客
03-29 826
March.29.2022——二叉树的相关概念及实现判断（一） 1.如何判断一棵树是搜索二叉树: 对于每一颗子树左边的树都比他自己小 右边比自己大 判断搜索二叉树方法： 中序遍历 后该二叉树不会降序； 解法一：代码实现 左树为搜索二叉树，左树上的最小值必须要大于我 返回值：是否为搜索二叉树，和最大值，最小值 右树为搜索二叉树，右树上的最大时要小于我 返回值：是否为搜索二叉树，和最小值，最大值 //默认左树给我一个信息，得到三个返回值 //默认右树给我一个信息，得到三个返回值 //得到自己的三个返
java.二叉树的相关概念
qq_45239139的博客
11-03 73
在了解二叉树的相关概念之前，我们首先要对“ 树 ” 的概念进行初步了解 树： 树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。 之所以把它称为树，因为它看起来就像是一个倒挂起来的树，也就是说它的结构就和我们日常生活中看到的树的形状是相反的，它是根朝着上方，而叶朝着下方 它具有以下特点： （1）每个结点有零个或者多个结点 （2）没有父结点的结点我们称之为根结...
【数据结构】树及二叉树概念
gwPersevere的博客
06-06 813
树、二叉树的概念以及性质
头歌数据结构二叉树的顺序存储及基本操作
05-18
在计算机科学中，二叉树是一种重要的数据结构，它的每个节点最多有两个子节点，分别称为左子树和右子树。这种特殊的树形结构在很多领域都有应用，特别是在文件系统和数据库系统中，利用二叉树可以实现高效的排序和...
数据结构二叉树，c语言简单实现
01-12
数据结构中的二叉树是一种非线性数据结构，它由n（n>=1）个有限节点组成，这些节点通过边连接形成一个具有层次关系的集合。每个节点最多有两个子节点，通常称为左子节点和右子节点。二叉树的概念在计算机科学中广泛...
合工大数据结构实验 二叉树
04-14
本实验的主题是“二叉树”，这是数据结构中一个基础且重要的概念。二叉树是一种非线性的数据结构，由节点（或称为顶点）组成，每个节点最多有两个子节点，通常称为左子节点和右子节点。这个实验旨在帮助学生深入理解...
二叉树的二叉链表表示与实现
11-16
二叉树的二叉链表表示与实现，包括二叉树的建立、遍历、深度、叶子节点数等
数据结构-二叉树 JAVA语言实现
10-16
在IT领域，数据结构是计算机科学的基础，而二叉树作为一种重要的数据结构，被广泛应用于算法设计、数据库系统、编译器等领域。本教程将详细阐述如何使用JAVA语言实现二叉树的相关操作。 首先，我们要了解二叉树的...
C语言数据结构二叉树简单应用
08-30
一、数据结构二叉树的概念： 在计算机科学中，二叉树是一种树结构，每个节点最多有两个子树，通常子树被称作“左子树”（left subtree）和“右子树”（right subtree）。 二、C语言数据结构二叉树简单应用： （1...
【数据结构】二叉树
qq_43669007的博客
08-27 147
深度优先遍历：不撞南墙不回头 必然要用到栈 广度优先遍历：一层一层遍历 必然要用到队列 树形结构 有序树：孩子的顺序重要的树 无序树：孩子的顺序不重要的树 二叉树：二叉树（binary tree）是一颗树，其中每个节点都不能有多余两个的儿子。 1.度最大为2 2.有序树 递归思想+递归方法 二叉树的表示形式： 链式表示： class Node{ int v...
二叉树的详解与实现
热门推荐
注意路标
08-18 16万+
简介 二叉树的相关概念，如，树高度，节点层数，节点度数，路径，叶节点，分支节点，根节点，父节点，左节点，右节点，兄弟节点，祖先节点，子孙节点，左子树，右子树等基本概念，不再赘述。 二叉树分类 1、完全二叉树 若设二叉树的高度为h，除第 h 层外，其它各层 (1～h-1) 的结点数都达到最大个数，第h层有叶子结点，并且叶子结点都是从左到右依次排布，这就是完全二叉树。 一维数组可以作为完全二叉树...
二叉树的存储表示与实现（陈锐，葛丽萍跟我学数据结构整理）
qq_41929516的博客
11-29 255
1.二叉树的顺序存储， 即用一维数组按照从左到右，从上到下的顺序依次存储，分析计算可得每个节点的编号，类似于树状数组。 适用于完全二叉树。 存储非完全二叉树时，需要在一维数组中将二叉树不存在的结点位置空出，并用NULL填充。 2.二叉树.的链式存储 二叉树的链式存储结构 二叉链表存储结构包含三个域：数据域，左孩子指针（指向左孩子节点）和右孩子指针（指向右孩子节点）。 三叉lian链表...
二叉树概念及实现
糖公子没来过的博客
06-10 143
二叉树 二叉树的基本概念 二叉树是每个节点最多有两个子树的树结构。通常子树被称作“左子树”（left subtree）和“右子树”（right subtree） 完全二叉树 若设二叉树的高度为h，除第 h 层外，其它各层 (1～h-1) 的结点数都达到最大个数，第h层有叶子结点，并且叶子结点都是从左到右依次排布，这就是完全二叉树。 满二叉树 除了叶结点外每一个结点都有左右子叶且叶子结点都处在最底层的二叉树 二叉树的性质 性质1:在二叉树的第i层上至多有2^(i-1)个结点（i>0）..
数据结构——10.二叉树的表现和实现
qq_51330164的博客
06-07 546
数据结构 10.二叉树的表现和实现 1.1二叉树的存储结构 1.顺序存储 二叉树的顺序存储结构就是一组地址连续的存储单元依次自上而下，自左而右地存储二叉树中的结点，并且在存储结点的同时，结点的存储位置（下标）应能体现结点之间的逻辑关系。 那么如何利用数组下标来反映结点之间的逻辑关系呢？性质5中介绍的完全二叉树中结点的编号就可以反映出结点之间的逻辑关系。 顺序实现的特点 1.造成存储空间的浪费：最坏的情况下，一个深度为k且只有k个结点的右单支二又树需要2k−12^k-12k−1个存储单元 2.一般只用于一
详解：冒泡排序
最新发布
2401_83418369的博客
09-14 751
冒泡排序（Bubble Sort）是一种简单的排序算法。它重复地遍历要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。遍历数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。
二叉链结构实现与二叉树概念解析
"二叉链结构的二叉树设计与实现" ...树和二叉树是数据结构中的重要组成部分，它们在算法设计、文件系统、编译器设计等领域发挥着关键作用。理解和掌握这些基本概念及其操作对于任何IT专业人员来说都至关重要。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值