AVL树

AVL树全程二叉平衡树，是在二叉查找树之上添加一个平衡条件，那就是左右子树的高度差不超过2，二叉查找树的优点就是插入和查询一个节点的速度快，但是当二叉查找树出现偏缀也就是每个节点都只有左孩子，这个树就会无限向下延申导致查找和插入的效率下降，所以二叉平衡树就出现了。

在这个平衡条件下，就出现了维持二叉树平衡的手段，也就是旋转，在我了解一点这个AVL树的时候我以为这个旋转会很复杂，事实告诉我任何东西只有你上手做你才会了解到他到底难不难。

首先是二叉平衡树的节点

public class TreeNode {
     int val;
     TreeNode left;
     TreeNode right;
     int hight;
     public TreeNode(int val, TreeNode left, TreeNode right){
         this.val = val;
         this.left = left;
         this.right = right;
         this.hight = 0;
     }
}

节点有一个hight属性，也就是左子树或者右子树的最大值。接下来是增删改查四个方法。

在增加之前了解四个旋转方法：LL单旋转，RR单旋转，LR双旋转，RL双旋转

public TreeNode leftleftRotation(TreeNode k2){
        TreeNode k1 ;
        k1 = k2.left;
        k2.left = k1.right;
        k1.right =  k2;

        k2.hight = max(getHight(k2.right), getHight(k2.left));
        k1.hight = max(getHight(k1.left), k2.hight);

        return k1;
    }

//RR型单旋转
    public TreeNode rightRightRotation(TreeNode k2){
        TreeNode k1;
        k1 = k2.right;
        k2.right = k1.left;
        k1.right = k2;

        k2.hight = max(getHight(k2.left), getHight(k2.right));
        k1.hight = max(getHight(k1.right), k1.hight);

        return k1;
    }

//LR双旋转
    public TreeNode leftRightRotation(TreeNode k3){
        k3.left = rightRightRotation(k3.left);
        return leftleftRotation(k3);
    }

//RL双旋转
    public TreeNode rightLeftRotation(TreeNode k3){
        k3.right = leftleftRotation(k3.right);
        return rightRightRotation(k3);
    }

然后是insert方法，我是用递归写的insert，在每次insert之后判断node是否失衡，如果失衡在判断失衡类型采用哪种旋转方法，增加之后更新高度。

//增加
    public void insert(TreeNode node,int val){
        if(node == null){
            node = new TreeNode(val, null, null);
        }
        int com = compareTo(val, node.val);

        if(com < 0){
            insert(node.left, val);
            if(getHight(node.left) - getHight(node.right) == 2){
                if(val < node.left.val){
                    node = leftleftRotation(node);
                }else{
                    node = leftRightRotation(node);
                }
            }
        }else if(com > 0){
            insert(node.right, val);
            if(getHight(node.left) - getHight(node.right) == 2){
                if(val > node.right.val){
                    node = rightRightRotation(node);
                }else{
                    node = rightLeftRotation(node);
                }
            }
        }else if(com == 0){
            return ;
        }
        node.hight = max(getHight(node.left), getHight(node.right));
    }

接着是删除功能，删除节点之后需要寻找替换节点，这个就是跟二叉查找树一样寻找删除节点的前驱节点或者后继节点，在这之前写一个获取最大节点和获取最小节点两个方法。

 //获取二叉树的最大节点
    public TreeNode getMax(TreeNode root){
        TreeNode p,x;
        if(root == null){
            return root;
        }
        p = root;
        x = p.right;
        while(true){
            if(x != null){
                p = x;
                x = x.right;
            }else{
                return p;
            }
        }
    }

//获取二叉树的最小节点
    public TreeNode getMin(TreeNode root){
        TreeNode p,x;
        if(root == null){
            return root;
        }
        p = root;
        x = p.left;
        while(true){
            if(x != null){
                p = x;
                x = x.left;
            }else{
                return p;
            }
        }
    }

public TreeNode del(TreeNode root, int val){
        if(val < root.val){
            root.left = del(root.left, val);
            if(getHight(root.right) - getHight(root.left) == 2){
                TreeNode node = root.right;
                if(getHight(node.left) > getHight(node.right)){
                    root.right = rightLeftRotation(node);
                }else{
                    root.right = rightRightRotation(node);
                }
            }
        }else if(val > root.val){
            root.right = del(root.right, val);
            if(getHight(root.left) - getHight(root.right) == 2){
                TreeNode node = root.left;
                if(getHight(node.right) > getHight(node.left)){
                    root.left = leftRightRotation(node);
                }else{
                    root.left = leftleftRotation(node);
                }
            }
        }else{
            //找到删除节点后，如果左子树hight > 右子树hight,用左子树的最大节点替换在删除这个节点。
            //左右子树都非空
            if ((root.left!=null) && (root.right!=null)) {
                if (getHight(root.left) > getHight(root.right)) {
                    TreeNode leftMax = getMax(root.left);
                    root.val = leftMax.val;
                    del(root.left, leftMax.val);
                } else if (getHight(root.left) < getHight(root.right)) {
                    TreeNode rightMin = getMin(root.right);
                    root.val = rightMin.val;
                    del(root.right, rightMin.val);
                }
            }else{
                root = null;
            }
        }
        return root;
    }

最后是查询功能

//查询
    public TreeNode sel(TreeNode root, int val){
        if(root == null || root.val == val){
            return root;
        }
        if(val < root.val){
            root = sel(root.left, val);
        }else{
            root = sel(root.right, val);
        }
        return root;
    }

总结

实现的很简陋，但是帮我理解了这个二叉平衡树的大部分原理，在我以前看来很艰难很复杂的旋转也并不难，只要加油都会有收获的。