平衡二叉树（AVLTree）

已于 2024-08-23 08:51:47 修改
阅读量856 收藏 22
点赞数 8
文章标签： 数据结构
于 2024-08-21 15:42:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80785428/article/details/141379812
版权

1.平衡二叉树的定义

1.1 什么是平衡二叉树

平衡二叉树，又称AVL树，用于解决二叉排序树高度不确定的情况，如果二叉排序树的子树间的高度相差太大，就会让二叉排序树操作的时间复杂度升级为O(n)，为了避免这一情况，为最坏的情况做准备，就出现了平衡二叉树，使树的高度尽可能的小，其本质还是一棵二叉搜索树。

 1.2 平衡二叉树的性质

  1. 左子树和右子树的高度之差的绝对值小于等于1
  2. 左子树和右子树也是平衡二叉树

为了方便起见，给树上的每个结点附加一个数字，给出该结点左子树与右子树的高度差，这个数字称为结点的平衡因子（BF）

                平衡因子 = 右子树的高度 - 左子树的高度

  左右子树的高度差（平衡因子）< 2，因此平衡二叉树所有结点的平衡因子只能是-1、0、1，如下图，是一个平衡二叉树

 

2.平衡二叉树的基本代码实现

2.1平衡二叉树的插入

首先我们创建一颗二叉树，在开发软件中创建一个AVLTree类，增添树的特性。

 static class TreeNode{
        public int bf;
        public int val;
        public TreeNode left;
        public TreeNode right;
        public TreeNode parent;
        public TreeNode(int val){
            this.val = val;
        }
    }
    public TreeNode root;

接下来我们可以插入一个节点，创建一个boolean类型的insert方法同时传入int val。插入一个树首先考虑插入的树是否为空，如果为空直接添加，如果不为空，就需要比较该节点与插入节的大小。由AVLTree的性质可以知道如果插入的树大于该节点就往改节点的右边走，如果插入的树小于该节点就往改节点的左边走，直到节点为空，以下为该段话语代码的实现：

 TreeNode node = new TreeNode(val);
        if(root == null){
            root = node;
            return true;
        }
        TreeNode parent = null;
        TreeNode cur = root;
        while(cur != null){
            if(cur.val < val){
                parent = cur;
                cur = cur.right;
            }else if (cur.val == val){
               return false;
            }else{
                parent = cur;
                cur = cur.left;
            }
        }

 接下来cur为null，我们需要进行插入，如果父亲节点小于该节点则插入在父亲节点的右侧，如果父亲节点大于该节点则插入在父亲节点的左侧。

 //cur == null
        if(parent.val < val){
            parent.right = node;
        }else{
            parent.left = node;
        }

插入之后我们首先想到的便是平衡因子的修改。先看插入的树是处在父亲节点的左还是右，左进行减减右进行加加。平衡因子修改之后我们还需判断平衡因子是否为这三个符合条件的数字 1 ，-1 ，0  如果是0则说明已经平衡了直接break，如果是 1 或者  -1 则需要向上继续检查是否有不符合标准的情况直到parent为空，此条件便是循环条件。如果平衡因子是2 或者 -2 的话就需要考虑多种情况进行左旋还有右旋还有左右旋。

1. 第一种情况parent.bf = -2 cur.bf = -1 进行右旋。    parent = 60 ，subL = 30 ，subLR = 40

右旋之后  subL.right = parent , parent.left = subLR

 2.第二种情况 进行左旋 parent.bf = 2 cur.bf = 1

左旋之后 subR.left = parent , parent.right = subRL

 3.第三种情况  parent.bf = -2 , cur.bf = 1 进行先左旋再右旋，此时左旋传入的parent.left，即rotateleft(parent.left)，右旋时传入的是parent,即rotate（parent）

左旋：subR.left = parent , parent.right = subRL

之后右旋： 

subL.right = parent

 4.第四种情况 parent.bf = 2 , cur.bf  = -1, bf = cur.left.bf

当bf = 1时，先右后左 rotate right（parent.right) , rotate left(parent)

右旋：

左旋：subR.left = parent

bf =  -1时 rotate right（parent.right）, rotate left(parent) parent为30

代码实现： 

 public boolean insert(int val){
        TreeNode node = new TreeNode(val);
        if(root == null){
            root = node;
            return true;
        }
        TreeNode parent = null;
        TreeNode cur = root;
        while(cur != null){
            if(cur.val < val){
                parent = cur;
                cur = cur.right;
            }else if (cur.val == val){
               return false;
            }else{
                parent = cur;
                cur = cur.left;
            }
        }
        //cur == null
        if(parent.val < val){
            parent.right = node;
        }else{
            parent.left = node;
        }
        //node.parent = parent;
        // cur = node
        //平衡因子修改
        while(parent != null){
            //先看平衡因子是左还是右决定平衡因子是++还是--
            if(cur == parent.right){
                parent.bf++;
            }else{
                //如果是左树，平衡因子--
                parent.bf--;
            }
            //检查平衡因子是否是 1 0 -1
            if(parent.bf == 0){
                //说明已经平衡了
                break;
            }else if(parent.bf == 1 || parent.bf == -1){
                //继续向上去修改平衡因子
                cur = parent;
                parent = cur.parent;
            }else{
                if(parent.bf == 2){
                    if(cur.bf == 1){
                        //左旋
                       rotateLeft(parent);
                    }else{
                        //cur.bf == -1 先右旋再左旋
                   rotateRL(parent);
                    }
                }else{
                    //parent.bf == -2 左树高，降低左树的高度
                    if(cur.bf == -1){
                        //右旋
                         rotateRight(parent);
                    }else{
                        //先左旋再右旋 cur.bf == 1
                       rotateLR(parent);
                    }

                }
                break;
            }
        }
        return true;
    }

2.2 左单旋

代码实现：

 private void rotateLeft(TreeNode parent){
         TreeNode subR = parent.right;
         TreeNode subRL = subR.left;
        parent.right = subRL;
         subR.left = parent;
         if(subRL != null) {
             subRL.parent = parent;
         }
         TreeNode pParent = parent.parent;
         parent.parent = subR;
         if(root == parent){
             root = subR;
             root.parent = null;
         }else{
             if(pParent.left == parent){
                 pParent.left = subR;
             }else {
                 pParent.right = subR;
             }
             subR.parent = pParent;
         }
         subR.bf = parent.bf = 0;
    }

 2.3 右单旋

代码实现：

 private void rotateRight(TreeNode parent){
        TreeNode subL = parent.left;
        TreeNode subLR = subL.right;
        parent.left = subLR;
        subL.right = parent;
        if(subLR != null){
            subLR.parent = parent;
        }
        TreeNode pParent = parent.parent;
        parent.parent = subL;
        if(parent == root){
            root = subL;
            root.parent = null;
        }else{
            if(pParent.left == parent){
                pParent.left = subL;
            }else{
                pParent.right = subL;
            }
            subL.parent = pParent;
        }
        subL.bf = 0;
        parent.bf = 0;
    }

 2.4 左右双旋

第一旋：对以A的左子树为根节点的树（即L后面结点，B-9-New）进行左旋；

第二旋：再对以A为根节点的树（即全部结点）进行右旋；图中有错误第二旋为右旋

 private void rotateLR (TreeNode parent){
        TreeNode subL = parent.left;
        TreeNode subLR = subL.right;
        int bf = subLR.bf;
        rotateLeft(parent.left);
        rotateRight(parent);
        if(bf == 1){
            subLR.bf = 0;
            parent.bf = 0;
            subL.bf = -1;
        }else if(bf == -1){
            subLR.bf = 0;
            subL.bf = 0;
            parent.bf = 1;
        }
    }

 2.5 右左双旋

第一旋：对以A的右子树为根节点的树（即R后面结点，B-13-10-New）进行右旋；

第二旋：再对以A为根节点的树（即全部结点）进行左旋；

代码实现：

 private void rotateRL (TreeNode parent){
      TreeNode subR = parent.right;
      TreeNode subRL = subR.left;
      int bf = subRL.bf;
      rotateRight(parent.left);
      rotateLeft(parent);
      if(bf == 1){
          subRL.bf = 0;
          parent.bf = -1;
          subR.bf = 0;
      }else if(bf == -1){
          subRL.bf =0;
          parent.bf = 0;
          subR.bf = 1;
      }
    }

3.检验是否为AVL树

 public boolean isBalanced (TreeNode root) {
       if (root == null) return true;

       int leftH = height(root.left);
       int rightH = height(root.right);

       if (rightH - leftH != root.bf) {
           System.out.println("这个因子" + root.val + "异常");
           return false;
       }
       return Math.abs(leftH - rightH) <= 1 && isBalanced(root.left) && isBalanced(root.right);
   }

 

 完整代码：

public class AVLTree {
    static class TreeNode{
        public int bf;
        public int val;
        public TreeNode left;
        public TreeNode right;
        public TreeNode parent;
        public TreeNode(int val){
            this.val = val;
        }
    }
    public TreeNode root;
    public boolean insert(int val){
        TreeNode node = new TreeNode(val);
        if(root == null){
            root = node;
            return true;
        }
        TreeNode parent = null;
        TreeNode cur = root;
        while(cur != null){
            if(cur.val < val){
                parent = cur;
                cur = cur.right;
            }else if (cur.val == val){
               return false;
            }else{
                parent = cur;
                cur = cur.left;
            }
        }
        //cur == null
        if(parent.val < val){
            parent.right = node;
        }else{
            parent.left = node;
        }
        //node.parent = parent;
        // cur = node
        //平衡因子修改
        while(parent != null){
            //先看平衡因子是左还是右决定平衡因子是++还是--
            if(cur == parent.right){
                parent.bf++;
            }else{
                //如果是左树，平衡因子--
                parent.bf--;
            }
            //检查平衡因子是否是 1 0 -1
            if(parent.bf == 0){
                //说明已经平衡了
                break;
            }else if(parent.bf == 1 || parent.bf == -1){
                //继续向上去修改平衡因子
                cur = parent;
                parent = cur.parent;
            }else{
                if(parent.bf == 2){
                    if(cur.bf == 1){
                        //左旋
                       rotateLeft(parent);
                    }else{
                        //cur.bf == -1 先右旋再左旋
                   rotateRL(parent);
                    }
                }else{
                    //parent.bf == -2 左树高，降低左树的高度
                    if(cur.bf == -1){
                        //右旋
                         rotateRight(parent);
                    }else{
                        //先左旋再右旋 cur.bf == 1
                       rotateLR(parent);
                    }

                }
                break;
            }
        }
        return true;
    }

    /**
     * 右左双旋
     * @param parent
     */
    private void rotateRL (TreeNode parent){
      TreeNode subR = parent.right;
      TreeNode subRL = subR.left;
      int bf = subRL.bf;
      rotateRight(parent.left);
      rotateLeft(parent);
      if(bf == 1){
          subRL.bf = 0;
          parent.bf = -1;
          subR.bf = 0;
      }else if(bf == -1){
          subRL.bf =0;
          parent.bf = 0;
          subR.bf = 1;
      }
    }
    /**
     * 左右双旋
     */
    private void rotateLR (TreeNode parent){
        TreeNode subL = parent.left;
        TreeNode subLR = subL.right;
        int bf = subLR.bf;
        rotateLeft(parent.left);
        rotateRight(parent);
        if(bf == 1){
            subLR.bf = 0;
            parent.bf = 0;
            subL.bf = -1;
        }else if(bf == -1){
            subLR.bf = 0;
            subL.bf = 0;
            parent.bf = 1;
        }
    }

    /**
     * 左单旋
     * @param parent
     */
    private void rotateLeft(TreeNode parent){
         TreeNode subR = parent.right;
         TreeNode subRL = subR.left;
        parent.right = subRL;
         subR.left = parent;
         if(subRL != null) {
             subRL.parent = parent;
         }
         TreeNode pParent = parent.parent;
         parent.parent = subR;
         if(root == parent){
             root = subR;
             root.parent = null;
         }else{
             if(pParent.left == parent){
                 pParent.left = subR;
             }else {
                 pParent.right = subR;
             }
             subR.parent = pParent;
         }
         subR.bf = parent.bf = 0;
    }

    /**
     * 右单旋
     * @param parent
     */
    private void rotateRight(TreeNode parent){
        TreeNode subL = parent.left;
        TreeNode subLR = subL.right;
        parent.left = subLR;
        subL.right = parent;
        if(subLR != null){
            subLR.parent = parent;
        }
        TreeNode pParent = parent.parent;
        parent.parent = subL;
        if(parent == root){
            root = subL;
            root.parent = null;
        }else{
            if(pParent.left == parent){
                pParent.left = subL;
            }else{
                pParent.right = subL;
            }
            subL.parent = pParent;
        }
        subL.bf = 0;
        parent.bf = 0;
    }

  public boolean isBalanced (TreeNode root) {
       if (root == null) return true;

       int leftH = height(root.left);
       int rightH = height(root.right);

       if (rightH - leftH != root.bf) {
           System.out.println("这个因子" + root.val + "异常");
           return false;
       }
       return Math.abs(leftH - rightH) <= 1 && isBalanced(root.left) && isBalanced(root.right);
   }
}

 

小媛早点睡
关注
平衡二叉树(AVLTree)的构造等——超详细
qq_44819750的博客
07-28 2542
平衡二叉树概念 二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当 于在顺序表中搜索元素，效率低下。因此，两位俄罗斯的数学家G.M.Adelson-Velskii和E.M.Landis在1962年 发明了一种解决上述问题的方法：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之 差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度。 一棵AVL树或者是空树，或者是具有以下性质的二叉搜索树： 1.它的左右子树都是AVL
详解AVL树（平衡二叉树）
水澹澹兮生烟
09-20 2万+
插入节点后对树进行旋转调整，分为四种情况。 1.右单旋 当一个平衡二叉树满足具有较高左子树时（如下图A），且要插入的节点插入到了较高左子树的左侧，此时进行右单旋。
Java树结构实际应用（平衡二叉树/AVL树），讲得透透的
weixin_51954021的博客
03-16 350
1、 看一个案例(说明二叉排序树可能的问题) 给你一个数列{1,2,3,4,5,6}，要求创建一颗二叉排序树(BST), 并分析问题所在.  左边 BST 存在的问题分析: 1) 左子树全部为空，从形式上看，更像一个单链表. 2) 插入速度没有影响 3) 查询速度明显降低(因为需要依次比较), 不能发挥 BST 的优势，因为每次还需要比较左子树，其查询速度比 单链表还慢 4) 解决方案-平衡二叉树(AVL) 2、 基本介绍 1) 平衡二叉树也叫平衡二叉搜索树（Self-balancin
【数据结构】平衡二叉树
最新发布
Jacky_Feng的博客
01-04 3224
本文主要介绍了平衡二叉树的基本概念及基础操作（查找、平衡、插入、删除）。
平衡二叉树（AVL Tree）
asdv78901的博客
08-31 226
在学习算法的过程中，二叉平衡树是一定会碰到的，这篇博文尽可能简明易懂的介绍下二叉树的相关概念，然后着重讲下什么事平衡二叉树。 （由于作图的时候忽略了箭头的问题，正常的树一般没有箭头，虽然不影响描述的过程，但是还是需要注意，所以还请读者忽略一下部分图的箭头） 一、二叉（查找）树 二叉查找树（Binary Search Tree）是二叉树的一种，其树节点（internal nodes ...
平衡二叉树详解
热门推荐
尽量致力于发表微服务、中间件和算法等原创作品。
06-17 4万+
平衡二叉树（Balanced Binary Tree）又被称为AVL树（有别于AVL算法），且具有以下性质：它是一 棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。这个方案很好的解决了二叉查找树退化成链表的问题，把插入，查找，删除的时间复杂度最好情况和最坏情况都维持在O(logN)。但是频繁旋转会使插入和删除牺牲掉O(logN)左右的时间，不过相对二叉查找树来说，时间上稳定了很多。 平衡二叉树大部分操作和二叉查找树类似，主要不同在于插入删除的时候平衡二叉树的平衡可
03平衡二叉树_AVLTree.rar_03平衡二叉树_AVLTree_大话数据结构_平衡二叉树
09-21
在"03平衡二叉树_AVLTree.c"这个文件中，应该包含了C语言实现AVL树的代码，包括节点结构定义、插入、删除和查找等基本操作，以及相应的旋转函数。通过阅读和理解这段代码，可以深入学习AVL树的内部工作原理和操作...
平衡二叉树AVL操作模板
09-04
2. 树结构：AVLTree * root：根节点 * hgt：树的高度 * size：树中不重复节点的数量 操作 1. 插入操作：_insert * 将新的节点插入树中，并保持树的平衡状态 2. 中序遍历：_mid_travel * 将树的节点按照中序遍历...
pinghen.rar_avl_avl tree_balanced tree_二叉树_平衡二叉树
09-24
平衡二叉树（Balanced Binary Tree）是一种特殊的二叉树数据结构，它的主要特性在于保持了树的高度平衡。这种平衡状态使得在二叉查找树（Binary Search Tree, BST）中的操作，如插入、删除和搜索等，都能在对数时间...
【二叉树进阶】AVLTree - 平衡二叉搜索树
codewinter的博客
06-20 2717
二叉搜索树的插入和删除操作都必须先查找，查找效率代表了二叉搜索树中各个操作的效率。但是二叉搜索树有其自身的缺陷，假如往树中插入的元素有序或者接近有序，二叉搜索树就会退化成单支树，时间复杂度为O(N)，因此 map、set 等关联式容器的底层结构是对二叉树进行了平衡处理，即采用平衡二叉搜索树来实现。最优情况下，有 n 个结点的二叉搜索树为完全二叉树，查找效率为：O(log2N)最差情况下，有 n 个结点的二叉搜索树退化为单支树，查找效率为：O(N)平衡二叉搜索树（Self-balancing binary s
平衡二叉树（AVL Tree)
further_的博客
09-01 2053
二叉排序树的结点不同插入次序，将导致不同的深度和平均查找长度，即其效率取决于二叉排序树的形态。为了获得较好的查找效率，就要构造一棵形态均匀的二叉排序树（AVL Tree)。 注：在学习平衡二叉树之前应先学习过二叉排序树/二叉搜索树/二叉查找树！！！ **什么是平衡二叉树（AVL Tree) ** 平衡二叉树或者是一棵空的二叉排序树，或者是具有下列性质的二叉排序树：（1）根结点的左子树和右子树的深度最多相差1；（2）根结点的左子树和右子树也都是平衡二叉树。（具有二叉排序树的性质） 平衡因子（Balance F
平衡二叉树（AVLTREE）
m0_63222000的博客
07-02 244
二叉搜索树的查找、插入、删除性能的时间复杂度均为Ologn但这是在期望的前提下，在最好和最坏的前提下差别较大。在最好情况下，二叉查找树的形态和二分查找的判定相似，每次可以缩小一半的查找范围。但是在最坏的情况下，二叉查找树为单支树，即只有从左子树到右子树，每次查找的搜索范围为n-1，退化为顺序查找。二叉查找树的效率和树高成反比，那么为了提高二叉查找树的效率这里就引入了平衡二叉树。平衡二叉查找树即平衡二叉树具有以下性质： 1：平衡二叉树可以为空树。 2：左右子树的高度差值的绝对值不超过1
平衡二叉树（AVLTree）详解
土豆的博客
07-06 1676
一、平衡二叉树：            这几天学了平衡二叉树，对于平衡二叉树，我觉得开始在理解插入旋转以及其平衡因子的调整时有点吃力。如今理清就来谈谈这部分。     对于平衡二叉树的理解：                平衡二叉树又称AVL树，（有别于AVL算法）,且具有以下性质：                它是一 棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都
[转]C#与数据结构--树论--平衡二叉树(AVL Tree)
weixin_34354173的博客
10-08 221
   C#与数据结构--树论--平衡二叉树(AVL Tree) http://www.cnblogs.com/abatei/archive/2008/11/17/1335031.html 介绍 我们知道在二叉查找树中，如果插入元素的顺序接近有序，那么二叉查找树将退化为链表，从而导致二叉查找树的查找效率大为降低。如何使得二叉查找树无论在什么样情况下都能使它的形态最大限度地接近...
平衡二叉树（AVL树）
学习日常分享
02-17 1301
为什么引入“平衡二叉树” 二叉搜索树上实现查找的时间复杂度与从根节点到所查对象节点的路径成正比，最坏情况下等于树的高度。 在构造二叉搜索树时，如果输入对象的序列恰好是按其关键码大小有序，则结果将产生一棵单支树。 例如：输入序列为{11,39,46,38,75} 在这样的树上查找所需要的时间是O(n)（与节点个数成正比）。 平衡二叉树的定义 平衡树（Balanced Tree）：高度为O(logn)的树。 平衡二叉树（Balanced Binary Tree）：由阿德尔森一维尔斯和兰迪斯（Adelson-V
MySQL索引原理
Dobbin
02-02 3万+
B+树索引是B+树在数据库中的一种实现，是最常见也是数据库中使用最为频繁的一种索引。B+树中的B代表平衡（balance），而不是二叉（binary），因为B+树是从最早的平衡二叉树演化而来的。在讲B+树之前必须先了解二叉查找树、平衡二叉树（AVLTree）和平衡多路查找树（B-Tree），B+树即由这些树逐步优化而来。
平衡二叉树(AVLTree)
艰难困苦如同欢乐，终将成为人生最后的财富
03-20 823
平衡二叉树（AVLTree）是指带平衡条件的二叉查找树。AVLTree要求每个节点的左子树和右子树的高度之差最多为1。当因为插入或删除操作导致AVLTree不满足该平衡条件时就需要进行调整操作，包括单旋转和双旋转操作。也正是因为需要时刻保持树的平衡条件，从而使得AVLTree的插入和删除操作较为复杂。
平衡二叉树AVL：概念与查找操作解析
在数据库领域，平衡二叉树（Balanced Binary Search Tree，简称BBS）是高效数据查找的重要数据结构，特别是对于大规模数据的存储和检索，平衡二叉树具有显著优势。这里的重点是AVL树，它是平衡二叉树的一种具体实现...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值