平衡二叉树

最新推荐文章于 2024-05-22 19:28:52 发布
最新推荐文章于 2024-05-22 19:28:52 发布
阅读量110 收藏
点赞数 1
文章标签： 数据结构 链表 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/EastFloatWater/article/details/119719169
版权

1.概念

  • 平衡二叉树的每个结点左右高度之差不超过1(定义)
  • 平衡二叉树是在二叉排序树的基础上实现的，如果是普通的树也能够实现平衡，但并没有什么作用。而在二叉排序树上实现平衡则能够减少检索量，提高二叉排序树的性能
  • 平衡二叉树是于二叉排序树的创建同步的，二叉排序树每创建一个结点则对二叉树进行平衡

2.实现步骤

在建立二叉排序树的过程中：

  1. 创建需要插入二叉排序树的结点

  2. 对二叉树进行二分查找，找到适合插入的位置插入;同时记录当前插入的点，记作Current_Node

  3. 对当前的二叉排序树，递归建立子树高度 Cal_Tree_High()

  4. 对当前的二叉树进行层次遍历，根据上一步的子树高度得到各个结点的平衡因子 Balance

  5. 查找当前二叉排序树的最小不平衡子树(建立三叉链表，根据当前结点Current_Node自底向上查找父节点)

  6. 找到最小不平衡子树的根节点时分四种情况讨论(每次操作针对的都是根节点) 👇👇👇

  7. 速记：左左 和右右都是反向下旋 左右和右左同向下旋

  8. 要注意的一个点是每种情况的根节点和对应的左/右孩子的Balance是确定的；四种情况实际上就是两种动作点坐下旋和点右下旋，注意选择好点就行
    1.插入的结点在根节点的左孩子的左子树(左左)
    A:2 B:1 -> A:0 B:0 ******A右下旋
    请添加图片描述

    2.插入的结点在根节点右孩子的右子树
    A:-2 B:-1 -> A:0 B:0 ******A左下旋请添加图片描述

    3.插入的结点在根节点左孩子的右子树

    **A:2 B:-1 C:1-> A:2 B:0 C:2 ->A:-1 B:0 C:0 ** ******B左下旋转 A右下旋
    请添加图片描述

    4.插入的结点在根节点的右孩子的左子树

    **A:-2 B:1 C:1-> A:-2 B:-1 C:-1 ->A:0 B:-1 C:0 ** ******B右下旋转 A左下旋请添加图片描述

3.代码

#pragma once
#include"LinkedStack.h"
#include"Queue.h"
class BstNode {
public:
	int data;
	int balance;//平衡因子
	int high;//当前结点(子树)的高度
	BstNode* lchild;
	BstNode* rchild;
	BstNode* parent;
	BstNode(int data) {
		this->data = data;
		this->balance = 0;
		this->high = 0;
		lchild = nullptr;
		rchild = nullptr;
		parent = nullptr;
	}
};
class BST {
private:
	BstNode *root;
	BstNode* Current_Node=nullptr;
public:
	BST(int* a, int length) {
		root = nullptr;
		BST_Create(a, length);
		int b = 0;
	};
	BstNode* GetRoot() {
		return this->root;
	}
	//搜索二叉排序树中的某个结点
	BstNode* BST_Search(BstNode* Node,int data) {
		if (Node == nullptr)return nullptr;
		if (data == Node->data)return Node;
		if (data < Node->data)
		{
			return BST_Search(Node->lchild, data);
		}
		if (data > Node->data) {
			return BST_Search(Node->rchild, data);
		}
		 
	};
	//在二叉排序树中插入值
	void BST_Insert(BstNode* &Node,BstNode* &parent, int data) {
		if (Node == nullptr) {
			Node = new BstNode(data);
			Node->parent = parent;
			Current_Node = Node;
			return;
		}
		Node->parent = parent;
		if (data == Node->data) {  return; }
		if (data < Node->data) {
			BST_Insert(Node->lchild, Node,data);
		}		
		if (data > Node->data) {
			BST_Insert(Node->rchild,Node, data);
		}
		
	};
	//递归计算各子树的高度
	int Cal_Tree_High(BstNode* Node) {
		if (Node == nullptr)return 0;
		if (Node->lchild == nullptr && Node->rchild == nullptr) {
			Node->high =1 ;
		}
		else  if (Node->lchild != nullptr && Node->rchild == nullptr) {
			Node->high = Cal_Tree_High(Node->lchild)+1;
		}
		else if (Node->lchild == nullptr && Node->rchild != nullptr) {
			Node->high = Cal_Tree_High(Node->rchild)+1;
		}
		else {
			Node->high = (Cal_Tree_High(Node->lchild)> Cal_Tree_High(Node->rchild)? Cal_Tree_High(Node->lchild): Cal_Tree_High(Node->rchild)) + 1;
		}
		return Node->high;
	}
	//层次遍历计算各结点的平衡因子
	void Cal_Balance(BstNode* Node) {
		Queue<BstNode*>* que = new Queue<BstNode*>();
		BstNode* Que_Head=nullptr;
		que->EnQueue(Node);
		while (!que->Empty()) {
			que->DeQueue(Que_Head);
			Que_Head->balance = (Que_Head->lchild == nullptr ? 0 : Que_Head->lchild->high) - (Que_Head->rchild == nullptr ? 0 : Que_Head->rchild->high);
			que->EnQueue(Que_Head->lchild);
			que->EnQueue(Que_Head->rchild);
		}
	}
	//平衡二叉树
	void BST_Balance(BstNode* Current_Node) {
		while (Current_Node->parent!=nullptr && abs(Current_Node->balance) < 2) {
			Current_Node = Current_Node->parent;
		}
		//左孩子的左右子树插入结点
		if(Current_Node->balance>1){
			//左孩子的左子树插入结点  LL
			if(Current_Node->lchild->balance==1){
				RD_Rotate(Current_Node);
				return;
			}
			//左孩子的右子树插入结点  LR
			if(Current_Node->lchild->balance==-1){
				LD_Rotate(Current_Node->lchild);
				RD_Rotate(Current_Node);
				return;
			}
		}
		//右孩子的左右子树插入结点
		else if(Current_Node->balance<-1){
			//右孩子的右子树插入结点
			if (Current_Node->rchild->balance == -1) {
				LD_Rotate(Current_Node);
				return;
			}
			//右孩子的左子树插入结点
			if (Current_Node->rchild->balance == 1) {
				RD_Rotate(Current_Node->rchild);
				LD_Rotate(Current_Node);
				return;
			}
		}
	
	}
	//左下旋,必是右孩子
	void LD_Rotate(BstNode* Node){
		BstNode* child = Node->rchild;
		Node->rchild = child->lchild;
		child->lchild = Node;
		child->balance = 0;
		Node->balance = 0;
		if (Node->parent == nullptr) { root = child; return; }
		if (Node->parent->lchild == Node) { Node->parent->lchild = child; }
		if (Node->parent->rchild == Node) { Node->parent->rchild = child; }
	}
	//右下旋,必是左孩子
	void RD_Rotate(BstNode* Node){
		BstNode* child = Node->lchild;
		Node->lchild = child->rchild;
		child->rchild = Node;
		child->balance = 0;
		Node->balance = 0;
		if (Node->parent == nullptr) { root = child; return; }
		if (Node->parent->lchild == Node) { Node->parent->lchild = child; }
		if (Node->parent->rchild == Node) { Node->parent->rchild = child; }

	}
	//使用数组创建二叉排序树
	void BST_Create(int*a,int length) {
		if (a == nullptr)return;
		BstNode* parent = nullptr;
		for (int i = 0; i < length; i++) {
			BST_Insert(root,parent,a[i]);
			Cal_Tree_High(root);
			Cal_Balance(root);
			BST_Balance(this->Current_Node);		
		}
		
	};
	//删除二叉排序树中的某个结点
	void BST_Delete(BstNode* Node,int data) {
		BstNode* current_node = BST_Search(Node, data);
		//被删除结点左右子树为空
		if (current_node->lchild == nullptr && current_node->rchild == nullptr) {
			//处理当前结点的父节点，让其指向nullprt
			if (current_node == current_node->parent->lchild)current_node->parent->lchild = nullptr;
			else if (current_node == current_node->parent->rchild)current_node->parent->rchild = nullptr;
			delete current_node;
			return;
		}
		//被删除结点左子树为空
		if (current_node->lchild==nullptr && current_node->rchild!=nullptr){
			if (current_node == current_node->parent->lchild) {
				current_node->parent->lchild = current_node->rchild;
				delete current_node;
			}
			else if (current_node == current_node->parent->rchild) {
				current_node->parent->rchild = current_node->rchild;
				delete current_node;
			}
			return;
		}
		//被删除结点右子树为空
		if (current_node->lchild != nullptr && current_node->rchild == nullptr) {
			if (current_node == current_node->parent->lchild) {
				current_node->parent->lchild = current_node->lchild;
				delete current_node;
			}
			else if (current_node == current_node->parent->rchild) {
				current_node->parent->rchild = current_node->lchild;
				delete current_node;
			}
			return;
		}
		//被删除结点左右子树都不为空
		if (current_node->lchild != nullptr && current_node->rchild != nullptr) {
			BstNode* After_Node = current_node->rchild;
			//找到被删除结点按顺序排列的下一个结点
			while (After_Node->lchild != nullptr) {
				After_Node = After_Node->lchild;
			}
			//记录下一结点的值
			int data = After_Node->data;
			//递归删除下一结点，继续用分三种情况分析
			BST_Delete(current_node, After_Node->data);
			current_node->data = data;
			return;
		}

		int a;
	};
	void BST_Foreach(BstNode* Node){
		if (Node == nullptr)return;
		BST_Foreach(Node->lchild);
		Visit(Node);
		BST_Foreach(Node->rchild);
	}
	void Visit(BstNode* Node) {
		std::cout << Node->data<<std::endl;
	}
};


-------main
#include <iostream>
#include"BST.h"
using namespace std;
int main()
{
	int a[] = {34,23,15,98,115,28,107};
	BST* tree = new BST(a,7);
	BstNode* root = tree->GetRoot();
	int b = 0;



}
等待freezeing
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
（十四）平衡二叉树
Apikaqiu的博客
05-31 248
基本介绍 平衡二叉树也叫平衡二叉搜索树（Self-balancing binary search tree）又被称为 AVL 树， 可以保证查询效率较高。 具有以下特点：它是一 棵空树或它的左右两个子树的高度差的绝对值不超过 1，并且左右两个子树都是一棵平衡二叉树。 ...
平衡二叉树的插入
weixin_36194037的博客
03-04 1万+
平衡二叉树的概念： 在学习二叉排序树的查找时，通过分析查找算法的效率可知，不同结构的二叉排序树查找效率有很大的不同，单支树的查找效率相当于顺序查找，而越趋于平衡的二叉排序树查找效率越高。因此，在二叉排序树的基础上引进了平衡二叉树。 所谓平衡二叉树是指它除了具备二叉排序树的基本特性之外，还具有一个非常重要的特点：它的左子树与右子树的深度之差（平衡因子）的绝对值不超过1，且都是平衡二叉树。二叉...
【数据结构】平衡二叉树的插入、删除
热门推荐
fxkcsdn的博客
08-14 3万+
目录 定义：什么叫平衡二叉树 定义及原理 不平衡的四种情况 旋转操作 插入节点 删除节点 定义：什么叫平衡二叉树 是二叉查找树的一个进化体，也是第一个引入平衡概念的二叉树。1962年，G.M. Adelson-Velsky 和 E.M. Landis发明了这棵树，所以它又叫AVL树。平衡二叉树要求对于每一个节点来说，它的左右子树的高度之差不能超过1，如果插入或者删除一...
平衡二叉树详解
weixin_43899008的博客
03-27 9110
一、平衡二叉树 平衡二叉搜索树又被称为AVL树，且具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。平衡二叉树的常用实现方法有红黑树、AVL等。 二、作用 我们有时在编程过程中可能会需要用到链表（时间复杂度O(n)）来进行对数据的存储，但是当数据量变得十分庞大时我们对于指定数据的一些操作的时间消耗就会变得大，这时我们就需要借助将链表的结构变为二叉搜索树（时间复杂度O(logn)）来进行数据的存储。 但在某些情况下，例如：对[1,2,3,4,5,6,…]
分步图解平衡二叉树的插入过程（Python实现）
Bebr的博客
06-19 1万+
一、基本概念： 平衡二叉树：是一种特殊的二叉排序树，它或者为空树，或者每个结点的左右子树都是平衡二叉树，也就是每个结点的左右子树的高度之差只能是-1,0,1三种情况。 平衡二叉树又称AVL树，是由苏联的Georgy Adelson-Velsky和E.M.Landis发明的，并以他们的名字命名。与之类似的还有红黑树、B树等。 平衡二叉树的平衡状况由平衡因子(Balance Factor,BF)...
c++实现平衡二叉树管理的学生管理系统项目
07-02
1. 完成 学生, 课程,选课,成绩 的增删改查 学生ID 学生名 选课名 成绩 001 张三 C++ 60 ...1.采用平衡二叉树的可靠管理，源码规范，文档齐备：80分 2.采用动态数组的可靠管理，源码规范，文档齐备：60分
平衡二叉树AVL操作模板
09-04
主要介绍了平衡二叉树AVL操作模板,需要的朋友可以参考下
Java—选择排序
qq_56725871的博客
05-22 254
它的基本思想是从待排序的数据中选择最小（或最大）的元素，放到已排序序列的末尾（或开头），然后再从剩余未排序的元素中选择最小（或最大）的元素，放到已排序序列的末尾（或开头），以此类推，直到全部元素排序完成。选择排序的时间复杂度为O(n^2)，其中n为待排序数组的长度。尽管选择排序的时间复杂度较高，但它简单易懂，适用于小规模数据的排序。对于大规模数据，更高效的排序算法如快速排序和归并排序更为常用。以上代码通过遍历整个数组，找到剩余未排序部分的最小值，并将其与当前位置的元素交换，重复这个过程直到数组排序完成。
刷题篇--数据结构--链表
hyldzbg的博客
05-18 442
如果我们有一个链表是1-->2-->3-->4-->5这样的，那我们反转后就是5-->4-->3-->2-->1这样的，那么要如果对链表操作呢？我们可以发现在反转后的链表里1-->2,变成2-->1那么我们就顺着这个思路，直接将下一个节点插到头节点前不就好了！！看起来好像不是很难，但是实现起来却很简单😉👌，嘿嘿！(^0^)我们可以再思考一下，将一个节点插到头节点前不就是头插嘛对不对，所以我们可以直接利用头插的方法来解决问题。
数据结构：二叉树---堆
Auroral_0218的博客
05-18 656
二叉树是一种特殊的树结构，其中每个节点最多有两个子节点。堆是一个完全二叉树：除了最后一层外，其他层节点个数都是满的，最后一层的节点都集中在左侧。堆中每个节点的值大于等于（或小于等于）其子节点的值，这个性质被称为堆序性。堆是一种特殊的数据结构，用于存储和管理一组元素。它的主要作用包括：1. 优先级队列：堆可以将元素按照一定的优先级进行排序，使得可以快速访问和操作优先级最高的元素。这在诸如调度算法、事件处理等场景中非常有用。2. 堆排序：堆排序是一种高效的排序算法，它利用堆的性质将元素快速排序。
二叉树——基础知识详解
2302_81016149的博客
05-22 1123
对于二叉树基础的理论知识，我们就学习到这里，虽然这些知识相对后面来说简单一点，但别忘记复习。有了这些预备知识才能够更好的理解后面知识。另外对于递归理解还不够的读者一定要去尽可能的去理解，对于二叉树的学习非常重要。今天的学习就结束了，有问题可在评论区交流，也可私信。我们下篇见！完！
数据结构——栈
2302_80339723的博客
05-15 338
1.我们可以定义一个结构体（ struct stack），其中有数组（SLDataType *a），栈顶元素的下标（top）和栈的空间（capacity）。通常为0.我们会将栈为空时状态定义为以下，但是如果将没有元素时top为0，这是top指向的就不是栈顶元素，而是栈顶元素的下一个元素。我们可以实现一个静态栈（数组的长度是一定），但是这种结构并不实用，我们接下来实现的是动态栈。如果不是左括号，就要判断栈是不是为空，若为空，直接返回false，不为空，再取栈顶元素与之比较。总体来说，实现一个栈还是很容易的。
质数和约数
2302_77099705的博客
05-21 1098
最大公约数（Greatest Common Divisor）指两个或多个整数共有约数中最大的一个。也称最大公因数、最大公因子，a， b的最大公约数记为（a，b），同样的，a，b，c的最大 公约数记为（a，b，c），多个 整数的最大公约数也有同样的记号。求最大公约数有多种 方法，常见的有 质因数分解法、 短除法、 辗转相除法、 更相减损法。
【算法】【二叉树，DFS，哈希集合，分类讨论】力扣1110. 删点成林
未来就在脚下。
05-20 880
本题通过DFS遍历二叉树，结合分类讨论的方法，逐步删除指定节点并生成新的森林。该算法有效地处理了节点删除后树结构的调整问题，并通过哈希集合优化删除判断的时间复杂度，最终实现了高效的解决方案。
算法刷题笔记 逆序对的数量（C++实现）
hanmo22357的博客
05-18 359
AcWing上的算法基础课题目 逆序对的数量 刷题笔记记录
【算法刷题day60】Leetcode：84. 柱状图中最大的矩形
qq_45022758的博客
05-21 328
暂无84. 柱状图中最大的矩形代码随想录解析。
第三十七天 | 860.柠檬水找零 406.根据身高重建队列 452.用最少数量的箭引爆气球
xxlyss的博客
05-18 333
其实你定义三个变量就好了呀，分别代表手上剩余的5，10，20面额纸币的张数，然后用for循环依次遍历bills，对三个变量进行运算，就可以模拟一次交易。当手上某一种纸币的数量不够找了，就false了。排序得到的结果：对于任意一个数据，它左边都是大于他的，右边都是小于他的。所以每一个元素前插，不会影响其他元素的 j 值，那就大胆前插，他的 j 是几就给他插到满意的位置。先将所有数据的身高（h）从大到小排序，使身高这个维度达到有序，然后再考虑前面有几个人的身高大于或者等于他。自己琢磨的七七八八了。
通过Wirtinger流进行相位恢复：理论与算法
最新发布
xy_optics的博客
05-22 847
Wirtinger流，包含通过谱方法初始化并使用类似梯度下降的新更新规则迭代地细化估计。这种方法承诺通过最少数量的随机测量实现精确的相位恢复，同时在计算和数据资源方面都具有高效性。传统方法，如Gerchberg-Saxton算法及其变体，通过迭代地应用投影，使频谱的幅度与观察数据匹配。这些方法依赖于关于信号的先验知识，并且缺乏理论上的收敛保证。Wirtinger流算法初始猜测zoz_ozo​是通过计算从测量数据构建的矩阵的主特征向量得到的。使用非凸目标函数的梯度迭代地细化zzz。
平衡二叉树完全二叉树
09-21
平衡二叉树和完全二叉树是两种不同的二叉树结构。 平衡二叉树是一种特殊的二叉搜索树，或者为空树，或者满足以下条件：它的左子树和右子树的深度之差（平衡因子）的绝对值不超过1，并且左子树和右子树都是一颗平衡二叉树。平衡二叉树的设计可以有效地解决二叉搜索树退化成链表的问题，同时保持了插入、查找和删除操作的平均时间复杂度为O(logN)。 而完全二叉树是一种特殊的二叉树结构，它除了最后一层可能不是满的外，其他层都是满的，而且最后一层的节点都集中在最左边。换句话说，深度为h的完全二叉树除了第h层外，其他各层的节点数都达到最大个数。完全二叉树具有高效的存储结构和查找性能。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值