js实现自平衡树 AVL tree

最新推荐文章于 2022-07-26 11:14:51 发布
最新推荐文章于 2022-07-26 11:14:51 发布
阅读量448 收藏
点赞数
文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/nidaye666666/article/details/104516130
版权
本文介绍了JavaScript实现AVL树的过程，包括插入和删除节点的特殊情况。在插入节点后，通过检查节点的平衡因子来判断是否需要进行平衡操作，如单旋转（LL, RR）和双旋转（RL, LR）。在删除节点时，根据节点的平衡因子和子节点情况决定是否进行旋转以保持平衡。文章提供了相关的代码示例，详细解释了自平衡树的平衡调整策略。" 86384877,7610454,Python+unittest+requests接口自动化测试实践与问题解析,"['Python编程', '测试工具', '自动化测试', '接口测试', 'unittest框架']

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

AVL tree

1. 笔记

节点高度：Math.max(左节点高度, 右节点高度)+1
平衡因子：左节点高度 - 右节点高度，节点内数字表示当前节点的平衡因子。
平衡操作共有四种情况。
1. 向右的单旋转 LL: 当前节点的左节点比右节点重，当前节点的左节点的左节点比右节点重。
在这里插入图片描述
2. 向左的单旋转 RR: 当前节点的右节点比左节点重，当前节点的右节点的右节点比左节点重。
3. 向左的双旋转 RL: 当前节点的右节点比左节点重，当前节点的右节点的左节点比右节点重。
先对 当前节点的右节点 进行一次向右的单旋转，在对当前节点进行向左的单旋转。
4. 向右的双旋转 LR: 当前节点的左节点比右节点重，当前节点的左节点的右节点比左节点重。
先对 当前节点的左节点 进行一次向左的单旋转，在对当前节点进行向右的单旋转。
在这里插入图片描述
基于二叉搜索树的insert方法，AVL与之不同的则是，在每次插入后，我们需要检测插入后根节点的平衡因子，是否为0 1 -1三个数的其中一个。不是的话，则需要对当前树进行调整。
表格中数字是节点的平衡因子

根节点根的左子节点根的右子节点操作描述
1---平衡
0---平衡
-1---平衡
21平衡向右的单旋转LL
20平衡向右的单旋转LL
2-1平衡向右的双旋转LR
-2平衡1向左的双旋转RL
-2平衡-1向左的单旋转RR
-2平衡0向左的单旋转RR

insertNode

insert(value) {
	super.insert(value)
	return this.checkIsBalance()
}

removeNode

remove(value) {
	super.remove(value)
	return this.checkIsBalance()
}

checkIsBalance

checkIsBalance() {
	this.root = this._changeToBalance(this.root)
	return this
}

插入节点的特殊情况

为下图的左边的树，添加一个节点，使其不平衡。但我们发现，此时平衡因子所属情况与之前所描述的不同。此时我们需要进行递归，先对根节点的左节点进行平衡操作LL，完成后在对根节点进行平衡操作。这是根节点的平衡因子等于2的情况。当然等于-2的情况与之原理相同。
在这里插入图片描述
连续插入左节点，在自平衡过程中，会报错，因为this.root.left.right为null。故在LL和RR使用try catch语句，处理异常。右节点：this.root.right为null，高度为-1。
在这里插入图片描述
在右侧插入节点(红色)，导致原树不平衡。只需做一次向左的单旋转RR，即可平衡。插入左侧节点时，原理一致。
在这里插入图片描述

删除节点的特殊情况

我们在看另外一种情况，下图删除了一个节点。左树平衡，右树不平衡。但根节点(平衡因子)为2，左子节点为0，右子节点平衡的情况之前没有讨论过。我们可以直接对其进行一次向右的单旋转即可平衡。当然，根节点为2，左子节点平衡，右子节点为0的情况与之原理相同。
在这里插入图片描述
在这里插入图片描述
_changeToBalance

_changeToBalance(node) {
     switch(this.getBalanceFactory(node)){
        case 2:
            const factoryLeft = this.getBalanceFactory(node.left)
            if([0,1].indexOf(factoryLeft) !== -1 || factoryLeft > 2){
                console.info('2 0 1')
                node = this.rotationLL(node)
            }else if(factoryLeft === -1){
                console.info('2 -1')
                node = this.rotationLR(node)
            }else if(factoryLeft === 2){
                console.info('2 2')
                node.left = this._changeToBalance(node.left)
            }else if(factoryLeft === -2){
                console.info('2 -2')
                node.left = this._changeToBalance(node.left)
            }
            return node
        case -2:
            const factoryRight = this.getBalanceFactory(node.right)
            if([0,1].indexOf(factoryRight) !== -1){
                console.info('-2 0 1')
                node = this.rotationRL(node)
            }else if(factoryRight === -1 || factoryRight < -2){
                console.info('-2 -1')
                node = this.rotationRR(node)
            }else if(factoryRight === 2){
                console.info('-2 2')
                node.right = this._changeToBalance(node.right)
            }else if(factoryRight === -2){
                console.info('-2 -2')
                node.right = this._changeToBalance(node.right)
                console.info(node.right)
            }
            return node
    }
	return node
}

2. 所有代码

2.1 自平衡树

class AVL extends BinarySearchTree {
    constructor(superConstructor) {
        super(superConstructor)
    }
    _getNodeHeight(node) {
        if(node === null){
            return -1
        }
        return Math.max(this._getNodeHeight(node.left), this._getNodeHeight(node.right))+1
    }
    getNodeHeight(node=this.root) {
        return this._getNodeHeight(node)
    }
    getBalanceFactory(node) {
        const factory = this.getNodeHeight(node.left) - this.getNodeHeight(node.right)
        return factory
    }
    // 向右单旋转
    rotationLL(node) {
        const tar = node.left
        try{
            node.left = tar.right
        }catch{
            node.left = null
        }
        tar.right = node
        return tar
    }
    // 向左单旋转
    rotationRR(node) {
        const tar = node.right
        try{
            node.right = tar.left
        }catch{
            node.right = null
        }
        tar.left = node
        return tar
    }
    // 向右双旋转
    rotationRL(node) {
        node.right = this.rotationLL(node.right)
        return this.rotationRR(node)
    }
    // 向左双旋转
    rotationLR(node) {
        node.left = this.rotationRR(node.left)
        return this.rotationLL(node)
    }
    _changeToBalance(node) {
        switch(this.getBalanceFactory(node)){
	        case 2:
	            const factoryLeft = this.getBalanceFactory(node.left)
	            if([0,1].indexOf(factoryLeft) !== -1 || factoryLeft > 2){
	                console.info('2 0 1')
	                node = this.rotationLL(node)
	            }else if(factoryLeft === -1){
	                console.info('2 -1')
	                node = this.rotationLR(node)
	            }else if(factoryLeft === 2){
	                console.info('2 2')
	                node.left = this._changeToBalance(node.left)
	            }else if(factoryLeft === -2){
	                console.info('2 -2')
	                node.left = this._changeToBalance(node.left)
	            }
	            return node
	        case -2:
	            const factoryRight = this.getBalanceFactory(node.right)
	            if([0,1].indexOf(factoryRight) !== -1){
	                console.info('-2 0 1')
	                node = this.rotationRL(node)
	            }else if(factoryRight === -1 || factoryRight < -2){
	                console.info('-2 -1')
	                node = this.rotationRR(node)
	            }else if(factoryRight === 2){
	                console.info('-2 2')
	                node.right = this._changeToBalance(node.right)
	            }else if(factoryRight === -2){
	                console.info('-2 -2')
	                node.right = this._changeToBalance(node.right)
	                console.info(node.right)
	            }
	            return node
	    }
        return node
    }
    checkIsBalance() {
        this.root = this._changeToBalance(this.root)
        return this
    }
    insert(value) {
        super.insert(value)
        return this.checkIsBalance()
    }
    remove(value) {
        super.remove(value)
        return this.checkIsBalance()
    }
}

2.2 二叉搜索树

class Node {
	constructor(value) {
		this.value = value
		this.left = null
		this.right = null
	}
}
class BinarySearchTree {
    constructor(value) {
        this.root = new Node(value)
    }
    _insertNode(node, value) {
        if(node.value > value){
            if(node.left === null){
                node.left = new Node(value)
            }else{
                this._insertNode(node.left, value)
            }
        }else{
            if(node.right === null){
                node.right = new Node(value)
            }else{
                this._insertNode(node.right, value)
            }
        }
    }
    insert(value) {
        if(this.root === null) {
            this.root = new Node(value)
        }else{
            this._insertNode(this.root, value)
        }
        return this
    }
    // 中序遍历: 左 -> 中 -> 右
    _inOrderTra(node, res) {
        if(node === null) { return }
        this._inOrderTra(node.left, res)
        res.push(node.value)
        this._inOrderTra(node.right, res)
    }
    inOrderTra() {
        let res = []
        this._inOrderTra(this.root, res)
        return res
    }
    // 前序遍历: 中 -> 左 -> 右
    _preOrderTra(node, res) {
        if(node === null) { return }
        res.push(node.value)
        this._preOrderTra(node.left, res)
        this._preOrderTra(node.right, res)
    }
    preOrderTra() {
        let res = []
        this._preOrderTra(this.root, res)
        return res
    }
    // 后序遍历: 左 -> 右 -> 中
    _postOrderTra(node, res) {
        if(node === null) { return }
        this._postOrderTra(node.left, res)
        this._postOrderTra(node.right, res)
        res.push(node.value)
    }
    postOrderTra() {
        let res = []
        this._postOrderTra(this.root, res)
        return res
    }
    _getMin(node) { 
        if(node.left === null){ return node }
        return this._getMin(node.left) 
    }
    getMin() {
        return this._getMin(this.root)
    }
    _getMax(node) { 
        if(node.right === null){ return node }
        return this._getMax(node.right) 
    }
    getMax() {
        return this._getMax(this.root)
    }
    _search(node, value) {
        if(node.value > value) {
            if(node.left === null) {
                throw 'Function Search: ' + value + ' 未找到'
            }else if(node.left.value === value) {
                return node.left
            }else {
                return this._search(node.left, value)
            }
        }else {
            if(node.right === null) {
                throw 'Function Search: ' + value + ' 未找到'
            }else if(node.right.value === value) {
                return node.right
            }else {
                return this._search(node.right, value)
            }
        }
    }
    search(value) {
        if(value === this.root.value){
            return this.root
        }
        return this._search(this.root, value)
    }
    _removeNode(target, node=this.root) {
        // 寻找删除节点的父节点
        if(node.left !== target && node.right !== target){
            if(node.value > target.value){
                return this._removeNode(target, node.left)
            }else{
                return this._removeNode(target, node.right)
            }
        }
        if(target.left === null && target.right === null){
            // 删除的节点无子节点
            return node.left === target ? node.left = null : node.right = null
        }else if(target.left === null || target.right === null){
            // 删除的节点只包含一个子节点
            const son = target.left === null ? target.right : target.left
            return node.left === target ? node.left = son : node.right = son
        }else if(target.left !== null && target.right !== null){
            // 删除的节点包含两个子节点
            const displace = this._getMin(target.right)
            return node.left === target ? node.left = displace : node.right = displace
        }
    }
    remove(value) {
        const target = this.search(value)
        if(target === this.root){
            throw 'Function remove: 不能删除根节点'
        }
        this._removeNode(target)
        return this
    }
}
WangKai_Code
关注
Javascript之数据结构与算法的自平衡二叉搜索树（AVL）实现
wushichao0325的博客
01-09 369
Javascript之数据结构与算法的自平衡二叉搜索树（AVL）实现简介代码实现 简介 AVL树是一种自平衡树。添加或移除节点时， AVL树会尝试自平衡。任意一个节点（不论深 度）的左子树和右子树高度最多相差1。添加或移除节点时， AVL树会尽可能尝试转换为完全树。 平衡因子是在AVL树中，需要对每个节点计算右子树高度（ hr）和左子树高度（ hl）的差值，该值（ hr－ hl）应为0、1或-1。...
数据结构 js 实现avl平衡树
qq_36723759的博客
05-25 357
/** * 平衡二叉搜索树 avl */ let alert = console.log; // console.log = () => {}; class TreeNode { constructor(value, leftNode, rightNode) { this.value = value; this.leftNode = leftNode; this.rightNode = rightNode; } } /** * 1、创建 create(){}
AVL树算法的动态演示的设计与实现.pdf
04-03
《数据结构》 是计算机学科中一门十分重要的核心课程， 而对于算法的理解则是学好该课程的关键。为了使学生更好的理解算法， 作为对课堂教学的有益补充， 我们设计开发了 《AVL树算法的动态演示》 ， 以帮助学生理解数据结构算法。本文通过对这种交互式动态演示的设计实现过程的详细描述， 着重讨论了 AVL树动态演示的算法实现。
用js来实现那些数据结构14（树02-AVL树）
weixin_33816611的博客
05-04 190
　　在使用二叉搜索树的时候会出现 一个问题，就是树的一条分支会有很多层，而其他的分支却只有几层，就像下面这样： 　　如果数据量够大，那么我们在某条边上进行增删改查的操作时，就会消耗大量的时间。我们花费精力去构造一个可以提高效率的结构，反而事与愿违。这不是我们想要的。所以，我们需要另外一种树来解决这样的问题，那就是自平衡二叉搜索树--Adelson-Ve...
JS 实现自平衡二叉查找树（AVL树）
三月的船长
09-16 391
该树的代码基本上是从我上篇文章 JS 实现二叉查找树 加入平衡因子，高度，旋转等 AVL 树的概念升级而来，写的过程中发现，思想就一个递归，细节就是递归处理操作的时候严不严谨，难点就是概念的理解的准不准确。
binary-search-tree:javascript中的二进制搜索树和AVL树（自平衡树）实现
04-28
javascript中的二进制搜索树和AVL树（自平衡树）实现。 二进制搜索树 AVL树（自平衡树） 目录 .min（） 。最大限度（） .lowerBound（k） .upperBound（k） 。根（） 。数数（） .traverseInOrder（cb） ...
BinaryTree:实现自平衡二叉树
05-03
在本话题中，我们将探讨如何使用JavaScript来实现自平衡二叉树，特别是AVL树和红黑树这两种常见的自平衡二叉树。 首先，让我们了解一下二叉搜索树的基本概念。二叉搜索树（BST）是一种二叉树，其中每个节点都具有...
AutoJs源码解析：深入理解AvlTree平衡树结构
AvlTree（平衡树）是一种自平衡的二叉搜索树，由Adelson-Velsky和Landis发明，简称AVL树。它在每个节点的左子树和右子树的高度最多相差1，这样可以保证最坏情况下查找、插入和删除操作的时间复杂度为O(log n)。 接...
binary-search-tree:使用 HTML、CSS 和 JS 创建的 BST 和 AVL 平衡
07-24
AVL 树是一种自平衡二叉搜索树，它通过保持左右子树的高度差不超过 1 来确保高效的查找性能。在项目中，AVL 树的平衡可能通过旋转操作（左旋和右旋）来实现。当插入或删除节点导致树不平衡时，JavaScript 程序会检测...
Interval-Tree:间隔树 ADT 的 javascript 实现
07-02
###Interval Tree：这个想法是增加一个自平衡二叉搜索树 (BST)，如红黑树、AVL 树等，以维护一组间隔，以便所有操作都可以在 O(Logn) 时间内完成。 Interval Tree 的每个节点都存储了以下信息。 a) i：表示为一对 ...
【LeetCode】110. 平衡二叉树（js 实现）
在热爱技术的路上一直前行。
05-11 486
1、题目 110. 平衡二叉树 - 力扣（LeetCode） 2、实现 （1）思路 使用深度优先遍历方式计算二叉树的最大深度； 再根据平衡树的概念，去计算左子树和右子树深度的差值，进而返回对应的false和true结果。 （2）代码1 /** * Definition for a binary tree node. * function TreeNode(val, left, right) { * this.val = (val===undefined ? 0 : val)
AVL树 算法思想与代码实现
weixin_30666753的博客
07-07 158
AVL树是高度平衡的二叉搜索树，按照二叉搜索树（Binary Search Tree）的性质，AVL首先要满足： 若它的左子树不为空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不为空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉搜索树。 AVL树的性质： 左子树和右子树的高度之差的绝对值不超过1 树中的每个左子树和右子树都是AVL树...
JS数据结构5：树-自平衡二叉树
斜光的博客
06-01 452
概念 BST 存在一个问题： 取决于你添加的节点数，树的一条边可能会非常深； 也就是说，树的一条分支会有很多层，而其他的分支却只有几层， 这会造成很大的性能问题 所以需要平衡二叉搜索树来解决这个问题 平衡二叉树的概念 在AVL 树中，需要对每个节点计算右子树高度（hr）和左子树高度（hl）之间的差值，该值（hr－hl）应为0、1 或 -1。 如果结果不是这三个值之一，则需要平衡该AVL 树。 这就是平衡因子的概念。 AVL的实现 我们可以扩展我们写的BST 类，只需要覆盖用来维持AVL 树平衡的方
js数据结构——平衡查找树
lay136362687的博客
08-07 426
2-3查找树 插入原理图 红黑二叉查找树 与2-3查找树的联系 将树中的链接分为两种类型，红链接将两个2-结点连接起来构成一个3-结点，黑色则是普通链接。 定义： 1. 红链接均为左链接 2. 没有任何一个结点同时和两条红链接相连 3. 该树是完美黑色平衡的，即任意空链接到根节点的路径上的黑链接数量相同。 该定义与的红黑树与相应的2-3树为一一对应 ...
【从蛋壳到满天飞】JS 数据结构解析和算法实现-AVL树（一）
weixin_34029680的博客
03-21 173
前言 【从蛋壳到满天飞】JS 数据结构解析和算法实现，全部文章大概的内容如下： Arrays(数组)、Stacks(栈)、Queues(队列)、LinkedList(链表)、Recursion(递归思想)、BinarySearchTree(二分搜索树)、Set(集合)、Map(映射)、Heap(堆)、PriorityQueue(优先队列)、SegmentTree(线段树)、Trie(字典树)、U...
javascript实现白平衡树 --- AVL 树
通俗易懂
07-26 371
avl树
【从蛋壳到满天飞】JS 数据结构解析和算法实现-AVL树（二）
weixin_34301132的博客
03-21 177
前言 【从蛋壳到满天飞】JS 数据结构解析和算法实现，全部文章大概的内容如下： Arrays(数组)、Stacks(栈)、Queues(队列)、LinkedList(链表)、Recursion(递归思想)、BinarySearchTree(二分搜索树)、Set(集合)、Map(映射)、Heap(堆)、PriorityQueue(优先队列)、SegmentTree(线段树)、Trie(字典树)、U...
js实现平衡二叉树
simple5960的博客
12-10 465
平衡二叉树定义(AVL)：它或者是一颗空树，或者具有以下性质的二叉排序树：它的左子树和右子树的深度之差(平衡因子)的绝对值不超过1，且它的左子树和右子树都是一颗平衡二叉树 平衡二叉树必须是二叉搜索树 var Node=function(key) { this.key=key; this.lchild=null; this.rchild=null; this.height=1;//平衡因子 } var root = null;//根节点 getRoot=function(){return r.
JS数据结构之平衡二叉树（AVL树）
qq_44222205的博客
07-29 409
AV树的旋转AVL树概念不平衡概况四种平衡旋转方式RL平衡旋转(先右后左双旋转)LR平衡旋转(先左后右单旋转) AVL树概念 前面学习二叉查找树和二叉树的各种遍历，但是其查找效率不稳定(斜树)，而二叉平衡树的用途更多。查找相比稳定很多。(欢迎关注数据结构专栏) AVL树是带有平衡条件的二叉查找树。这个平衡条件必须要容易保持。而且要保证它的深度是O(logN). AVL的条件是左右树的高度差（平衡因子）不大于1；并且它的每个子树也都是平衡二叉树。 对于平衡二叉树的最小个数，n0=0;n1=1;nk=n
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值