数据结构之AVL二叉查找树java实现

AVL Binary Search Tree

二叉查询树可看二叉查找树实现

Avl树是带有平衡条件的二叉查找树，他需要保证树的深度是log N，平衡条件是要求每个节点

都必须有高度相同的左子树和右子树，且每个节点的左右子树高度最多差1.！！

如图所示，左边这棵二叉查找树就是一颗AVL树，我们看他的节点，从根节点开始，他的左子树深度为3，右子树深度为2，深度相差为1满足平衡条件。再看2那个节点，左子树为1深度为1，右子树为4深度为2，深度相差1满足平衡条件。看4那个节点，他只有一个左子树右子树没有，所以深度相差也是1也满足。

而右边为什么不是AVL树呢？我们看7这个根节点，他的左子树是以2为头节点的深度为3，而右子树只有8这个节点深度为1，他们一相减深度差2>1不满足平衡条件所以不是平衡树。

当我们执行插入操作的时候，我们有可能会破坏原本的平衡结构，所以我们需要进行旋转操作。
旋转我们分为单旋转和双旋转

单旋转

左单

右单

双旋转

双旋转就是左单之后再右单
先左先右根据左大右大进行选择

程序实现

public class AVLBinary<AnyType extends Comparable<? super AnyType>> {
    private static class BinaryNode<AnyType>{
        AnyType data;
        BinaryNode<AnyType> left;
        BinaryNode<AnyType> right;
        int height;
        public BinaryNode(AnyType data){this(data,null,null);}
        private BinaryNode(AnyType data,BinaryNode<AnyType> left,BinaryNode<AnyType> right){
            this.data=data;  this.left=left;  this.right=right; height=0;
        }
    }

    BinaryNode<AnyType> root;
    public AVLBinary(){ root=null; }
    public boolean isEmpty(){return root==null;}

    private int height(BinaryNode<AnyType> node){
        return (node==null)?-1:node.height;
    }

    public void insert(AnyType x){root=insert(x,root);}
    private BinaryNode<AnyType> insert(AnyType x,BinaryNode<AnyType> node){
        if(node==null)
            return new BinaryNode<>(x);
        int compareResult=x.compareTo(node.data);

        if (compareResult>0)
            node.right=insert(x,node.right);
        else if(compareResult<0)
            node.left=insert(x,node.left);
        else ;

        return balance(node);
    }

    private static final int ALLOWED_IMBALANCE=1;
    private BinaryNode<AnyType> balance(BinaryNode<AnyType> node) {
        if(node==null)
            return node;
        if(height(node.left)-height(node.right)>ALLOWED_IMBALANCE){          //左子树的高度大于右子树的高度+1
            if(height(node.left.left)>=height(node.left.right))
                node=rotateWithLeftChild(node);
            else
                node=doubleWithRightChile(node);
        }
        else {
            if (height(node.right) - height(node.left) > ALLOWED_IMBALANCE) {        //左子树的高度小于右子树的高度-1
                if (height(node.right.right) >= height(node.right.left))
                    node = rotateWithLeftChild(node);
                else
                    node = doubleWithRightChile(node);
            }
        }
         node.height=Math.max(height(node.left),height(node.right))+1;
        return node;
    }

    private BinaryNode<AnyType> rotateWithLeftChild(BinaryNode<AnyType> node){
        BinaryNode<AnyType> newNode=node.left;                                //先获取当前节点的左子树集
        node.left=newNode.right;                                              //把原先的树剪枝，把新子树的右节点放置
        newNode.right=node;                                                   //把原树作为一个子树放置在新树的右子树处
        newNode.height=Math.max(height(newNode.left),height(newNode.right))+1;
        node.height=Math.max(height(node.left), newNode.height)+1;
        return newNode;
    }

    private BinaryNode<AnyType> doubleWithRightChile(BinaryNode<AnyType> node){
        node.left=rotateWithLeftChild(node.left);
        return rotateWithLeftChild(node);
    }

    public void remove(AnyType x){root=remove(x,root);}
    private BinaryNode<AnyType> remove(AnyType x,BinaryNode<AnyType> node){
        if(node==null)
            return node;
        int compareResult=x.compareTo(node.data);

        if (compareResult>0)
            node.right=insert(x,node.right);
        else if(compareResult<0)
            node.left=insert(x,node.left);
        else if(node.left!=null&&node.right!=null){
            node.data=findMin(node.right).data;
            node.right=remove(node.data,node.right);
        }
        else
            node=(node.left!=null)?node.left:node.right;
        return balance(node);
    }
    public AnyType findMin(){
        if(isEmpty()) throw new BufferUnderflowException();
        return findMin(root).data;
    }
    public BinaryNode<AnyType> findMin(BinaryNode<AnyType> node){    //递归查找最下边最左的子树
        if(node==null)
            return null;
        else if(node.left==null)
            return node;
        return findMin(node.left);
    }

    public AnyType findMax(){
        if (isEmpty()) throw  new BufferUnderflowException();
        return findMax(root).data;
    }
    public BinaryNode<AnyType> findMax(BinaryNode<AnyType> node){
        if(node==null)
            return null;
        else if(node.right==null)
            return node;
        return findMax(node.right);
    }
}