平衡二叉树及优化(细节图解)(时间复杂度O(N))

最新推荐文章于 2024-04-27 03:56:45 发布
最新推荐文章于 2024-04-27 03:56:45 发布
阅读量1.1k 收藏 17
点赞数 24
分类专栏： 数据结构 文章标签： 数据结构 c语言 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_61125362/article/details/135040531
版权

一.平衡二叉树

定义：平衡二叉树是一种高度平衡的二叉树，它的节点结构和操作方式有特殊的规律。平衡二叉树的定义是：任意节点的子树的高度差都小于等于1。 平衡二叉树的作用是提高查询的效率，保证查询的时间复杂度为O(logn)。

平衡二叉树会使用到[递归(这里有递归基础)]

1.1平衡二叉树定义

二.构建二叉树节点

2.1构建结构体

typedef char BTDataType;
typedef struct BinaryTreeNode {
	BTDataType data;
	struct BinaryTreeNode* left;
	struct BinaryTreeNode* right;
}BTNode;

2.2连接图例

 2.3创建节点

BTNode* CreateNode(BTDataType x)//创建节点
{
	BTNode* node = (BTNode*)malloc(sizeof(BTNode));
	node->data = x;
	node->left = NULL;
	node->right = NULL;
	return node;
}

三.构建二叉树

3.1快速构建二叉树

BTNode* A = CreateNode(1);
	BTNode* B = CreateNode(2);
	BTNode* C = CreateNode(3);
	BTNode* D = CreateNode(4);
	BTNode* E = CreateNode(5);


	BTNode* A2 = CreateNode(1);
	BTNode* B2 = CreateNode(2);
	BTNode* C2 = CreateNode(3);
	BTNode* D2 = CreateNode(4);
	BTNode* E2 = CreateNode(5);
	BTNode* F2 = CreateNode(5);


	//快速构建树A
	A->left = B;
	A->right = C;
	B->left = D;
	B->right = E;

	//快速构建树A2
	A2->left = B2;
	A2->right = C2;
	B2->left = D2;
	C2->right = E2;
	E2->right = F2;

 3.2构建的两颗树

 四.平衡二叉树(O(n^2))

4.1平衡二叉树代码

方法一(未优化):平衡二叉树的判断思路主要是看该二叉树是否满足两个条件：首先，它需要是一颗[二叉排序树]；其次，它的任何一个节点的左子树或者右子树都需要是平衡二叉树，也就是说左右子树的高度差必须小于等于1。

具体实现上，我们可以使用递归的方法来进行判断。首先检查当前子树是否是平衡二叉树，然后递归地对左子树和右子树做同样的检查。在检查过程中，需要求出每个节点的左右子树的高度，并判断它们的高度差是否超过了1。只有当每个节点都满足上述条件时，这颗二叉树才可以被称为是平衡二叉树。

int TreeDepth(BTNode* root)//树的高度
{
	if (root == NULL)
		return 0;

	int leftDepth = TreeDepth(root->left);
	int rightDepth = TreeDepth(root->right);
	return leftDepth > rightDepth ? leftDepth + 1 : rightDepth + 1;
}




//平衡二叉树(前序)
//TreeDepth()计算当前树的高度
bool isBalanced(BTNode* root)
{
	if (root == NULL)
		return true;

	int gap = TreeDepth(root->left) - TreeDepth(root->right);
	if (abs(gap) > 1)
		return false;


	return isBalanced(root->left) && isBalanced(root->right);

}

4.2计算树的高度图解

4.3平衡二叉树图解

对比当前根(root)左右子树的高度，这里每次对比的时候都要调用TreeDepth()计算当前根左右子树的高度，又因为TreeDepth()的时间复杂度为O(n),

所以整个isBalanced()的最坏时间复杂度为O(n^2)

五.平衡二叉树优化(O(n))

5.1平衡二叉树代码优化

从左子树叶子节点开始。判断的同时，把高度带给上一次调用的父亲节点，这里不需要再递归求树的高度，优化之后就不像之前存在大量的重复计算。isBalanced1()优化后的平衡二叉树代码，时间复杂度为O(N).

可以通过【前序中序后续递归】尝试打印出树中的数据。

bool _isBalanced1(BTNode* root, int* pDepth)
{
	if (root == NULL)
	{
		*pDepth = 0;
		return true;
	}
	else
	{
		int leftDepth = 0;
		if (_isBalanced1(root->left, &leftDepth) == 0)
		{
			return false;
		}

		int rightDepth = 0;
		if (_isBalanced1(root->right, &rightDepth) == 0)
		{
			return false;
		}

		if (abs(leftDepth - rightDepth) > 1)
			return false;

		*pDepth = leftDepth > rightDepth ? leftDepth + 1 : rightDepth + 1;
		return true;

	}
}
bool isBalanced1(BTNode* root)
{
	int Depth = 0;
	return _isBalanced1(root, &Depth);
}

5.1 平衡二叉树图解

六.全部代码

6.1全部代码

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

typedef char BTDataType;
typedef struct BinaryTreeNode {
	BTDataType data;
	struct BinaryTreeNode* left;
	struct BinaryTreeNode* right;
}BTNode;

BTNode* CreateNode(BTDataType x)//创建节点
{
	BTNode* node = (BTNode*)malloc(sizeof(BTNode));
	node->data = x;
	node->left = NULL;
	node->right = NULL;
	return node;
}

int TreeDepth(BTNode* root)//树的高度
{
	if (root == NULL)
		return 0;

	int leftDepth = TreeDepth(root->left);
	int rightDepth = TreeDepth(root->right);
	return leftDepth > rightDepth ? leftDepth + 1 : rightDepth + 1;
}




//平衡二叉树(前序)
//TreeDepth()计算当前树的高度
bool isBalanced(BTNode* root)
{
	if (root == NULL)
		return true;

	int gap = TreeDepth(root->left) - TreeDepth(root->right);
	if (abs(gap) > 1)
		return false;


	return isBalanced(root->left) && isBalanced(root->right);

}




bool _isBalanced1(BTNode* root, int* pDepth)
{
	if (root == NULL)
	{
		*pDepth = 0;
		return true;
	}
	else
	{
		int leftDepth = 0;
		if (_isBalanced1(root->left, &leftDepth) == 0)
		{
			return false;
		}

		int rightDepth = 0;
		if (_isBalanced1(root->right, &rightDepth) == 0)
		{
			return false;
		}

		if (abs(leftDepth - rightDepth) > 1)
			return false;

		*pDepth = leftDepth > rightDepth ? leftDepth + 1 : rightDepth + 1;
		return true;

	}
}
bool isBalanced1(BTNode* root)
{
	int Depth = 0;
	return _isBalanced1(root, &Depth);
}



int main()
{
	BTNode* A = CreateNode(1);
	BTNode* B = CreateNode(2);
	BTNode* C = CreateNode(3);
	BTNode* D = CreateNode(4);
	BTNode* E = CreateNode(5);


	BTNode* A2 = CreateNode(1);
	BTNode* B2 = CreateNode(2);
	BTNode* C2 = CreateNode(3);
	BTNode* D2 = CreateNode(4);
	BTNode* E2 = CreateNode(5);
	BTNode* F2 = CreateNode(5);


	//快速构建树A
	A->left = B;
	A->right = C;
	B->left = D;
	B->right = E;

	//快速构建树A2
	A2->left = B2;
	A2->right = C2;
	B2->left = D2;
	C2->right = E2;
	E2->right = F2;


	printf("A这棵树为平衡二叉树吗?   1是 0不是\n");
	bool a = isBalanced1(A);
	printf("A=%d", a);
	printf("\n");

	
	printf("A2这棵树为平衡二叉树吗?   1是 0不是\n");
	bool b = isBalanced1(A2);
	printf("A2=%d", b);
	printf("\n");


	return 0;
}

 6.2运行结果

   以上就是本期内容，欢迎参考指正，如有不懂，欢迎评论或私信出下期！！！

锻炼²
关注
  • 24
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
自平衡二叉树实现及时间复杂度分析
qq_1015350043的博客
12-10 8921
平衡二叉树的实现我们在遍历二叉树时，先一直往左遍历，于是我们发现，当一棵树的每个节点都只有一个子节点时，他就变成了一个链表，然后链表就说啊：❝年轻人你不要过度消费我，这好吗？这不好。❞所...
平衡二叉（AVL）树
月守护的博客
12-15 901
在前面的系列文章中，我们讲过了二叉查找树的相关知识和实现（二叉树（一）–概述（附二叉搜索树实现））。在文章的最后，我们总结了二叉查找树的查找时间复杂度： 对于一个节点分布相对均衡的二叉查找树来说，如果节点总数是n，那么搜索节点的时间复杂度是O（logn）,和树的深度是一样的。 但对于极端情况（每次插入数据大小都是增大的，或者减小的），外形上看就只有一半的树，查找时间复杂度就会退化成O（n）的 为了解决二叉查找树查找时间复杂度退化的问题，需要二叉数据的自平衡，也就是本节要讲的平衡二叉树。通过自身的平衡调整
数据结构-复习（三）：平衡二叉树 AVL
dadaima_sama的博客
03-29 1005
2.9平衡二叉树 原因：由于二叉搜索树的时间复杂度受输入顺序的影响，在最好的情况下复杂度为O(log n),最坏的情况下复杂度为O(n);为了使二叉搜索树的时间复杂度始终保持在O(log n)级的平衡状态，Adelson-Velskii和Landis发明了AVL树（平衡二叉树）。 定义 定义：结点的平衡因子：二叉树中某结点的右子树的高度和左子树的高度之差称为该节点的平衡因子。 平衡二叉树...
平衡二叉树
Poem_coder的博客
03-25 1005
一、题目 二、思路 1.一棵树要是平衡二叉树，那么它的每颗子树都要是平衡二叉树 2.root左树的高度-右树的高度<=1 时间复杂度：O(n^2)，其中 n是二叉树中的节点个数。 最坏情况下，二叉树是满二叉树，需要遍历二叉树中的所有节点，时间复杂度是 O(n)。 对于节点 p，如果它的高度是 d，则 height(p) 最多会被调用 d 次（即遍历到它的每一个祖先节点时）。对于平均的情况，一棵树的高度 h 满足 O(h)=O(logn)，因为 d≤h，所以总时间复杂度为 O(nlogn)。
c++实现平衡二叉树管理的学生管理系统项目
07-02
1. 完成 学生, 课程,选课,成绩 的增删改查 学生ID 学生名 选课名 成绩 001 张三 C++ 60 002 张三 C++ 70 发布的数据量 有10w学生，1000课程,100w选课记录 文件存储(及时的存储) 查询 通过ID, 通过名字,允许同名(查询时间复杂度:对数阶) 统计选修"C++"课程的学生考试情况 学生ID 学生名 成绩 001 张三 70 002 李四 80 支持: 通过学生ID查询学生姓名 通过学生姓名查询学生ID 通过课程ID查询课程名 通过课程名查询课程ID 通过课程ID查询选修了该课程的学生以及成绩 通过学生ID查询该学生选修的课程信息 插入: 新增学生 新增课程 新增选课记录 删除: 删除学生 删除课程 删除选课记录 6. 不能使用三方的函数 评分标准： 1.采用平衡二叉树的可靠管理，源码规范，文档齐备：80分 2.采用动态数组的可靠管理，源码规范，文档齐备：60分
平衡二叉树时间复杂度计算1
08-08
平衡二叉树时间复杂度计算1
二叉树的应用---2.平衡二叉树
roothahh的博客
04-15 2290
（一）平衡二叉树的概念： 由于二叉搜索树的时间复杂度最好为O（logn），最差为O（n），因此有了AVL树，即平衡二叉树，其时间复杂度为O（logn），其定义为： 1.平衡因子：二叉树中某结点的右子树的高度和左子树的高度差为该结点的平衡因子 2.平衡二叉树满足（1）树中任一结点的平衡因子的绝对值不超过1（2）任一结点的左子树和右子树均是平衡二叉树 如图所示即为一个平衡二叉树： 如图是一个非二叉树： 由于二平衡二叉树是一种特殊的二叉搜索树，其查找操作与二叉搜索树类似，不再考虑； （二）平衡二叉树的插入
数据结构—平衡二叉树
且将&的博客
12-05 780
查询数据的时间复杂度、平衡二叉树
平衡二叉树ALVBinaryTreeList
jainszhang的博客
12-23 871
简介：本文介绍平衡二叉树基本概念，并通过继承AbstractBinaryTree抽象类，java实现ALVBinaryTreeList，主要操作算法有插入和删除。 一、平衡二叉树基本概念 1.平衡二叉树是什么？ 平衡二叉树时一种结构平衡的二叉树，即叶节点高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。 2.为什么会出现平衡二叉树？ 1）二叉树插入时存在最坏情况，导致查找的时间复杂度为O(n)。例如：顺序插入1，2，3，...，时，二叉树严重失衡，退化为普通链表，查找时间复杂.
平衡二叉树详解及java代码的实现
01-19
平衡二叉树（Balanced Binary Tree）又被称为AVL树（有别于AVL算法），且具有以下性质：它是一 棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树（递归定义）的二叉排序树。...
二叉树查找时间复杂度比较源码
06-17
二叉树查找时间复杂度比较，通过比较不同的排序方法的时间复杂度，比较各种排序方法的优缺点
平衡二叉树的左右旋以及双旋转的图文详解
08-26
今天小编就为大家分享一篇关于平衡二叉树的左右旋以及双旋转的图文详解，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧
数据结构七：线性表之链式栈的设计
最新发布
weixin_47040031的博客
04-27 611
从以上分析，我们可以知道链式栈只是单链表的一种特殊情况，限定了数据元素的插入和删除位置，链式栈是一种基于单链表实现的栈，在空间复杂度上，顺序栈在创建时就申请了数组空间，若栈经常处于不满状态将造成存储空间的浪费；链式栈所需空间是根据需要随时申请的，比之顺序栈仅仅是其每个结点需要额外的空间以存储其next指针域。在时间复杂度上，对于针对栈顶的基本操作（压入、弹出和栈顶元素存取），容易看出，顺序栈和链式栈的时间复杂性均为O(1)。
数据结构之栈
qq_74336191的博客
04-24 842
栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除操作。进入数据插入和删除操作的一端称为栈顶，另一端称为栈底。
【数据结构】冒泡排序
m0_74055118的博客
04-21 464
冒泡排序的平均和最坏时间复杂度都是 O(n^2)，其中 n 是数组的长度。这是因为它需要比较所有相邻元素对，并且在最坏的情况下，每个元素都需要移动到数组的另一端。不过，冒泡排序有一个优点，就是它是稳定的排序算法，即相等的元素在排序后保持它们的原始顺序。此外，如果在一轮比较中没有发生任何交换，冒泡排序可以提前终止，这提供了一种优化手段。算法的每一步都会比较相邻的两个元素，如果它们的顺序错误（即第一个元素比第二个元素大），则交换它们。这样，每经过一轮比较和交换，数组中最大的元素就会“冒泡”到数组的最后位置。
【数据结构6--图】
w384829981的博客
04-24 772
图（Graph）是一种数学结构，用于表示对象之间的关系。在图中，通常包含以下元素：一些简单的概念术语就不讨论了，例如:提醒一点下图是一个图还是4个图？（一个图，千万别说成四个图）(x,y)指由x点到y点，且无方向；也就是（x,y)=(y,x);指由x到y，但是有方向；也就是!=;什么是顶点？什么是边？什么是图？什么是子图？—就是从一个图中拿走一部分，这部分就是子图，隶属关系什么是有向图？—只要有一根线带方向就是有向图什么是完全有向图？
数据结构-查找
qq_48664605的博客
04-21 514
分块查找(索引顺序查找):分块查找（也称为索引查找）是一种在有序数组中进行查找的算法。在进行查找时，首先通过索引找到目标值可能所在的块，然后在对应的块中进行顺序查找。顺序查找(线性查找):顺序查找（Sequential Search）是一种简单的查找方法，它从列表的第一个元素开始，逐个比较元素与目标值的大小，直到找到目标值或遍历整个列表。查找的概念:根据数据存储的方式，查找操作可以分为两种主要类型：静态查找（Static Search）和动态查找（Dynamic Search）。
【高阶数据结构】B树 {B树的概念；B树的实现：节点设计，查找，插入，遍历，删除；B树的性能分析；B+树和B*树；B树的应用}
芥末虾的博客
04-24 800
【高阶数据结构】B树 {B树的概念；B树的实现：节点设计，查找，插入，遍历，删除；B树的性能分析；B+树和B*树；B树的应用}
二叉树的时间复杂度和空间复杂度
05-19
二叉树的时间复杂度和空间复杂度与具体的操作有关。 1. 插入操作：时间复杂度为O(log n)，其中n为二叉树的节点数。最坏情况下需要遍历整棵树，所以时间复杂度为O(n)。 2. 查找操作：时间复杂度为O(log n)，其中n为二叉树的节点数。最坏情况下需要遍历整棵树，所以时间复杂度为O(n)。 3. 删除操作：时间复杂度为O(log n)，其中n为二叉树的节点数。最坏情况下需要遍历整棵树，所以时间复杂度为O(n)。 4. 遍历操作：时间复杂度为O(n)，其中n为二叉树的节点数。因为每个节点都需要访问一次。 5. 空间复杂度：最坏情况下，二叉树的高度等于节点数，所以空间复杂度为O(n)。 需要注意的是，如果二叉树是平衡二叉树，插入、查找、删除等操作的时间复杂度会更快，为O(log n)。但是，如果二叉树退化成链表，时间复杂度就会退化为O(n)。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

锻炼²

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值