算法与数据结构 其六 Avl平衡树

Avl平衡树

接下来要介绍的树都是从二叉树演变而来的，Avl平衡树当然不例外。

何谓平衡？

原目标是树的所有左右子数的高度都相等，但是实际操作起来不现实，所以给的平衡条件是
树的每个节点的左子树和右子树的高度最多差1

那么Avl平衡树就是树的每个节点的左子树和右子树的高度最多差1 的二叉查找树。由于一科满二叉树的高度是O（logN），平衡二叉树的高度仅仅稍微大于 O(logN)，所以对于我们 CRUD速度是很快的。但是在操作中有一点需要注意：

为了保持树的平衡，每次增删时判断树时对树的平衡加以控制

所以Avl树比普通二叉查找树多了一部，就是保持平衡，我们称它为旋转

旋转分为两种类型：单旋转（左旋转，单右旋转）；双旋转（先左旋后右旋，先右旋后左旋）。后者是建立在前者之上。下面讲讲旋转

单旋转（右旋转）

当树的左右子树高度相差2的时候，我们将 K1的左子树挂在K2的左子树，而K1称为这个子树的根节点，保持了平衡

实际例子

这样，非常简单明了。（左旋转和这里类似，所以不做介绍）

双旋转（先右后左）

由于会出现单旋转不能解决的类型，例如下面

那么我们需要使用双旋转进行修复

实际例子

只要理解了这个概念就可以了，因为其他的是和查找二叉树

使用java代码实现AVL树

因为无论插入还是删除都可能对平衡造成影响，所以我们要记录下树的高度，用来判断是否需要旋转

//这是树的节点，height是节点下树的高度
private static class AvlNode<E>{
        public AvlNode(E theElement){
            this(theElement,null,null);
        }

        public AvlNode(E theElement, AvlNode<E> lt, AvlNode<E> rt) {
            this.theElement = theElement;
            this.lt = lt;
            this.rt = rt;
            height=0;
        }

        E theElement;
        AvlNode<E> lt;
        AvlNode<E> rt;
        int height;

        @Override
        public String toString() {
            return theElement+"";
        }
    }

单旋转代码

private AvlNode<E> rotateWidthLeftChild(AvlNode<E> a1) {
        //这里进行旋转
        AvlNode<E> a2 = a1.lt;
        a1.lt=a2.rt;
        a2.rt = a1;
        //计算旋转后两个子树的高度
        a1.height = Math.max(height(a1.rt),height(a1.lt))+1;
        a2.height = Math.max(height(a2.lt),a1.height)+1;
        return a2;
}

双旋转代码（先右后左）

private AvlNode<E>  doubleRotateWidthLeftChild(AvlNode<E> avlNode) {
        //右旋转
        avlNode.lt = rotateWidthRightChild(avlNode.lt);
        //左旋转
        AvlNode<E>  node = rotateWidthLeftChild(avlNode);
        return node;
}

插入元素的代码

public boolean insert(E theElement){
        root = insert(theElement,root);
        return true;
}
private AvlNode<E> insert(E theElement,AvlNode<E> avlNode){

        if(avlNode==null||theElement==null)
            return new AvlNode<E>(theElement);

        int compareResult = theElement.compareTo(avlNode.theElement);

        if(compareResult<0){
            avlNode.lt = insert(theElement,avlNode.lt);
            if(height(avlNode.lt)-height(avlNode.rt)==2){
                if(theElement.compareTo(avlNode.lt.theElement)<0){
                    avlNode = rotateWidthLeftChild(avlNode);
                }else{
                    avlNode = doubleRotateWidthLeftChild(avlNode);
                }
            }
        }else if(compareResult>0){
            avlNode.rt = insert(theElement,avlNode.rt);
            if(height(avlNode.rt)-height(avlNode.lt)==2){
                if(theElement.compareTo(avlNode.rt.theElement)>0){
                    avlNode = rotateWidthRightChild(avlNode);
                }else{
                    avlNode = doubleRotateWidthRightChild(avlNode);
                }
            }
        }else;
        avlNode.height = Math.max(height(avlNode.lt),height(avlNode.rt))+1;
        return avlNode;
}

删除元素代码

private AvlNode<E> remove(E theElement, AvlNode<E> avlNode) {
        if(avlNode==null||theElement==null)
            return null;


        int compateTo = theElement.compareTo(avlNode.theElement);
        if(compateTo<0){
            avlNode.lt = remove(theElement,avlNode.lt);
            //删除之后进行旋转
            if(height(avlNode.lt)-height(avlNode.rt)==2){
                if(theElement.compareTo(avlNode.lt.theElement)<0){
                    avlNode = rotateWidthLeftChild(avlNode);
                }else{
                    avlNode = doubleRotateWidthLeftChild(avlNode);
                }
            }
        }else if(compateTo>0){
            avlNode.rt = remove(theElement,avlNode.rt);
            //删除之后进行旋转
            if(height(avlNode.rt)-height(avlNode.lt)==2){
                if(theElement.compareTo(avlNode.rt.theElement)>0){
                    avlNode = rotateWidthRightChild(avlNode);
                }else{
                    avlNode = doubleRotateWidthRightChild(avlNode);
                }
            }
        }else if(compateTo==0){
            if(avlNode.lt!=null && avlNode.rt!=null){
                //如果左子树的高度 大于右子树
                if(height(avlNode.lt)>height(avlNode.rt)){
                    //找左子树最大的点
                    AvlNode<E> avl =findMax(avlNode.lt);
                    avlNode.theElement = avl.theElement;
                    //该保持还是要保持
                    avlNode.lt = remove(avl.theElement,avlNode.lt);
                }else{
                    //如果左子树的高度 小于右子树
                    //找右子树最小的点
                    AvlNode<E> avl = findMin(avlNode.rt);
                    avlNode.theElement = avl.theElement;
                    //
                    avlNode.rt = remove(avl.theElement,avlNode.rt);
                }
            }else{
                AvlNode<E> avl = avlNode;
                if(avlNode.lt!=null){
                    //整个左子树向上移了
                    avlNode = avlNode.lt;
                }else if(avlNode.rt!=null){
                    //整个右子树向上移了
                    avlNode = avlNode.rt;
                }
                avl=null;
            }
        }
        return avlNode;
}

---

注意这里，因为删除和插入也是需要一定的开销，所以建议如果在数据量大，插入和删除操作很少的情况下，可以使用惰性删除（删除元素而不删除节点）