AVL树

最新推荐文章于 2023-05-17 20:38:32 发布

Lzz688

最新推荐文章于 2023-05-17 20:38:32 发布

阅读量822

点赞数

文章标签：二叉树

本文链接：https://blog.csdn.net/qq_44876857/article/details/104998338

版权

AVL树

基础知识

平衡二叉搜索树（Self-balancing binary search tree）又被称为AVL树（有别于AVL算法），且具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。

平衡因子

某结点的左子树与右子树的高度(深度)差即为该结点的平衡因子（BF,Balance Factor）。平衡二叉树上所有结点的平衡因子只可能是 -1，0 或 1。如果某一结点的平衡因子绝对值大于1则说明此树不是平衡二叉树。为了方便计算每一结点的平衡因子我们可以为每个节点赋予height这一属性，表示此节点的高度。

为什么要平衡二叉树

二叉查找树的性能和树的高度有关

层数	该层的节点数
0	1
1	2
2	4
3	8
4	16
h-1	2^(h-1)

当为满二叉树时为最好情况时间复杂度为O (log n),当退化成链表时为最坏情况O (n)。
平衡二叉搜索树在最坏时也能保证时间复杂度在O (log n)。
平衡二叉树在二叉搜索树的基础上需要满足两个条件

1)他的左右两个子树的高度差的绝对值不超过1。

2)左右两棵子树都是一颗平衡二叉树。

AVL树

AVL树是高度平衡的二叉搜索树。AVL树检查左子树和右子树的高度，并确保差异不大于1。该差异称为“ 平衡因子”。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-u7iQl5Pz-1584708715302)(/home/lzz/Desktop/assets/AVL例子.png)]

在第二棵树中，C的左子树的高度为2，而右边子树的高度为0，所以差为2。在第三棵树中，A的右子树的高度为2，而左子树的高度为2，所以它为0。，并且相差再次为2。AVL树允许差异（平衡因子）仅为1。

构建

public class AVLTree<E extends Comparable<E>>{
    private class Node{
        public E e;
        public Node left;
        public Node right;
        public int height;

        public Node(E e){
            this.e=e;
            this.left=null;
            this.right=null;
            this.height=1;
        }
    }

    private Node root;
    private int size;

    public AVLTree(){
        root = null;
        size = 0;
    }
    //获取某一节点的高度
    private int getHeight(Node node){
        if (node == null){
            return 0;
        }
        return node.height;
    }

    public int getSize(){
        return size;
    }
    public boolean isEmpty(){
        return size == 0;
    }

    /*
    * 获取节点的平衡因子
    * */
    private int getBalanceFactor(Node node){
        if (node == null){
            return 0;
        }
        return getHeight(node.left)-getHeight(node.right);
    }

    //判断树是否是平衡二叉树
    public boolean isBalanced(){
        return isBalanced(root);
    }
    private boolean isBalanced(Node node){
        if (node == null){
            return true;
        }
        //取绝对值
        int balanceFactory = Math.abs(getBalanceFactor(node));
        if (balanceFactory > 1){
            return false;
        }
        return isBalanced(node.left) && isBalanced(node.right);
    }

AVL树的旋转

往平衡二叉树中添加节点很可能会导致二叉树失去平衡，所以我们需要在每次插入节点后进行平衡的维护操作。

左旋：向右子树（L）的右孩子（L）中插入新节点后导致不平衡，这种情况下需要左旋操作，而不是说LL的意思是右旋，后面的也是一样。
右旋：向左子树（L）的左孩子（L）中插入新节点后导致不平衡，这种情况下需要右旋操作，而不是说LL的意思是右旋，后面的也是一样。
左右旋转

左左
在这里插入图片描述

/*
* 右旋转
* */
private Node rightRotate(Node y){
    Node x = y.left;
    Node t3 = x.right;
    x.right = y;
    y.left = t3;
    //更新height
    y.height = Math.max(getHeight(y.left),getHeight(y.right))+1;
    x.height = Math.max(getHeight(x.left),getHeight(x.right))+1;
    return x;
}

右右
在这里插入图片描述

/*
* 左旋转
* */
private Node leftRotate(Node y){
    Node x = y.right;
    Node t2 = x.left;
    x.left = y;
    y.right = t2;
    y.height = Math.max(getHeight(y.left),getHeight(y.right))+1;
    x.height = Math.max(getHeight(x.left),getHeight(x.right))+1;
    return x;
}

左右旋转

第一种
在这里插入图片描述

第二种
在这里插入图片描述

添加节点

//向树中添加新元素
public void add(E e){
    root = add(root,e);
}

public Node add(Node node , E e) {
    if (node == null) {
        size++;
        return new Node(e);
    }
    if (e.compareTo(node.e) < 0) {
        node.left = add(node.left, e);
    } else if (e.compareTo(node.e) > 0) {
        node.right = add(node.right, e);
    }
    //更新height
    node.height = 1 + Math.max(getHeight(node.left), getHeight(node.right));
    //计算平衡因子
    int balanceFactor = getBalanceFactor(node);
    if (balanceFactor > 1 && getBalanceFactor(node.left) >= 0) {
        //右旋LL
        return rightRotate(node);
    }
    if (balanceFactor < -1 && getBalanceFactor(node.right) <= 0) {
        //左旋RR
        return leftRotate(node);
    }
    //LR
    if (balanceFactor > 1 && getBalanceFactor(node.left) <= 0) {
        node.left = leftRotate(node.left);
        return rightRotate(node);
    }
    //RL
    if (balanceFactor < -1 && getBalanceFactor(node.right) > 0) {
        node.right = rightRotate(node.right);
        return leftRotate(node);
    }
    return node;
}

/*
* 找到以root为根节点的最小值
* */
public E min(){
    return minNode(root).e;
}
//二叉搜索树的最小值一直找左孩子就行了
private Node minNode(Node node){
    if (node.left == null){
        return node;
    }
    return minNode(node.left);
}
//返回以node为根节点的二叉查找树，key所在的节点
private Node getNode(Node node,E e){
    if (node == null){
        return null;
    }
    if (e.equals(node.e)){
        return node;
    }else if (e.compareTo(node.e) < 0){
        return getNode(node.left,e);
    }else{
        return getNode(node.right,e);
    }
}

删除节点

public E remove(E e){
    Node node = getNode(root ,e);
    if (node != null){
        root = remove(root,e);
        return node.e;
    }
    return null;
}
//返回以node为根的二叉查找树的最小值所在的节点
private Node minimum(Node node){
    if (node.left == null){
        return node;
    }
    return minimum(node.left);
}
private Node remove(Node node,E e){
    if (node == null){
        return null;
    }
    Node retNode;
    if (e.compareTo(node.e) < 0){
        node.left = remove(node.left,e);
        retNode = node;
    }else if (e.compareTo(node.e) > 0){
        node.right = remove(node.right,e);
        retNode = node;
    }else{//e.compareTo(node.e) == 0
        //待删除节点左子树为空的情况
        if (node.left == null){
            Node rightNode = node.right;
            node.right = null;
            size--;
            retNode = rightNode;
        }
        //待删除节点右子树为空的情况
        else if (node.right == null){
            Node leftNode = node.left;
            node.left = null;
            size--;
            retNode = leftNode;
        }else {
            //待删除节点左右字树均不为空的情况
            //找到比待删除节点大的最小节点，即待删除节点右子树的最小节点
            //用这个节点顶替待删除节点的位置
            Node successor = minimum(node.right);
            successor.right =remove(node.right,successor.e);
            successor.left = node.left;
            node.left=node.right=null;
            retNode = successor;
        }
    }
    if (retNode == null){
        return null;
    }
    //维护平衡
    //更新height
    retNode.height=1+Math.max(getHeight(retNode.left),getHeight(retNode.right));
    //计算平衡因子
    int balanceFactor = getBalanceFactor(retNode);
    if (balanceFactor > 1 && getBalanceFactor(retNode.left)>=0){
        //右旋LL
        return rightRotate(retNode);
    }
    if (balanceFactor < 1 && getBalanceFactor(retNode.left) < 0){
        //左旋RR
        return leftRotate(retNode);
    }
    //LR
    if (balanceFactor >1 && getBalanceFactor(retNode.left) < 0){
        node.left = leftRotate(retNode.left);
        return rightRotate(retNode);
    }
    //RL
    if (balanceFactor < -1 && getBalanceFactor(retNode.right) > 0){
        node.right = rightRotate(retNode.right);
        return leftRotate(retNode);
    }
    return node;
}

参考博客：

https://blog.csdn.net/qq_25343557/article/details/89110319

https://blog.csdn.net/johnny901114/article/details/80740418

Lzz688

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
AVL树

AVL树基础知识平衡二叉搜索树（Self-balancing binary search tree）又被称为AVL树（有别于AVL算法），且具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。平衡因子某结点的左子树与右子树的高度(深度)差即为该结点的平衡因子（BF,Balance Factor）。平衡二叉树上所有结点的平衡因子只...
复制链接

扫一扫

AVL树

AVL树

AVL树

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