数据结构之AVL树

最新推荐文章于 2024-09-29 12:32:27 发布
最新推荐文章于 2024-09-29 12:32:27 发布
阅读量793 收藏 1
点赞数
分类专栏： 算法第四版 文章标签： 数据结构 AVL
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qing0706/article/details/50635410
版权

文字介绍和图片来自http://www.cnblogs.com/skywang12345/p/3577479.html

1.AVL介绍

AVL树是高度平衡的而二叉树。它的特点是：AVL树中任何节点的两个子树的高度最大差别为1。
这里写图片描述

2.AVL的实现

2.1 结点定义

//结点定义
    private class AVLNode {
        Key key;
        Value val;
        int h;
        AVLNode left,right;
        public AVLNode(Key k,Value v,int h) {
            key = k; val = v; left = null; right = null; this.h = h;
        }
    }

2.2 旋转

如果在AVL树中进行插入或删除节点后，可能导致AVL树失去平衡。这种失去平衡的可以概括为4种姿态：LL(左左)，LR(左右)，RR(右右)和RL(右左)。下面给出它们的示意图：
旋转示意图
上图中的4棵树都是”失去平衡的AVL树”，从左往右的情况依次是：LL、LR、RL、RR。除了上面的情况之外，还有其它的失去平衡的AVL树，如下图：
其他失去平衡的情况
上面的两张图都是为了便于理解，而列举的关于”失去平衡的AVL树”的例子。总的来说，AVL树失去平衡时的情况一定是LL、LR、RL、RR这4种之一，它们都由各自的定义：

2.2.1 LL的旋转

LL失去平衡的情况，可以通过一次旋转让AVL树恢复平衡。如下图：
LL
图中左边是旋转之前的树，右边是旋转之后的树。从中可以发现，旋转之后的树又变成了AVL树，而且该旋转只需要一次即可完成。

LL的旋转代码

/**
     * LL：左左对应的情况(左单旋转)，LL失去平衡的情况，可以通过一次旋转让AVL树恢复平衡。
     * @param p
     * @return 旋转后的根节点
     */
    private AVLNode LLrotation(AVLNode p) {
        AVLNode v = p.left;
        p.left = v.right;
        v.right = p;
        p.h = Math.max(height(p.left), height(p.right))+1;
        v.h = Math.max(height(v.left), height(v.right))+1;
        return v;
    }

2.2.2 RR的旋转

理解了LL之后，RR就相当容易理解了。RR是与LL对称的情况！RR恢复平衡的旋转方法如下：
RR
图中左边是旋转之前的树，右边是旋转之后的树。RR旋转也只需要一次即可完成。

RR的旋转代码

/**
     * RR：右右对应的情况(右单旋转)。
     * @param p
     * @return 旋转后的根节点
     */
    private AVLNode RRrotation(AVLNode p) {
        AVLNode v = p.right;
        p.right = v.left;
        v.left = p;
        p.h = Math.max(height(p.left), height(p.right))+1;
        v.h = Math.max(height(v.left), height(v.right))+1;
        return v;
    }

2.2.3 LR的旋转

LR失去平衡的情况，需要经过两次旋转才能让AVL树恢复平衡。如下图：

LR
第一次旋转是围绕”k1”进行的”RR旋转”，第二次是围绕”k3”进行的”LL旋转”。
LR的旋转代码

/**
     * LR失去平衡的情况，需要经过两次旋转才能让AVL树恢复平衡。先RR再LL
     * @param p
     * @return
     */
    private AVLNode LRrotation(AVLNode g) {
        AVLNode p = g.left;
        g.left = RRrotation(p);
        return LLrotation(g);
    }

2.2.4 RL的旋转

RL是与LR的对称情况！RL恢复平衡的旋转方法如下：
RL
第一次旋转是围绕”k3”进行的”LL旋转”，第二次是围绕”k1”进行的”RR旋转”。

RL的旋转代码

/**
     * RL失去平衡的情况，需要经过两次旋转才能让AVL树恢复平衡。先LL再RR
     * @param p
     * @return
     */
    private AVLNode RLrotation(AVLNode g) {
        AVLNode p = g.right;
        g.right = LLrotation(p);
        return RRrotation(g);
    }

2.2.5 LL,RR,LR,RL 调整rebalance方案

代码

/**
     * 调整二叉树使之平衡
     * @param p
     * @return
     */
    private AVLNode rebalance(AVLNode p) {
        if(p == null) return null;
        //判断以p为根节点的左右子树是否平衡
        if(Math.abs(height(p.left)-height(p.right))<2)
            return p;
        if(height(p.left)>height(p.right)) {
            //若AVL左子树失去平衡，则进行相应的调节
            if(height(p.left.left) - height(p.right) == 1)  
                p = LLrotation(p);//LL
            else 
                p = LRrotation(p);//LR
        }
        else {
            //若AVL右子树失去平衡，则进行相应的调节
            if(height(p.right.right) - height(p.left) == 1) 
                p = RRrotation(p);//RR
            else 
                p = RLrotation(p);//RL
        }
        return p;
    }

2.3 插入

//插入
    public void insert(Key key,Value val) {
        if(key == null) return;
        if(val == null) delete(key);
        root = insert(root,key,val);
    }

    private AVLNode insert(AVLNode p,Key key,Value val) {
        if(p == null) { p = new AVLNode(key,val,1); return p;}
        int cmp = key.compareTo(p.key);
        if(cmp < 0) 
            p.left = insert(p.left,key,val);
        else if(cmp > 0) 
            p.right = insert(p.right,key,val);
        else {
            p.val = val; return p;
        }
        p.h = Math.max(height(p.left), height(p.right)) + 1;
        p = rebalance(p);
        return p;
    }

2.4 删除

//删除
    public void delete(Key key) {
        root = delete(root,key);
    }

    private AVLNode delete(AVLNode p,Key key) {
        if(p == null || key == null) return null;
        int cmp = key.compareTo(p.key);
        if(cmp < 0) 
            p.left = delete(p.left,key);
         else if(cmp > 0) 
            p.right = delete(p.right,key);
         else {
            //删除
            if(p.right == null) {
                p = p.left;
            }
            else {
                //选择右子树最小结点替换待删除结点
                AVLNode rmin = min(p.right);    
                p.key = rmin.key; p.val = rmin.val;
                p.right = delete(p.right,rmin.key);
            }
        }

        if(p != null) {
            p.h = Math.max(height(p.left), height(p.right)) + 1;
            p = rebalance(p);
        }
        return p;
    }

3 完整代码

package xwq.dt;


public class AVLTree<Key extends Comparable<Key>,Value> {
    private AVLNode root;
    //结点定义
    private class AVLNode {
        Key key;
        Value val;
        int h;
        AVLNode left,right;
        public AVLNode(Key k,Value v,int h) {
            key = k; val = v; left = null; right = null; this.h = h;
        }
    }

    public AVLTree() {
        root = null;
    }

    //查找
    public Value find(Key k) {
        AVLNode result = find(root,k);
        if(result != null) return result.val;
        return null;
    }

    private AVLNode find(AVLNode p,Key k) {
        if(k == null) return null;
        while(p != null) {
            int cmp = k.compareTo(p.key);
            if(cmp<0) p = p.left;
            else if(cmp>0) p = p.right;
            else return p;
        }
        return null;
    }

    //插入
    public void insert(Key key,Value val) {
        if(key == null) return;
        if(val == null) delete(key);
        root = insert(root,key,val);
    }

    private AVLNode insert(AVLNode p,Key key,Value val) {
        if(p == null) { p = new AVLNode(key,val,1); return p;}
        int cmp = key.compareTo(p.key);
        if(cmp < 0) 
            p.left = insert(p.left,key,val);
        else if(cmp > 0) 
            p.right = insert(p.right,key,val);
        else {
            p.val = val; return p;
        }
        p.h = Math.max(height(p.left), height(p.right)) + 1;
        p = rebalance(p);
        return p;
    }

    //删除
    public void delete(Key key) {
        root = delete(root,key);
    }

    private AVLNode delete(AVLNode p,Key key) {
        if(p == null || key == null) return null;
        int cmp = key.compareTo(p.key);
        if(cmp < 0) 
            p.left = delete(p.left,key);
         else if(cmp > 0) 
            p.right = delete(p.right,key);
         else {
            //删除
            if(p.right == null) {
                p = p.left;
            }
            else {
                //选择右子树最小结点替换待删除结点
                AVLNode rmin = min(p.right);    
                p.key = rmin.key; p.val = rmin.val;
                p.right = delete(p.right,rmin.key);
            }
        }

        if(p != null) {
            p.h = Math.max(height(p.left), height(p.right)) + 1;
            p = rebalance(p);
        }
        return p;
    }

    /***************************************************************************
        *  AVL tree helper functions.
     ***************************************************************************/
    /**
     * 调整二叉树使之平衡
     * @param p
     * @return
     */
    private AVLNode rebalance(AVLNode p) {
        if(p == null) return null;
        //判断以p为根节点的左右子树是否平衡
        if(Math.abs(height(p.left)-height(p.right))<2)
            return p;
        if(height(p.left)>height(p.right)) {
            //若AVL左子树失去平衡，则进行相应的调节
            if(height(p.left.left) - height(p.right) == 1)  
                p = LLrotation(p);//LL
            else 
                p = LRrotation(p);//LR
        }
        else {
            //若AVL右子树失去平衡，则进行相应的调节
            if(height(p.right.right) - height(p.left) == 1) 
                p = RRrotation(p);//RR
            else 
                p = RLrotation(p);//RL
        }
        return p;
    }

    /**
     * LL：左左对应的情况(左单旋转)，LL失去平衡的情况，可以通过一次旋转让AVL树恢复平衡。
     * @param p
     * @return 旋转后的根节点
     */
    private AVLNode LLrotation(AVLNode p) {
        AVLNode v = p.left;
        p.left = v.right;
        v.right = p;
        p.h = Math.max(height(p.left), height(p.right))+1;
        v.h = Math.max(height(v.left), height(v.right))+1;
        return v;
    }

    /**
     * RR：右右对应的情况(右单旋转)。
     * @param p
     * @return 旋转后的根节点
     */
    private AVLNode RRrotation(AVLNode p) {
        AVLNode v = p.right;
        p.right = v.left;
        v.left = p;
        p.h = Math.max(height(p.left), height(p.right))+1;
        v.h = Math.max(height(v.left), height(v.right))+1;
        return v;
    }

    /**
     * LR失去平衡的情况，需要经过两次旋转才能让AVL树恢复平衡。先RR再LL
     * @param p
     * @return
     */
    private AVLNode LRrotation(AVLNode g) {
        AVLNode p = g.left;
        g.left = RRrotation(p);
        return LLrotation(g);
    }

    /**
     * RL失去平衡的情况，需要经过两次旋转才能让AVL树恢复平衡。先LL再RR
     * @param p
     * @return
     */
    private AVLNode RLrotation(AVLNode g) {
        AVLNode p = g.right;
        g.right = LLrotation(p);
        return RRrotation(g);
    }



    /***************************************************************************
     *  Utility functions.
     ***************************************************************************/
    public int height() {
        return height(root);
    }

    private int height(AVLNode p) {
        if(p==null) return 0;
        return p.h;
    }

    public Key minKey() {
        AVLNode min = min(root);
        if(min == null) return null;
        return min.key;     
    }

    private AVLNode min(AVLNode p) {
        if(p == null) return null;
        while(p.left != null)
            p = p.left;
        return p;
    }

    public Key maxKey() {
        AVLNode max = max(root);
        if(max == null) return null;
        return max.key;
    }

    private AVLNode max(AVLNode p) {
        if(p==null) return null;
        while(p.right != null)
            p = p.right;
        return p;
    }

    public boolean isBalance() {
        return isBalance(root);
    }

    private boolean isBalance(AVLNode p) {
        if(p == null) return true;
        if(Math.abs(height(p.left)-height(p.right))>=2)
                return false;
        return isBalance(p.left) && isBalance(p.right);
    }

    /***************************************************************************
        *  AVL tree 遍历 functions.
     ***************************************************************************/
    //前序遍历
    public void preorder() {
        System.out.println("preorder: ");
        preorder(root);
        System.out.println();
    }
    //中序遍历
    public void inorder() {
        System.out.println("inorder: ");
        inorder(root);
        System.out.println();
    }
    //后序遍历
    public void postorder() {
        System.out.println("postorder: ");
        postorder(root);
        System.out.println();
    }

    private void inorder(AVLNode p) {
        if(p == null) return;
        inorder(p.left);
        System.out.print(p.key+" ");
        inorder(p.right);
    }

    private void preorder(AVLNode p) {
        if(p == null) return;
        System.out.print(p.key+" ");
        preorder(p.left);
        preorder(p.right);
    }

    private void postorder(AVLNode p) {
        if(p == null) return;
        postorder(p.left);
        postorder(p.right);
        System.out.print(p.key+" ");
    }

}
《数据结构》AVL
songyu005615的博客
02-04 477
AVL的定义 属于二叉查找树，左儿子的值&amp;amp;amp;amp;lt;当前的值&amp;amp;amp;amp;lt;右儿子的值。 在任意一个节点，左右子树高度差不超过2.在任意一个节点，左右子树高度差不超过2. 性质 左子树中任意一节点的值&amp;amp;amp;amp;lt;当前节点的值&amp;amp;amp;amp;lt;右子树中任意一节点的值 高度为h的AVL树，节点最多有2h-1个。 思想 通过旋转操作，实现左右子树平
【数据结构】数据结构之AVL树
aaronlanni的博客
03-16 1336
一、AVL树的来源 AVL树是一种搜索树，但在搜索效率上，容易形成单支树的情形，因此在查找元素相当于在顺序表中搜索元素，效率低下。
数据结构之AVL树（万字详解）
最新发布
都市隸人的博客
09-29 1261
本文介绍了数据结构中的AVL树，给出了C++的代码实现
数据结构-AVL
12-06 743
简介 普通的二分搜索树是有可能退化成链表的，这意味着时间复杂度从O(log(n))O(log(n))O(log(n))降至O(n)O(n)O(n)，为了规避这种现象，平衡二叉树的概念应运而生。 在计算机科学中，AVL树是最先发明的自平衡二叉查找树。AVL树得名于它的发明者G. M. Adelson-Velsky和E. M. Landis，他们在1962年的论文《An algorithm for t...
数据结构之AVL
weixin_30326741的博客
05-08 142
简介： 一棵AVL树有如下必要条件： 　　条件一：它必须是二叉查找树。（左<根<右） 　　 　　条件二：每个节点的左子树和右子树的高度差至多为1。 　　 AVL相关概念： 平衡因子：将二叉树上节点的左子树高度减去右子树高度的值称为该节点的平衡因子BF(Balance Factor)。　　　　　　对于平衡二叉树，BF的取值范围为[-1,1]。如果发现某个节点的BF...
数据结构 -- AVL树
qq_40337206的博客
05-10 230
AVL树 在计算机科学中，AVL树是最先发明的自平衡二叉查找树。在AVL树中任何节点的两个子树的高度最大差别为1，所以它也被称为高度平衡树。增加和删除可能需要通过一次或多次树旋转来重新平衡这个树。AVL树得名于它的发明者G. M. Adelson-Velsky和E. M. Landis，他们在1962年的论文《An algorithm for the organization of informa...
数据结构 - AVL树
TPON的博客
11-10 804
AVL树 - 平衡二叉搜索树
AVL树数据结构平衡二叉查找树
07-16
在计算机科学中，AVL树是最先发明的自平衡二叉查找树。在AVL树中任何节点的两个子树的高度最大差别为1，所以它也被称为高度平衡树。增加和删除可能需要通过一次或多次树旋转来重新平衡这个树。AVL树得名于它的发明者...
数据结构——AVL树
qq_44745063的博客
10-16 384
作者：小 琛 欢迎转载，请标明出处 AVL树的概念与定义 二叉搜索树在很大程度上优化了查找的效率，但如果插入的数据非常有序(例如下图)，则二叉搜索树就会退化成单一的链式结构，这种情况下的查找等操作就非常消耗时间。平衡二叉树就因此引入。 定义 当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，实现降低树的高度，从而减少平均搜索长度。 对于每个节点的平衡因子值_bf，_bf=右子树高度-左子树高度。因此在一棵树的左边插入，平衡因子减一；右边插入平衡
【数据结构】AVL树
Hello_World_213的博客
11-07 1539
数据结构 -- AVL树详解与代码实现: 更新平衡因子+四种旋转, 检验AVL树, 以及AVL树的效率
数据结构-AVL树
草根学僧
04-12 472
AVL树 AVL树又被称作高度平衡的二叉搜索树，是由两个俄罗斯数学家提出的。引入它是为了提高二叉搜索树的效率，减少树的平均搜索长度。 什么是AVL树（性质） 左子树和右子树的高度之差的绝对值不超过1 树中的每个左子树和右子树都是AVL树 每个节点都有一个平衡因子(balance factor–bf),任一节点的平衡因子是-1,0,1。 (每个节点的平衡因子等于右子树的高度减去左子 树的高度 )
数据结构AVL树
专注Java（全栈）应用开发，求知若渴，虚心若愚，talk is cheap, show me the code.
12-01 1030
等价二分查找树的结构 定义： 中序白能力的相同的任意两个的二叉树的，想出相互等价的，。 引理7：      有N个节点的组成的任何一个二分茶轴的树的T的二分不超过的log2n 的二分查找树等价。 证明：    对T做中序遍历设对应的比哪里的O（T）＝｛ｔ１，ｔ２，，，ｔｎ｝； 考虑的有N个接待你的组成的完全二叉树的S积极遍历的序列G（ｓ）＝｛ｓ１，ｓ１，，，，ｓｎ｝； 只要按照的ｓｊ...
【数据结构】AVL树(图文解析 + 代码实现)
2301_80277275的博客
07-23 1618
AVL树的概念、AVL树结点的定义、AVL树的插入、AVL树的旋转、AVL树的验证
数据结构-AVL树（平衡二叉树）
m0_61433144的博客
08-11 1073
规定在插入和删除二叉搜索树的结点时，要保证任意结点的左右子树高度差的绝对值不超过1，我们将这样特殊的二叉搜索树称为AVL树（平衡二叉树）。每一个结点中有记录其左右子树高度差的平衡因子，也即平衡因子的值只可能是-1,0,1。（1如果某结点的左子树高度比右子树高度高一则平衡因子为-1，如果某结点的左子树高度比右子树高度低一则平衡因子为1，如果某结点的左子树高度与右子树高度一样则平衡因子为0）。............
【数据结构】AVL树（万字超详细 附动图）
Eristic0618的博客
04-23 3851
本篇文章围绕数据结构中的AVL树展开讲解，包含AVL树的插入、旋转、验证等内容，万字讲解搭配自制动图
数据结构第二次作业第二题（AVL树）
MysteriousL的博客
10-23 435
#include <stdio.h> #include <stdlib.h> typedef struct treenode { int data; int height; struct treenode *left; struct treenode *right; } TreeNode, *AVL; int Max(int a, int b) { return (a > b) ? a : b; } int Height(AVL .
优化数据结构：AVL树与平衡二叉操作详解
高级数据结构是一门深入研究的数据结构理论，它探讨了在复杂度优化方面超越基础数据结构的高级概念和技术。本讲内容涵盖了平衡二叉树、可并优先队列、线段树和树状数组的基础以及RMQ（Range Minimum Query）与LCA...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值