数据结构—二叉树

已于 2023-04-15 23:31:25 修改
阅读量1k 收藏 1
点赞数
分类专栏： C/C++ 文章标签： 数据结构 算法 c语言
于 2022-09-22 19:18:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/thdwx/article/details/126997429
版权

二叉树是一棵树，其每个节点的儿子数不能多于2.下图是一般的二叉树：

 二叉树的平均深度要比N（数据量）小得多，其平均深度是O(根号下N)。而对于二叉查找树来说，其平均深度为O(logN).而当二叉树退化成链表时（即每个父亲节点只有一个儿子），它的深度可以大到N-1.二叉查找树是有序的，其任意节点的左子树的节点都小于它，右子树的节点都大于它。

二叉树的性质：

① 一个二叉树的第k层最多有2^{k-1}个结点（k>=1）

② 一个高度为k的二叉树最多有2^{k}-1个结点（k>=1）

③ 对于任意的二叉树，度为零的结点的个数等于度为1的结点的个数+1，即n_{0}=n_{2}+1，证明如下，对于有n个结点的二叉树，有n=n_{0}+n_{1}+n_{2}，其边（分支）的个数有n-1条（除根节点外，每个结点都有一条边连接其父节点），边的条数还等于2*n_{2}+n_{1}，那么结合这几个关系就可以得出结果。

④ 对于有n个结点的二叉树，有n+1个空着的指针域，这也为线索二叉树提供了基础（使用这些空指针指向该节点的前驱或后继）。

⑤ 满二叉树：满二叉树是指，对于一个高度为k（K>=1）的二叉树，如果它结点的个数为2^{k}-1，那么这棵二叉树就是满二叉树。

⑥ 完全二叉树：是指如果一棵高为k的树中结点的编号（从1开始编号，按照层序遍历的办法）与高度为k的满二叉树的结点编号可以对应（从1开始编号，按照层序的办法，满二叉树多出来的结点不算在内），那么这棵树就是完全二叉树。也就是说，高度为k的完全二叉树，其除第k层外是一棵满二叉树，第k层的结点从左到右依次排列，不能有空缺。一棵有n个结点的完全二叉树的高度为\left \lfloor log_{2} n \right \rfloor+1或\left \lceil log_{2}(n+1) \right \rceil。满二叉树一定是完全二叉树，完全二叉树不一定是满二叉树。如果从1开始编号，那么完全二叉树中的结点与其孩子结点有倍数上的关系，所以可以使用顺序表表示，例如，1结点的孩子是2和3，2结点的孩子是4和5等。

二叉树的遍历：

① 先序遍历：先处理根节点，再处理左子树，最后处理右子树

② 中序遍历：先处理左子树，再处理根节点，最后处理右子树

③ 后序遍历：先处理左子树，再处理右子树，最后处理根节点

二叉查找树的递归实现：

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

typedef struct tree {
	int ele;//节点值
	struct tree* left;//左子树
	struct tree* right;//右子树
	int count;//记录重复元素的个数
}tree;

tree* FindMin(tree* t) {//找最小值，一直找到最左边的树叶即可
	if (t == NULL) {//平均时间复杂度和空间复杂度都为O(logN)
		printf("树为空树\n");
		return NULL;
	}
	if (t->left != NULL)
		return FindMin(t->left);
	else
		return t;
}

tree* FindMax(tree* t) {//和找最小值原理相同
	if (t == NULL) {
		printf("树为空树\n");
		return NULL;
	}
	if (t->right != NULL)
		return FindMax(t->right);
	else
		return t;
}

tree* insert(tree* t, int x) {//插入
	if (t == NULL) {//如果t为空，就建立一个节点
		t = (tree*)malloc(sizeof(tree));//时间空间复杂度为O(logN)
		t->ele = x;
		t->left = NULL;
		t->right = NULL;
		t->count = 1;
	}
	else {//t不为空，首先找到x的位置
		if (x > t->ele) {//x大于节点值，就插入在节点的右边
			t->right = insert(t->right, x);
		}
		else if (x < t->ele) {//x小于该节点值，就插入到节点的左边
			t->left = insert(t->left, x);
		}
		else {//等于节点值，就让count+1
			t->count++;
		}
	}
	return t;
}

tree* delete(tree* t, int x) {//删除要分为有两个孩子的删除和一个或零个孩子的删除
	if (t == NULL) {//删除的时间空间复杂度也为O(logN)
		printf("树为空树\n");
		return NULL;
	}
	if (x < t->ele) {//x小于节点值就向左找
		t->left = delete(t->left, x);
	}
	else if (x > t->ele) {//x大于节点值就向右找
		t->right = delete(t->right, x);
	}
	else {//找到x的位置
		if (t->left != NULL && t->right != NULL) {//x有两个孩子节点
			tree* tmp = FindMin(t->right);//首先找到右子树的最小值
			t->ele = tmp->ele;//将最小值节点移到x的位置，实际上只需要赋值即可
			t->right = delete(t->right, tmp->ele);//然后删除该最小值节点
		}
		else {//当只有一个或没有孩子时
			tree* tmp = t;
			if (t->left == NULL) {//当它的左子树为空，就将右子树的指针返回
				t = t->right;
			}
			else if (t->right == NULL) {//右子树为空，就返回左子树的指针
				t = t->left;
			}
			free(tmp);
		}
	}
	return t;
}

tree* Find(tree* t,int x) {//查找时间空间复杂度为O(logN)
	if (t == NULL) {
		printf("树为空树\n");
		return;
	}
	if (x > t->ele) {//x大于节点值，就向右找
		return Find(t->right, x);
	}
	else if (x < t->ele) {//x小于节点值，就向左找
		return Find(t->left, x);
	}
	else
		return t;
}

//中序遍历打印
void Print(tree* t) {//时间空间复杂度为O(N)
	if (t == NULL) {
		printf("树为空树\n");
		return;
	}
	if (t->left != NULL) {
		Print(t->left);
	}
	printf("%d ", t->ele);
	if (t->right != NULL) {
		Print(t->right);
	}
}

void MakeEmpty(tree* t) {//时间空间复杂度为O(N)
	if (t != NULL) {
		MakeEmpty(t->left);
		MakeEmpty(t->right);
		free(t);
	}
}

int main() {
	tree* root = insert(NULL, 5);
	for (int i = 0; i <= 10; i++) {
		insert(root, i);
	}
	Print(root);
	printf("\n-------------------------\n");
	insert(root, 18);
	Print(root);
	printf("\n-------------------------\n");

	printf("%d\n-------------------------\n", (FindMin(root))->ele);
	printf("%d\n-------------------------\n", (FindMax(root))->ele);
	printf("%d\n-------------------------\n", (Find(root,5))->ele);

	for (int i = 0; i <= 4; i++) {
		delete(root, i);
		Print(root);
		printf("\n-------------------------\n");
	}
	//当二叉树只有左子树或是右子树时，对其根的删除就必须重新赋值
	root = delete(root, 5);
	//只有这样，才能正常打印出二叉树的元素，这是因为，当只有一边的子树时
	//删除时要将删除节点的孩子节点连接在父亲节点上，但是由于根没有父亲节点
	//所以当删除结束后，root会丢失二叉树的地址，就必须重新进行赋值才能正常使用

	Print(root);
	printf("\n-------------------------\n");

	return 0;
}

二叉查找树的循环实现： 

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

typedef struct tree {
	int ele;
	struct tree* left;
	struct tree* right;
	int count;
}tree;

tree* FindMin(tree* t) {//时间复杂度为O(logN)
	if (t == NULL) {
		printf("树为空树\n");
		return NULL;
	}
	while (t->left != NULL) {//找到最左边的节点
		t = t->left;
	}
	return t;
}

tree* FindMax(tree* t) {//找最大值同理
	if (t == NULL) {
		printf("树为空树\n");
		return NULL;
	}
	while (t->right != NULL)
		t = t->right;
	return t;
}

tree* insert(tree* t, int x) {//插入的时间复杂度为O(logN)
	tree* before = t;
	if (t == NULL) {
		t = (tree*)malloc(sizeof(tree));
		t->ele = x;
		t->left = NULL;
		t->right = NULL;
		t->count = 1;
	}
	else {
		while (1) {
			if (x < t->ele) {
				before = t;
				t = t->left;
				if (t == NULL) {
					t = (tree*)malloc(sizeof(tree));
					t->ele = x;
					t->left = NULL;
					t->right = NULL;
					t->count = 1;
					before->left = t;
					break;
				}
			}
			else if (x > t->ele) {
				before = t;
				t = t->right;
				if (t == NULL) {
					t = (tree*)malloc(sizeof(tree));
					t->ele = x;
					t->left = NULL;
					t->right = NULL;
					t->count = 1;
					before->right = t;
					break;
				}
			}
			else {
				t->count++;
				break;
			}
		}
	}
	return t;
}

tree* delete(tree* t, int x) {//删除的时间复杂度为O(logN)
	tree* root = t;
	tree* before = t;
	if (t == NULL) {
		printf("树为空树\n");
		return NULL;
	}
	while (1) {
		if (x > t->ele) {
			before = t;
			t = t->right;
		}
		else if (x < t->left) {
			before = t;
			t = t->left;
		}
		else {
			if (t->left != NULL && t->right != NULL) {//有两个子树的情况
				tree* tmp = FindMin(t->right);//找到右子树的最小值
				t->ele = tmp->ele;//将最小值赋给待删除节点，然后删除最小值节点
				tree* minbefore = t->right;
				if (minbefore == tmp) {//如果最小值就是删除节点的右子树
					t->right = tmp->right;
					free(tmp);
				}
				else {//如果最小值不为右子树
					while (minbefore->left->ele != tmp->ele) {//找到最小值的父亲节点
						minbefore = minbefore->left;
					}
					minbefore->left = tmp->right;//删除最小值
					free(tmp);
				}
			}
			else {//有小于两个子树的情况
				if (t == root) {//如果要删除节点为根节点
					if (t->left == NULL) {//左子树为空，就将根节点变为右子树的第二个节点
						tree* p = t->right;
						free(t);
						return p;
					}
					else {//右子树为空同理
						tree* p = t->left;
						free(t);
						return p;
					}
				}
				if (t->left == NULL) {//节点的左子树为空，则要将节点的右子树连接到父亲节点上
					if (before->left == t) {
						before->left = t->right;
					}
					else
						before->right = t->right;
				}
				else if (t->right == NULL) {//节点的右子树为空同理
					if (before->left == t) {
						before->left = t->left;
					}
					else
						before->right = t->left;
				}
			}
		}
	}
	return t;
}

tree* Find(tree* t,int x) {
	tree* tmp = t;
	if (t == NULL) {
		printf("树为空树\n");
		return NULL;
	}
	while (tmp->ele != x) {
		if (x < tmp->ele) {
			tmp = tmp->left;
		}
		else
			tmp = tmp->right;
	}
	return tmp;
}

//中序遍历打印
void Print(tree* t) {//中序遍历的打印使用循环也过于麻烦
	//由于必须先打印左子树，所以需要先找到最左边的叶节点，
	//从这个叶节点开始向上打印，所以打印显然是一个递归
	if (t == NULL) {
		printf("树为空树\n");
		return;
	}
	if (t->left != NULL) {
		Print(t->left);
	}
	printf("%d ", t->ele);
	if (t->right != NULL) {
		Print(t->right);
	}
}

void MakeEmpty(tree* t) {//清除内存函数使用循环过于低效，因为必须先找到每个叶节点
	//当叶节点释放完毕后，再释放上一级的叶节点，但由于没有办法从叶节点直接找到它们的
	//父亲节点，所以总共需要树的深度-1次循环才能实现
	if (t != NULL) {
		MakeEmpty(t->left);
		MakeEmpty(t->right);
		free(t);
	}
}

int main() {
	tree* root = insert(NULL, 5);
	for (int i = 0; i <= 10; i++) {
		insert(root, i);
	}
	Print(root);
	printf("\n-------------------------\n");
	insert(root, 18);
	Print(root);
	printf("\n-------------------------\n");

	printf("%d\n-------------------------\n", (FindMin(root))->ele);
	printf("%d\n-------------------------\n", (FindMax(root))->ele);
	printf("%d\n-------------------------\n", (Find(root,5))->ele);

	for (int i = 0; i <= 4; i++) {
		delete(root, i);
		Print(root);
		printf("\n-------------------------\n");
	}
	//当二叉树只有左子树或是右子树时，对其根的删除就必须重新赋值
	root = delete(root, 5);
	//只有这样，才能正常打印出二叉树的元素，这是因为，当只有一边的子树时
	//删除时要将删除节点的孩子节点连接在父亲节点上，但是由于根没有父亲节点
	//所以当删除结束后，root会丢失二叉树的地址，就必须重新进行赋值才能正常使用

	Print(root);
	printf("\n-------------------------\n");

	return 0;
}

表达式树：

要将一个表达式转化成表达式树，首先要将其改写成后缀表达式（使用栈），接下来从左到右遍历后缀表达式，遇见数字就建立一个节点保存数字，并将节点的地址推入栈中，当遇见运算符时，建立一个节点保存符号，并从栈中弹出两个地址，分别放在符号节点的左子树和右子树。最后栈中留下的地址即是根节点的地址。

int main() {
	char str[] = "ab+cde+**";
	char* p = str+1;
	s* ps = CreatStack();//创建一个栈
	tree* tmp = insert(NULL, 'a');//建立一个节点
	push(ps, tmp);//将节点的地址推入栈中
	while (*p) {
		if (isalpha(*p)) {//当遇到数字时
			tmp = insert(NULL, *p);//建立一个节点并推入栈中
			push(ps, tmp);
		}
		else {
			tree* root = insert(NULL, *p);//为运算符时
			root->left = topandpop(ps);//建立一个节点，并且和栈中弹出的两个元素连接起来
			root->right = topandpop(ps);
			push(ps, root);
		}
		p++;
	}//循环结束后栈顶的元素就是根的地址
	tree* root = top(ps);
	return 0;
}

thdwx
关注
专栏目录
数据结构 二叉树（三）二叉树的深度
胡乱写点什么
02-20 1069
数据结构（十二） 学习数据结构与算法过程中的心得体会以及知识点的整理，方便我自己查找，也希望可以和大家一起交流。 —— 二叉树的深度 —— 1.题目描述 给定一棵二叉树，求该二叉树的深度 二叉树深度定义：从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的节点个数为树的深度 1.1输入 第一行是一个整数n，表示二叉树的结点个数。二叉树结点编号从1到n，根结点为1，n &...
[数据结构]求二叉树的深度与宽度
ER_Plough的专栏
08-09 2944
二叉树数据结构声明： struct TreeNode { int val; TreeNode *left; TreeNode *right; };   1、递归求二叉树深度   int getDepth(TreeNode *root) { if (root == NULL) { return 0; } re
如何计算完全二叉树的深度
热门推荐
小辣抓
09-22 2万+
如何计算完全二叉树的深度一棵有12个节点的完全二叉树，其深度是（）一棵有12个节点的完全二叉树，其深度是（） 4 5 3 6 在此之前我想说一下三种二叉树 Full Binary Tree Perfect Binary Tree Complete Binary Tree 为什么要说到这个问题，是因为在翻译的时候有个坑，特地想拿出来给大家说一下，Full Binary Tree翻译过来应该是满二叉树，
数据结构二叉树的深度
wwxy1995的博客
11-25 773
6-8 求二叉树高度 （20 point(s)） 本题要求给定二叉树的高度。 函数接口定义： int GetHeight( BinTree BT ); 其中BinTree结构定义如下： typedef struct TNode *Position; typedef Position BinTree; struct TNode{ ElementType Data; B...
【数据结构】求二叉树的最大深度
阳阳的博客
11-02 1万+
求二叉树的最大深度 二叉树的最大深度即二叉树的高度，一般有两个解法，第一种是递归，代码简单，但不太好理解。第二种是使用层序遍历的方式，记录每层的节点数，遍历完一层，层数计数器加一。 一、递归 想要求一颗二叉树的高度，即求孩子节点的最大深度，要么是左孩子，要么是右孩子，那么我们只需要对传入的孩子节点递归调用即可。 ...
数据结构——二叉树的深度
qq_33713592的博客
05-26 1696
一、二叉树的最大深度 int maxDepth(TreeNode *root) { if(root == NULL) return 0; int left = maxDepth(root->left) int right = maxDepth(root->right) return l...
数据结构-二叉树（深度剖析）
最新发布
aa884561001的博客
12-19 1139
二叉树，堆实现，链式结构
数据结构与算法（5）：二叉树的深度
冷雨清的博客
03-01 407
剑指 Offer 55 - I. 二叉树的深度 输入一棵二叉树的根节点，求该树的深度。从根节点到叶节点依次经过的节点（含根、叶节点）形成树的一条路径，最长路径的长度为树的深度。 例如： 给定二叉树 [3,9,20,null,null,15,7]， 3 / 9 20 / 15 7 返回它的最大深度 3 。 提示： 节点总数 <= 10000 解析(主要是采用DFS的方式进行遍历，简单快捷) 树的遍历方式总体分为两类：深度优先搜索（DFS）、广度优先搜索（BFS）； 常见的 DFS ： 先序遍
数据结构实验 5.二叉树深度
Running Snail
05-19 706
【问题描述】 给定一棵二叉树，求该二叉树的深度。 二叉树深度定义：从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的节点个数为树的深度。 【输入形式】 第一行是一个整数n，表示二叉树的结点个数。二叉树结点编号从1到n，根结点为1，n <= 10 接下来有n行，依次对应二叉树的n个节点。 每行有两个整数，分别表示该节点的左儿子和右儿子的节点编号。如果第一个（第二个）数为-1则表示没有左（右）儿子。 【输出形式】 输出一个整型数，表示树的深度。 【样例输入】 3 2 3 -1 -1
数据结构与算法-二叉树的深度-leetcode
weixin_43331160的博客
03-22 372
1 二叉树的深度 题目：输入一棵二叉树的根节点，求该树的深度。从根节点到叶节点依次经过的节点（含根、叶节点）形成树的一条路径，最长路径的长度为树的深度。 例如：给定二叉树 [3,9,20,null,null,15,7]， 返回它的最大深度 3 树的遍历方式总体分为两类：深度优先搜索（DFS）、广度优先搜索（BFS）； 常见的 DFS ： 先序遍历、中序遍历、后序遍历； 常见的 BFS ： 层序遍历...
头歌数据结构二叉树的二叉链表存储及基本操作
05-18
在IT领域，数据结构是计算机科学的基础，而二叉树是一种重要的抽象数据类型。本题主要涉及二叉树的链式存储方式以及基于链表的二叉树的基本操作，包括先序遍历、计算二叉树的高度、节点总数、叶子节点数、层次遍历...
头歌数据结构二叉树的顺序存储及基本操作
05-18
在计算机科学中，二叉树是一种重要的数据结构，它的每个节点最多有两个子节点，分别称为左子树和右子树。这种特殊的树形结构在很多领域都有应用，特别是在文件系统和数据库系统中，利用二叉树可以实现高效的排序和...
数据结构二叉树功能展示
06-02
数据结构二叉树功能展示包括以完全前序序列创建二叉树"; cout以前序和中序序列创建二叉树"; cout前序遍历二叉树"; cout中序遍历二叉树"; cout后序遍历二叉树"; cout广度优先遍历二叉树"; cout求某结点的双亲";...
C语言数据结构二叉树简单应用
08-30
本文主要介绍了C语言数据结构二叉树简单应用的相关知识点，涵盖了二叉树的创建、先中后序递归遍历、统计叶子结点的总数、求树的高度、反转二叉树、输出每个叶子结点到根节点的路径、输出根结点到每个叶子结点的路径...
数据结构 二叉树
03-20
数据结构中的二叉树是一种非常重要的非线性数据结构，其在计算机科学中扮演着核心角色，尤其是在数据存储和检索方面。本文将深入探讨二叉树的定义、特性、操作及其实现细节，旨在帮助读者全面理解二叉树及其在实际...
二叉树的深度和高度
Mamba_Stan的博客
09-07 7877
给定一个二叉树, 找出其最大深度。二叉树的深度为根节点到最远叶子节点最长路径上的节点数。如二叉树 [ 3, 9, 20, null, null, 15, 7 ]的最大深度为3:先看一个简单的情况:对于节点 3, 最大深度自然是左右子节点 + 1, 左右子节点都有可能为空, 但只要有一个, 树的最大高度就是 1 + 1 = 2。然后再增加几个节点:而对于节点 3, 则是左右子树深度最大的那个然后 + 1, 具体谁更大, 并不关心。
数据结构--二叉树--获得二叉树的深度和根（链表结构）
复兴之路
08-07 1200
采用二叉链表结构构造二叉树，完成其基本操作。   #include #define CHAR /* 字符型 */ #include /* EOF(=^Z或F6),NULL */ #include /* floor(),ceil(),abs() */ #define TRUE 1 #define FALSE 0 #define OK 1 typedef int Status;
数据结构之二叉树相关笔试题
kaikai_sk的博客
12-08 580
面试题：二叉树的深度 题目：输入一棵二叉树的根节点，求该树的深度。从根节点到叶子结点一次经过的结点形成树的一条路径，最长路径的长度为树的深度。根节点的深度为1。解体思路：如果根节点为空，则深度为0，返回0，递归的出口 如果根节点不为空，那么深度至少为1，然后我们求他们左右子树的深度， 比较左右子树深度值，返回较大的那一个 通过递归调用#include #include
数据结构之二叉树深度计算
千寻瀑
08-05 3164
数据结构之二叉数深度计算原理代码 原理 本质上就是二叉树的遍历过程 分别遍历左右子树，取大的即可 二叉数树深度 = max(左子树深度，右子树深度) + 1 代码 //二叉数深度计算 int treeDepth(BiTree T){ if(T == null) return 0; else{ int l = treeDepth(T->lchild); int r = treeDepth(T->rchild); r
数据结构二叉树详解
"数据结构二叉树优选ppt资料.ppt" 这份资料主要涵盖了数据结构中的核心概念——二叉树。二叉树是数据结构中的一个重要组成部分，它是一种特殊的树形结构，每个节点最多有两个子节点，通常称为左子节点和右子节点。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值