树--平衡二叉树(AVL)

已于 2022-08-13 15:29:52 修改
阅读量76 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 数据结构
于 2022-08-07 16:36:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41587518/article/details/126208210
版权

平衡二叉树

  1. 概念
  2. 查找
  3. 插入
  4. 删除

1、概念

1.1 作用

        防止 二叉搜索树 退化为链表，性能下降( O(logn)-->O(n) )

1.2 特征

  • 树 为 二叉排序树
  • 每个节点的左右高度差不超过2
  • 二叉树的每个节点都处于平衡状态

1.3 定义

type AVLNode struct {
	Val    int			// 节点值
	Height int			// 节点高度
	Left   *AVLNode		// 左孩子
	Right  *AVLNode		// 右孩子
}

2、查找操作

        （与二叉搜索树相同）

// 查找元素
func (root *AVLNode) search(targer int) bool {
	if root == nil {
		return false
	}
	if root.Val > targer {
		return root.Left.search(targer)
	} else if root.Val < targer {
		return root.Right.search(targer)
	} else {
		return true
	}
}

3、插入操作

插入操作步骤：

  1. 找到对应位置插入 
  2. 根据 树高 判断是否 平衡 
  3. 若不平衡进行旋转操作

（引用：图解平衡二叉树平衡过程）

涉及函数：插入、获取树高、LL/RR/LR/RL

// 两者取最大
func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

// 获取当前节点的高度
func (root *AVLNode) getHeight() int {
	if root == nil {
		return 0
	}
	return max(root.Left.getHeight(), root.Right.getHeight()) + 1
}

// 左旋转 RR
func (root *AVLNode) leftRotate() *AVLNode {
	tmp := root.Right
	root.Right = tmp.Left
	tmp.Left = root
	root = tmp
	root.Height = root.getHeight()
	return root
}

// 右旋 LL
func (root *AVLNode) rightRotate() *AVLNode {
	tmp := root.Left
	root.Left = tmp.Right
	tmp.Right = root
	root = tmp
	root.Height = root.getHeight()
	return root
}

// 先左旋后右旋
func (root *AVLNode) LR_Rotate() *AVLNode {
	root.Left = root.Left.leftRotate() // 左孩子先旋转 变为LL模式，再右旋转
	return root.rightRotate()
}

// 先右旋后左旋
func (root *AVLNode) RL_Rotate() *AVLNode {
	root.Right = root.Right.rightRotate()
	return root.leftRotate()
}

// 检测是否平衡并恢复平衡
func (root *AVLNode) adjust() *AVLNode {
	if root.Left.getHeight()-root.Right.getHeight() == 2 {
		if root.Left.Left.getHeight() > root.Left.Right.getHeight() {
			root = root.rightRotate() // 左偏 右旋
		} else {
			root = root.LR_Rotate()
		}
	} else if root.Left.getHeight()-root.Right.getHeight() == -2 {
		if root.Right.Right.getHeight() > root.Right.Left.getHeight() {
			root = root.leftRotate()
		} else {
			root = root.RL_Rotate()
		}
	}

	return root
}

// 插入元素
func (root *AVLNode) insert(targer int) *AVLNode {
	if root == nil { // 找到该插入的位置
		return &AVLNode{
			Val: targer,
		}
	}
	if root.Val > targer {
		root.Left = root.Left.insert(targer)
	} else if root.Val < targer {
		root.Right = root.Right.insert(targer)
	} else {
		fmt.Println("值已存在")
	}

	// 从插入节点开始 会有个回溯的过程
	return root.adjust()

}

4、删除操作

删除操作步骤：

  1. 找到需要被删除的元素
  2. 有三种情况
    叶子节点：直接删除
    被删除的节点，只有左/右节点：父节点直接指向该节点的孩子节点
    被删除节点左右孩子都在：找孩子树的最小节点

  3. 检查并恢复平衡性

涉及函数：删除、获取树高、LL/RR/LR/RL、获取右子树最小节点/左子树最大节点顶替

// 获取当前节点最左边的孩子
func getMinNode(root *AVLNode) *AVLNode {
	for root.Left != nil {
		root = root.Left
	}
	return root
}

// 删除元素
func (root *AVLNode) delete(targer int) *AVLNode {
	if root == nil {
		return nil
	}

	if root.Val == targer {
		if root.Left == nil && root.Right == nil {
			return nil
		} else if root.Left == nil && root.Right != nil {
			root = root.Right
		} else if root.Left != nil && root.Right == nil {
			root = root.Left
		} else {
			minNode := getMinNode(root.Right)
			root.Val = minNode.Val
			root.Right = root.Right.delete(minNode.Val)
		}
	} else if root.Val > targer {
		root.Left = root.Left.delete(targer)
	} else {
		root.Right = root.Right.delete(targer)
	}

	return root.adjust()
}
↓↓↓↓↓↓↓************** 整体代码逻辑 **************↓↓↓↓↓↓↓ 
package main

import "fmt"

// 平衡二叉树的实现 (增删查)
type AVLNode struct {
	Val    int
	Height int
	Left   *AVLNode
	Right  *AVLNode
}

// 查找元素
func (root *AVLNode) search(targer int) bool {
	if root == nil {
		return false
	}
	if root.Val > targer {
		return root.Left.search(targer)
	} else if root.Val < targer {
		return root.Right.search(targer)
	} else {
		return true
	}
}

// 两者取最大
func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

// 获取当前节点的高度
func (root *AVLNode) getHeight() int {
	if root == nil {
		return 0
	}
	return max(root.Left.getHeight(), root.Right.getHeight()) + 1
}

// 左旋转 RR
func (root *AVLNode) leftRotate() *AVLNode {
	tmp := root.Right
	root.Right = tmp.Left
	tmp.Left = root
	root = tmp
	root.Height = root.getHeight()
	return root
}

// 右旋 LL
func (root *AVLNode) rightRotate() *AVLNode {
	tmp := root.Left
	root.Left = tmp.Right
	tmp.Right = root
	root = tmp
	root.Height = root.getHeight()
	return root
}

// 先左旋后右旋
func (root *AVLNode) LR_Rotate() *AVLNode {
	root.Left = root.Left.leftRotate() // 左孩子先旋转 变为LL模式，再右旋转
	return root.rightRotate()
}

// 先右旋后左旋
func (root *AVLNode) RL_Rotate() *AVLNode {
	root.Right = root.Right.rightRotate()
	return root.leftRotate()
}

// 检测是否平衡并恢复平衡
func (root *AVLNode) adjust() *AVLNode {
	if root.Left.getHeight()-root.Right.getHeight() == 2 {
		if root.Left.Left.getHeight() > root.Left.Right.getHeight() {
			root = root.rightRotate() // 左偏 右旋
		} else {
			root = root.LR_Rotate()
		}
	} else if root.Left.getHeight()-root.Right.getHeight() == -2 {
		if root.Right.Right.getHeight() > root.Right.Left.getHeight() {
			root = root.leftRotate()
		} else {
			root = root.RL_Rotate()
		}
	}

	return root
}

// 插入元素
func (root *AVLNode) insert(targer int) *AVLNode {
	if root == nil { // 找到该插入的位置
		return &AVLNode{
			Val: targer,
		}
	}
	if root.Val > targer {
		root.Left = root.Left.insert(targer)
	} else if root.Val < targer {
		root.Right = root.Right.insert(targer)
	} else {
		fmt.Println("值已存在")
	}

	// 从插入节点开始 会有个回溯的过程
	return root.adjust()

}

// 获取当前节点最左边的孩子
func getMinNode(root *AVLNode) *AVLNode {
	for root.Left != nil {
		root = root.Left
	}
	return root
}

// 删除元素
func (root *AVLNode) delete(targer int) *AVLNode {
	if root == nil {
		return nil
	}

	if root.Val == targer {
		if root.Left == nil && root.Right == nil {
			return nil
		} else if root.Left == nil && root.Right != nil {
			root = root.Right
		} else if root.Left != nil && root.Right == nil {
			root = root.Left
		} else {
			minNode := getMinNode(root.Right)
			root.Val = minNode.Val
			root.Right = root.Right.delete(minNode.Val)
		}
	} else if root.Val > targer {
		root.Left = root.Left.delete(targer)
	} else {
		root.Right = root.Right.delete(targer)
	}

	return root.adjust()
}

// 中序遍历，二叉搜索树的顺序性
// 之所以递归调用插入值，是因为后面有一个回溯判断节点是否平衡的过程
func (root *AVLNode) traversal() { // 中序遍历
	if root == nil {
		return
	}
	// 先打印左子树
	root.Left.traversal()
	// 再打印根节点
	if root.Left != nil && root.Right != nil {
		fmt.Printf("root=%v\t root.left=%v\t root.right=%v\n", root.Val, root.Left.Val, root.Right.Val)
	} else if root.Left != nil && root.Right == nil {
		fmt.Printf("root=%v\t root.left=%v\t root.right=nil\n", root.Val, root.Left.Val)
	} else if root.Left == nil && root.Right != nil {
		fmt.Printf("root=%v\t root.left=nil\t root.right=%v\n", root.Val, root.Right.Val)
	} else {
		fmt.Printf("root=%v\t root.left=nil\t root.right=nil\n", root.Val)
	}
	// 再打印右子树
	root.Right.traversal()

}

// 测试数据
var append_list = []int{2, 3, 5, 6, 10, 17, 4}
var remove_list = []int{5, 1}

func main() {
	treeNode := &AVLNode{
		Left:   nil,
		Right:  nil,
		Height: 0,
		Val:    1,
	}
	// 循环添加元素
	for i := 0; i < len(append_list); i++ {
		treeNode = treeNode.insert(append_list[i])
	}

	treeNode.traversal()
	fmt.Println()
	//循环删除元素
	for i := 0; i < len(remove_list); i++ {
		treeNode = treeNode.delete(remove_list[i])
	}
	treeNode.traversal()

}

输出结果

root=1   root.left=nil   root.right=nil
root=2   root.left=1     root.right=3
root=3   root.left=nil   root.right=4
root=4   root.left=nil   root.right=nil
root=5   root.left=2     root.right=10
root=6   root.left=nil   root.right=nil
root=10  root.left=6     root.right=17
root=17  root.left=nil   root.right=nil

------------------------------------------------------

root=2   root.left=nil   root.right=nil
root=3   root.left=2     root.right=4
root=4   root.left=nil   root.right=nil
root=6   root.left=3     root.right=10
root=10  root.left=nil   root.right=17
root=17  root.left=nil   root.right=nil

JanNinth
关注
专栏目录
红黑树 -- 平衡二叉树
知性人 -- 的博客
07-22 280
  平衡二叉搜索树（Self-balancing binary search tree）又被称为AVL树（有别于AVL算法），且具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。平衡二叉树的常用实现方法有红黑树、AVL、替罪羊树、Treap、伸展树等。 二叉树   二叉树是每个节点最多有两个子树的树结构，如下图：   二叉树有五种基本形态：...
数据结构-----平衡二叉树
m0_73633088的博客
10-02 6208
前面去构建一个二叉排序树，非常简单，只需要排序就行了，那构建一个平衡二叉树不仅仅要考虑到排序问题，还要考虑到左右子树高度不大于1才行，下面我介绍一种通过旋转的方法来去构建平衡二叉树。
数据结构 --- AVL平衡二叉树基础
weixin_60569662的博客
03-02 498
平衡二叉树和普通二叉搜索树的区别 如果数据是有序的，创建出来的二叉搜索树会出现不平衡的现象(是单边的)，单边的情况，和数组的查找速度一样，效率不高，二叉搜索树最坏的情况：4-7-8-9-10，为了提高查找效率，对二叉搜索树做一个调整，调整为平衡的 AVL树是根据它的发明者G.M. Adelson-Velsky和E.M. Landis命名的。 它是最先发明的自平衡二叉查找树，也被称为高度平衡树。 相比于"二叉查找树"，它的特点是： AVL树中任何节点的两个子树的高度最大差别为1 平衡二叉树节
数据结构-AVL树（平衡二叉树）
m0_61433144的博客
08-11 1048
规定在插入和删除二叉搜索树的结点时，要保证任意结点的左右子树高度差的绝对值不超过1，我们将这样特殊的二叉搜索树称为AVL树（平衡二叉树）。每一个结点中有记录其左右子树高度差的平衡因子，也即平衡因子的值只可能是-1,0,1。（1如果某结点的左子树高度比右子树高度高一则平衡因子为-1，如果某结点的左子树高度比右子树高度低一则平衡因子为1，如果某结点的左子树高度与右子树高度一样则平衡因子为0）。............
数据结构与算法基础-学习-21-查找之平衡二叉树（AVL树）
qq_45111959的博客
04-24 1595
本文主要介绍如下内容： 一、个人理解 二、最小失衡子树 三、平衡调整的四种类型 1、LL型 2、RR型 3、LR型 4、RL型 四、如何平衡调整 1、LL型调整 2、LR型调整 五、宏定义 六、结构体类型定义 1、AVL树结点类型 2、AVL树类型 3、AVL树结点搜索路径类型 七、函数定义 八、Linux环境测试LL型
数据结构树--＞平衡二叉树
路漫漫其修远兮
08-12 1009
平衡二叉树 平衡二叉树又叫 AVL树 前面我们介绍了二叉查找树，二叉平衡树是二叉查找树的一种，为什么会有二叉平衡树呢？这时因为二叉查找树的排序引起的，看下图。 这也是一个二叉查找树，但因为数据的原因这个二叉查找树基本成了链式结构，无法达到二叉查找树的快速查找能力，这就引入了平衡二叉树。 平衡二叉树在二叉查找树的基础上添加了平衡因子。 1. 平衡因子 平衡因子：二叉树所有节点左子树高度与右子树的高度差值的绝对值不能大于1。 只有满足这个平衡因子的二叉查找树就是一颗合格的平衡二叉树。 如图就是一个合格的平衡
详解AVL树（平衡二叉树）
热门推荐
水澹澹兮生烟
09-20 2万+
插入节点后对树进行旋转调整，分为四种情况。 1.右单旋 当一个平衡二叉树满足具有较高左子树时（如下图A），且要插入的节点插入到了较高左子树的左侧，此时进行右单旋。
平衡二叉树（AVL树）
Xpccccc的博客
03-27 1458
平衡二叉树（AVL树）
数据结构与算法 ---- 平衡二叉树（AVL树）
qq_41877840的博客
08-05 650
平衡二叉树，又称为 AVL 树。实际上就是遵循以下两个特点的二叉树： ①每棵子树中的左子树和右子树的深度差不能超过 1； ②二叉树中每棵子树都要求是平衡二叉树； 其实就是在二叉树的基础上，若树中每棵子树都满足其左子树和右子树的深度差都不超过 1，则这棵二叉树就是平衡二叉树。 平衡因子：每个结点都有其各自的平衡因子，表示的就是其左子树深度同右子树深度的差。平衡二叉树中各结点平衡因子的取值只可能是：0、1 和 -1。 如图 1 所示，其中 （a） 的两棵二叉树中由于各个结点的平衡因子数的绝对值都不超过 1.
《剑指Offer》刷题笔记——面试题55-II. 平衡二叉树
12-22
《剑指Offer》是针对程序员面试的一本经典书籍，其中的面试题55-II主要讨论的是平衡二叉树。平衡二叉树是一种特殊的二叉树结构，它的左右两个子树的高度差不超过1，并且左右两个子树都是一棵平衡二叉树。平衡二叉树...
js代码-200609-平衡二叉树
07-16
在JavaScript中实现平衡二叉树，我们可以选择AVL树或红黑树等经典的数据结构。 在`main.js`文件中，我们可能看到了平衡二叉树的JavaScript实现。通常，平衡二叉树的实现会包括以下几个关键部分： 1. **节点定义**...
算法-理论基础- 查找- 平衡二叉树（包含源程序）.rar
09-16
平衡二叉树的主要类型包括AVL树和红黑树。AVL树是最早提出的自平衡二叉查找树，由G. M. Adelson-Velsky 和 E. M. Landis 于1962年提出，因此得名AVL。AVL树的特点是任意节点的两个子树高度差不超过1，这样确保了树的...
【二叉树进阶】AVLTree - 平衡二叉搜索树
codewinter的博客
06-20 2739
二叉搜索树的插入和删除操作都必须先查找，查找效率代表了二叉搜索树中各个操作的效率。但是二叉搜索树有其自身的缺陷，假如往树中插入的元素有序或者接近有序，二叉搜索树就会退化成单支树，时间复杂度为O(N)，因此 map、set 等关联式容器的底层结构是对二叉树进行了平衡处理，即采用平衡二叉搜索树来实现。最优情况下，有 n 个结点的二叉搜索树为完全二叉树，查找效率为：O(log2N)最差情况下，有 n 个结点的二叉搜索树退化为单支树，查找效率为：O(N)平衡二叉搜索树（Self-balancing binary s
数据结构编程实践20讲(Python版)—14邻接矩阵
AnFany
10-16 1232
数据结构编程实践20讲(Python版)—14邻接矩阵
数据结构(8.1)——排序的基本概念
最新发布
m0_65240792的博客
10-16 263
排序的定义 排序算法的评价指标 排序算法的分类 总结：
《C++中栈的实现：探索高效数据结构》
xy520521的博客
10-13 576
当向栈中添加元素时，创建一个新的节点，将其数据设置为要添加的元素，并将其指向下一个节点设置为当前的栈顶节点，然后将栈顶指针指向新节点。当从栈中删除元素时，将栈顶指针指向当前栈顶节点的下一个节点，并释放原来栈顶节点的内存。首先，数组的大小是固定的，一旦栈的大小超过了数组的容量，就需要进行复杂的扩容操作。其次，数组实现的栈在内存中的分配是连续的，可能会导致内存碎片的问题。此外，链表实现的栈在内存中的分配是不连续的，不会产生内存碎片。但是，链表实现的栈在进行插入和删除操作时需要进行指针的操作，相对来说比较复杂。
数据结构——广义表
2302_80420838的博客
10-16 188
注：广义表的元素既可以是一个元素（原子），也可以又是一个表（子表），（）为原子是空元素，（（））为子表是一个无元素的表。
【AcWing】算法基础课-数据结构
2301_80277275的博客
10-16 952
AcWing算法基础课---数据结构笔记
数据结构常考基础代码题-数组倒置
qq_52291558的博客
10-16 452
根据题目中的“将数组中的元素顺序反转”，我们需要实现一个函数Reverse，用于反转数组中从start到end的元素。// 函数用于反转数组A中从start到end的元素int temp;// 使用while循环进行元素交换，直到start和end相遇或交叉// 保存A[start]的值// 将A[end]的值赋给A[start]// 将temp（原A[start]的值）赋给A[end]start++;// 移动start指针end--;// 移动end指针。
平衡二叉树的构造c语言,数据结构之---C语言实现平衡二叉树（AVL树）
06-02
下面是C语言实现平衡二叉树（AVL树）的代码： ``` #include #include /* 定义平衡二叉树节点结构体 */ struct AVLNode { int data; // 存储的数据 int height; // 节点高度 struct AVLNode *leftChild; // 左...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值