AVL树的分析

最新推荐文章于 2023-11-27 15:44:01 发布

原创最新推荐文章于 2023-11-27 15:44:01 发布 · 151 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#数据结构 #java

AVL树又叫做平衡之二叉树,什么是平衡和不平衡就是由一个平衡因子来判断的

一棵AVL树是其每个结点的左子树和右子树的高度最多相差1的二叉查找树(空树的高度为-1)，这个差值也称为平衡因子（其取值可以是1，0，-1，平衡因子是某个结点左右子树层数的差值,因为没有规定左子树减右子树还是右子树减左子树，所以有负和正的区别)

假如我们要在AVL树中插入或者删除一个节点的话那么就有可能会影响平衡所以就有了旋转的概念,这里假设结点X是失衡点，它必须重新恢复平衡

旋转分为四种:

在结点X的左孩子结点的左子树中插入元素
在结点X的左孩子结点的右子树中插入元素
在结点X的右孩子结点的左子树中插入元素
在结点X的右孩子结点的右子树中插入元素

以上4种情况，其中第1情况和第4情况是对称的，可以通过单旋转来解决，而第2种情况和第3情况是对称的，需要双旋转来解决。
这里先来创建一个平衡二叉查找树

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;
    }
    /**
     * 获取节点的平衡因子
     * @param node
     * @return
     */
    //判断树是否为平衡二叉树
    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);
    }

这里也就创建了一个平衡的二叉树,下面我们来说说旋转，旋转分为四种:
右旋转

private Node rightRotate(Node y){
        //创建一个y节点的左孩子节点为x
        Node x = y.left;  
        //创建一个x节点的右孩子节点t3
        Node t3 = x.right;
        //然后把y变成t3节点，把x节点变成之前的y节点
        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;
        //更新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;
    }

左右双旋转也就是得先左旋转再又旋转，右左双旋转则反之

下面来看看AVL树之插入和删除节点
插入:实际上也就是和二叉查找树插入一样只是多了一步判断他的平衡因子是否满足AVL树的条件，如果不满足则用旋转修复

// 向以node为根的二分搜索树中插入元素(key, value)，递归算法
// 返回插入新节点后二分搜索树的根
    private Node add(Node node, E e){
        //如果根节点为空则创建一个新的节点为e
        if(node == null){
            size ++;
            return new Node(e);
        }
        //如果e的值比节点e的值小则插入一个左子节点为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);
        //如果平衡因子大于一且左子节点的平衡因子大于0
        if(balanceFactor > 1 && getBalanceFactor(node.left)>0) {
            //右旋LL
            return rightRotate(node);
        }
        //如果平衡因子小于-1且右孩子的平衡因子小于0
        if(balanceFactor < -1 && getBalanceFactor(node.right)<0) {
            //左旋RR
            return leftRotate(node);
        }
        //如果平衡因子大于一且左孩子的平衡因子小于零
        if(balanceFactor > 1 && getBalanceFactor(node.left) < 0){
            //左右旋LR
            node.left = leftRotate(node.left);
            return rightRotate(node);
        }
        //如果平衡因子小于-1且右孩子的平衡因子大于零
        if(balanceFactor < -1 && getBalanceFactor(node.right) > 0){
            //右左旋RL
            node.right = rightRotate(node.right);
            return leftRotate(node);
        }
        //如果都没有那就返回原节点
        return node;
    }

删除也就是在二叉查找树上删除然后判断其还满不满足AVL的条件，如果不满足则旋转修复
删除有三种情况:
1.被删的节点为叶子节点则直接删除即可

2.被删除的节点只有一个子节点，则直接用子节点替代他即可

3.被删除节点有两个儿子。那么，先找出它的后继节点；然后把“它的后继节点的内容”复制给“该节点的内容”；之后，删除“它的后继节点”。在这里，后继节点相当于替身，在将后继节点的内容复制给"被删除节点"之后，再将后继节点删除。这样就巧妙的将问题转换为"删除后继节点"的情况了，下面就考虑后继节点。在"被删除节点"有两个非空子节点的情况下，它的后继节点不可能是双子非空。既然"的后继节点"不可能双子都非空，就意味着"该节点的后继节点"要么没有儿子，要么只有一个儿子。若没有儿子，则按"情况1 "进行处理；若只有一个儿子，则按"情况2 "进行处理。

 @Override
    public void remove(T data) {
        if (data==null){
            throw new RuntimeException("data can\'t not be null ");
        }
        this.root=remove(data,root);
    }
    //删除操作
     private AVLNode<T> remove(T data,AVLNode<T> p){
     //如果传进来的节点为空则不存在
        if(p ==null)
            return null;
            //和根节点比较值负数在左正数在右
        int result=data.compareTo(p.data);
        //从左子树查找需要删除的元素
        if(result<0){
            p.left=remove(data,p.left);
            //检测是否平衡
            if(height(p.right)-height(p.left)==2){
                AVLNode<T> currentNode=p.right;
                //判断需要那种旋转
                if(height(currentNode.left)>height(currentNode.right)){
                    //RL
                    p=doubleRotateWithRight(p);
                }else{
                    //RR
                    p=singleRotateRight(p);
                }
            }

        }
        //从右子树查找需要删除的元素
        else if(result>0){
            p.right=remove(data,p.right);
            //检测是否平衡
            if(height(p.left)-height(p.right)==2){
                AVLNode<T> currentNode=p.left;
                //判断需要那种旋转
                if(height(currentNode.right)>height(currentNode.left)){
                    //LR
                    p=doubleRotateWithLeft(p);
                }else{
                    //LL
                    p=singleRotateLeft(p);
                }
            }
        }
        //已找到需要删除的元素,并且要删除的结点拥有两个子节点
        else if(p.right!=null&&p.left!=null){
            //寻找替换结点
            p.data=findMin(p.right).data;
            //移除用于替换的结点
            p.right = remove( p.data, p.right );
        }
        else {
            //只有一个孩子结点或者只是叶子结点的情况
            p=(p.left!=null)? p.left:p.right;
        }
        //更新高度值
        if(p!=null)
            p.height = Math.max( height( p.left ), height( p.right ) ) + 1;
        return p;
    }

查找最大值和最小值就是两端子孙节点

最大值

 private AVLNode<T> findMax(AVLNode<T> p){
        if (p==null)
            return null;
        else if (p.right==null)//如果没有右结点,那么t就是最大的
            return p;
        return findMax(p.right);
    }

最小值

private AVLNode<T> findMin(AVLNode<T> p){
        if (p==null)//结束条件
            return null;
        else if (p.left==null)//如果没有左结点,那么t就是最小的
            return p;
        return findMin(p.left);
    }