AVL树

定义：AVL树是一种二叉查找树，其中每一个节点的左子树和右子树的高度差至多等于1。

递归定义：AVL树是二叉查找树，其中根的左子树和右子树是高度最多相差1的AVL树。

定义不难理解，给出几个实例，体会一下。

为什么要让左右子树高度最多相差为1？这个问题在前节已经讨论过了，无非是希望树尽量平衡，使得查找和删除的时间复杂度控制在O（lg n）。那么，它是怎么做到让左右子树高度相差做多为1的呢？这里用到了一个东西叫平衡因子，对于一个节点，有三种可能的平衡因子：

• 等高 “—”：该节点的左子树和右子树是等高的。
• 右高 “ / ”  : 该节点的右子树高度比它的左子树的高度大1。
• 左高 “ ”  : 该节点的左子树高度比它的右子树的高度大1。

给出示例：

如果二叉查找树的每个节点都处在这三种平衡状态下，那自然满足AVL的条件。那平衡因子如何设定？这就要从AVL树的构建开始说起，只要保证构建的每一步，节点的平衡因子都为这三种状态之一，那构建的结果必然就是满足条件的AVL树。这里同样介绍AVL树的搜索、插入和删除操作。

• 搜索。因为AVL树是二叉平衡树，搜索操作不对树进行任何修改，所以搜索同二叉平衡树。
• 插入。插入操作和二叉查找树的过程部分相同，将节点插入后可能会引发失衡情况，而左右子树高度失衡的节点就叫作失衡节点。

旋转

Why?  如上图中的节点9和节点7都是失衡节点。如何调整平衡，使得节点都满足AVL的性质，使用的技术叫作旋转。

How to ensure the new trees reach the goal?  以最简单的两种旋转操作作下说明，盗两张图：

从上面可以看出来,旋转通过改变节点之间的位置，在失衡节点处，将较高的一侧子树高度至少降低1，相应的较低一侧子树高度则会增加(至少1)。这是基本的情况，还有更复杂的旋转，这在后面介绍插入和删除操作时，再进一步分析。

插入

AVL的插入操作可以分为两个步骤：

1. 同普通二叉查找树一样插入新值，先寻找它的正确位置，然后把包含这个新值的节点实际插入进去，新节点总是叶节点。
2. 从这个插入节点沿双亲链返回，沿途纠正每个节点的平衡因子。如果有不平衡节点，那么在此停止，称这个节点为X，在节点X调整平衡。R表示插入后X的较高子树的根。

当然，如果插入节点的父节点本来就有一个孩子，插入之后该节点高度不变，那就不会出现失衡节点。亦或者，在沿双亲链上行寻找失衡节点的过程中，某个节点插入未使得其高度发生变化，也可以停止继续上行。此处讨论的是插入操作导致树的高度发生变化的情况。

case 1 : X的平衡因子与R的平衡因子相同，也即X与R的平衡因子都是左高或者右高。所作操作：

• 旋转链接R-X
• 更新R和X的平衡因子

case 2 : X的平衡因子与R的平衡因子方向相反。换句话说，X是右高则R是左高，或者反过来。设Q为R较高子树的根。所作操作：

• 在链接Q-R上旋转，这一旋转使得节点X、Q和R的方向相同。
• 旋转链接Q-X
• 更新X、Q和R的平衡因子

情况2较1稍微复杂一点，要作两次旋转。为什么要两次旋转？ 旋转的目的在于使得较高一侧的子树高度变低，如果直接旋转，那么R的较高子树就会粘贴到X上，那么这颗较高的子树高度并没有减少，并没有达到目的。所以要使得X和R的平衡因子相同再作旋转，就添加了一次旋转操作。

删除

同插入操作，AVL树的删除可以大致分为两个阶段：

1. 同普通二叉查找树，根据三种情况删除节点。（不清楚的同学可以看上篇博客）
2. 从删除节点的双亲P开始，沿着双亲链返回，沿途调整每个节点的平衡因子。

删除和插入实质上是类似的，都是因为节点数量的变化导致树的高度发生变化，所以要调整平衡因子，甚至需要旋转操作改变节点位置。稍微有点不同的是，插入上行的过程中，如果发现有节点高度未发生变化或者找到失衡节点进行旋转，结束后停止继续上行。而删除操作即使在失衡节点处旋转，之后可能依旧需要上行。因为旋转是使得树平衡的操作，旋转后树的高度减少了而不是增加了。删除操作引发的树高度减少的情况，旋转并不能中和它，只能在某个节点处保证满足AVL性质，节点的双亲链是否满足则不确定。给出删除算法的伪代码：

P：the parent of the delete node X
shorter ← true

while(P is not null and shorter is true) do
    
    PP ← parent of P
    rebalance at P
        { rebalance may set shorter to false}
    P ← PP

endwhile

case 1 : P 的平衡因子等高

• 根据删除分别发生在P的左子树还是右子树，更改P的平衡因子为右高或左高。

当case 1 完成时，删除操作结束，不必向上返回。因为P的高度没有发生变化。

case 2 : P的平衡因子不是等高，P的较高子树因删除而变短。

• 将P的平衡因子改成等高。

这种情况不终止返回过程，完成后继续上行。因为该节点高度还是降低了，不能保证其父节点高度是否发生变化，及其平衡因子的调整。

case 3 :Ｐ的平衡因子不是等高，且Ｐ的较短子树因删除而变短。

这种情况涉及到旋转操作，而且比较复杂，可以进一步细分。

case 3.1 : R的平衡因子是等高。

• 旋转链接R-P
• 根据R是P的右孩子还是左孩子，分别设置R的平衡因子为左高或右高。

这是一种与插入旋转不同的操作，出现了R的平衡因子等高的情况。而插入操作是沿着双亲链旋转，因为插入导致高度变化，不可能出现R平衡因子既是等高又同时需要旋转的情况。

这种情况完成后终止返回过程，停止上行。

case 3.2 : R的平衡因子不是等高，且旋转方向与P的平衡因子方向相同。

• 旋转链接R-P
• 把R和P的平衡因子都设置为等高

这种情况下旋转，并不能使得节点高度不变，所以继续上行。

case 3.3 :　Ｒ的平衡因子不是等高，且旋转的方向与Ｐ的平衡因子方向相反。（设Ｑ为Ｒ较高子树的根）

• 旋转链接Ｑ－Ｒ，按Ｐ、Ｑ、Ｒ的顺序排列节点
• 旋转链接Ｑ－Ｐ
• 设置Ｑ的平衡因子为等高
• 根据删除前Ｑ的子树的高度，设置Ｒ和Ｐ的平衡因子

这种情况，树的高度依旧减少，所以不停止上行。为什么减少，有兴趣的同学可以试着画一画，不想画的话可以往下看鄙人的总结。

好了，删除操作大概也就这么多。以上是书上写的内容，除了理解部分，理论基础大部分来源于《数据结构从应用到实现JAVA版》。

如果没有看过的同学，没准已经晕乎乎了。我刚看的时候也一样，后面觉得看懂了，准备写代码的时候发现：差得远呢，代码设计与实现，情况的归纳总结，这些细节，书上几乎都没有。还有插入和删除操作的一般化，肯定有人问了，为什么是这样，你的结论对所有情况都通用吗？ 这些都要个人摸索，以下给出鄙人实践过程中的总结内容。

我的旋转

节点的平衡因子调节，比较简单，根据插入和删除操作的不同，获取上行的子树信息即可调整对应的平衡因子，此处略过讨论。

我的疑问也很简单：

• 旋转情况如何归类？
• 旋转除了节点的位置变化，还涉及节点的平衡因子的改变，如何调节平衡因子？
• 旋转操作对应的平衡因子的调节，涉及到固定的节点，还是会递归地影响下去？

当然，很可笑，这些都是我没有深入思考前的问题。如果是愿意动手的同学或者脑子特别灵光的那种，问题3应该已经有自己的答案了。没错，旋转操作本质上只涉及到3个节点的操作，也即Xparent、X、R，不用考虑子树的平衡因子。而实际上，一次旋转只需要考虑X和R的平衡因子调节就可以了，至于Xparent的调节则在上行之后再进行。调整的可能有多少种呢？ （3*3）²  = 81， impossible! 别慌，这只是理论上的数字，我们需要筛选掉不可能出现的情况，并将剩余的可能合并。

插入和删除的旋转，有些情况是可以合并的。鄙人总结为3个类别：

情况 A：X和R的平衡因子相同,也即最简单的旋转。（也即之前介绍的 插入case 1 和 删除 case 3.2）

给出鄙人的实现代码，调用的方法详见本文结尾：

    //情况A对应的旋转，根据平衡因子，旋转节点X和R，并调整平衡因子
    private void rotateA(avlTree<T> X, avlTree<T> R) {
        avlTree<T> parent = X.parent;
        int XsubInfo = getSubInfo(X);

        // 判断是左旋转还是右旋转
        if (X.balanceFactor == BALANCE)
            throw new TreeViolationException("The node " + X.getData() + " is balance state, dont need rotation!");
        else if (X.balanceFactor == LEFT_HIGHER) {  //左旋转
            setRelation(X, R.right, LEFT_SUB);
            setRelation(R, X, RIGHT_SUB);
        } else {    //右旋转
            setRelation(X, R.left, RIGHT_SUB);
            setRelation(R, X, LEFT_SUB);
        }
        setRelation(parent, R, XsubInfo);

        // 调整平衡因子
        X.setBalanceFactor(BALANCE);
        R.setBalanceFactor(BALANCE);
    }

情况B： X和R的平衡因子不同(也即 插入case2 和 删除 case3)。

设R较高子树的根为Q,因平衡因子的调节规律不同，情况B又细分为B1、B2和B3。

B1>  Q与R的平衡因子不同。

B2> R和Q的平衡因子相同。

B3> Q的平衡因子为等高。（只会在删除操作中出现）

给出B的实现代码：

 // 针对失衡节点和高子树节点的平衡因子不同的情况B，设置的旋转,与A不同之处仅在于平衡因子的设置
    private void rotateB(avlTree<T> X, avlTree<T> R, avlTree<T> Q) {
        avlTree<T> parent = X.parent;
        int XsubInfo = getSubInfo(X);
        int RsubInfo = getSubInfo(R);

        // 先作旋转操作,此处将两次旋转作一次操作
        if(RsubInfo==LEFT_SUB){ //注意先后顺序
            setRelation(R, Q.left, RIGHT_SUB);
            setRelation(X, Q.right, LEFT_SUB);
            setRelation(Q, X, RIGHT_SUB);
            setRelation(Q, R, LEFT_SUB);
        }else{  //右旋同理
            setRelation(R, Q.right, LEFT_SUB);
            setRelation(X, Q.left, RIGHT_SUB);
            setRelation(Q, X, LEFT_SUB);
            setRelation(Q, R, RIGHT_SUB);
        }
        setRelation(parent, Q, XsubInfo);

        // 调整平衡因子
        Q.setBalanceFactor(BALANCE);
        if(Q.balanceFactor==BALANCE){ //B3
            R.setBalanceFactor(BALANCE);
            X.setBalanceFactor(BALANCE);
        }else if(Q.balanceFactor==X.balanceFactor){ //B1
            R.setBalanceFactor(BALANCE);
            reverseBalanceFactor(X);
        }else{  //B2
            X.setBalanceFactor(BALANCE);
            reverseBalanceFactor(R);
        }
    }

情况C ： X为失衡节点，较高子树R的平衡因子为等高。（只会在删除操作中出现，也即上文的删除case1）

对应代码:

    //针对删除引起的特殊旋转的情况C，设置的旋转
    private void rotateC(avlTree<T> X, avlTree<T> R){
        avlTree<T> parent = X.parent;
        int XsubInfo = getSubInfo(X);

        // 先旋转
        if(X.balanceFactor==BALANCE)
            throw new TreeViolationException("The node "+X.getData()+" need not rotate!");
        else if(X.balanceFactor==LEFT_HIGHER){
            setRelation(X, R.right, LEFT_SUB);
            setRelation(R, X, RIGHT_SUB);
        }else{
            setRelation(X, R.left, RIGHT_SUB);
            setRelation(R, X, LEFT_SUB);
        }
        setRelation(parent, R, XsubInfo);

        //调整平衡因子
        if(X.balanceFactor==LEFT_HIGHER)
            R.setBalanceFactor(RIGHT_HIGHER);
        else
            R.setBalanceFactor(LEFT_HIGHER);
    }

AVL最难最核心的东西应该就是上面这些了，除了刚开始的理论，后面全是个人工作，也许没有那么好，胜在一个体会吧，哈哈。

以下给出完整代码，这次连接口都是自己写的哦，绝对全网首发，O(∩_∩)O哈哈~

package com.structures.tree;
import java.util.HashMap;

import static com.structures.tree.constant.*;

/**
 * Created by wx on 2017/11/23.
 * Implement a kind of binary balanced tree which subtrees' height minus less than 1.
 * Initialize with a head node.
 */
public class avlTree<T extends Comparable<T>> {
    private T data;
    private avlTree<T> parent;
    private avlTree<T> left;
    private avlTree<T> right;
    private char balanceFactor;


    private final static HashMap<Integer, Character> modifyMap = new HashMap<Integer, Character>();

    static {
        modifyMap.put(LEFT_SUB, LEFT_HIGHER);
        modifyMap.put(RIGHT_SUB, RIGHT_HIGHER);
    }

    // 设置头结点
    public avlTree(){
        this.data = null;
        parent = null;
        left = null;
        right = null;
        setBalanceFactor(BALANCE);
    }

    // 私有构造器，insert操作时使用
    private avlTree(T data){
        this.data = data;
        parent = null;
        left = null;
        right = null;
        setBalanceFactor(BALANCE);
    }

    //设定节点值
    private void setData(T data){
        if (checkHeadNode(this))
            throw new TreeViolationException("The node is head node, forbid set data!");
        this.data = data;
    }

    //设定平衡因子
    private void setBalanceFactor(char factor){
        balanceFactor = factor;
    }

    //检查节点是否为头结点
    private static <T extends Comparable<T>> boolean checkHeadNode(avlTree<T> node){

        return node.parent==null;
    }

    //返回节点是其双亲节点的哪个分支信息
    private static <T extends Comparable<T>> int getSubInfo(avlTree<T> node){
        if (checkHeadNode(node))
            throw new TreeViolationException("The tree node is a head node, has no parents!");
        avlTree<T> parent = node.parent;

        if(parent.left == node)
            return LEFT_SUB;
        else
            return RIGHT_SUB;
    }

    //将平衡因子反向
    private static <T extends Comparable<T>> void reverseBalanceFactor(avlTree<T> node){
        if(node.balanceFactor==BALANCE)
            throw new TreeViolationException(node.getData() + " is a balance tree");
        else if(node.balanceFactor==LEFT_HIGHER)
            node.setBalanceFactor(RIGHT_HIGHER);
        else
            node.setBalanceFactor(LEFT_HIGHER);
    }

    //对parent和child建立父子关系
    private static <T extends Comparable<T>> void setRelation(avlTree<T> parent, avlTree<T> child, int subInfo){
        if(child!=null)
            child.parent = parent;
        //因为头结点的存在，parent不会为null
        if (subInfo == LEFT_SUB)
            parent.left = child;
        else
            parent.right = child;

    }

    //获取节点较高子树
    private static <T extends Comparable<T>> avlTree<T> getHighSubTree(avlTree<T> node){
        if(node==null)
            throw new TreeViolationException("The tree node is empty!");

        switch(node.balanceFactor) {
            case BALANCE:
                throw new TreeViolationException("The tree node " + node.getData() + " hasn't higher tree!");
            case LEFT_HIGHER:
                return node.left;
            default:
                return node.right;
        }
    }

    //返回节点数据
    public T getData(){
        return data;
    }

    // 返回整棵树的头结点
    private avlTree<T> root(){
        avlTree<T> myRoot = this;

        while(myRoot.parent!=null){
            myRoot = myRoot.parent;
        }
        return myRoot;
    }

    // 查找节点,此为用户接口，实际操作在findLocation中完成
    public avlTree<T> search(T targetData){
        avlTree<T> searchResult = findLocation(targetData);

        if(searchResult.data!=targetData)
            throw new TreeViolationException("There is no "+targetData+" node in the tree!");

        return searchResult;
    }

    //查找节点实际操作函数
    //返回查找结果，找不到则返回其需要插入的双亲节点
    private avlTree<T> findLocation(T targetData){
        avlTree<T> root = this;     //搜索的起点为头结点
        avlTree<T> nextNode = root.right;

        while(nextNode!=null){
            root = nextNode;
            int result = root.getData().compareTo(targetData);

            if (result == 0)
                break;
            else if (result > 0)
                nextNode = root.left;
            else
                nextNode = root.right;
        }
        return root;
    }

    //插入节点,先插入，后调节平衡因子
    public void insert(T insertData){
        avlTree<T> searchResult = findLocation(insertData);
        avlTree<T> insertNode = new avlTree<T>(insertData);

        if(checkHeadNode(searchResult)) {     // 空树，只有头结点
            setRelation(searchResult, insertNode, RIGHT_SUB);
            searchResult.setBalanceFactor(RIGHT_HIGHER);
            return;
        }
        int compareResult = searchResult.getData().compareTo(insertData);

        if(compareResult==0)    // 插入数值已存在
            throw new TreeViolationException("Insert data " + insertData+ " already exists!");
        else {  // 插入数值不存在
            if (compareResult > 0)   // 以左子树插入
                setRelation(searchResult, insertNode, LEFT_SUB);
            else    //以右子树插入
                setRelation(searchResult, insertNode, RIGHT_SUB);

            // 调整并上行直至结束
            avlTree<T> lastNode = insertNode;
            avlTree<T> thisNode = searchResult;
            int subInfo = getSubInfo(lastNode);

            while(!checkHeadNode(thisNode)){
                if(thisNode.balanceFactor!=modifyMap.get(subInfo)){ //不旋转
                    if(thisNode.balanceFactor==BALANCE)
                        thisNode.setBalanceFactor(modifyMap.get(subInfo));
                    else{
                        thisNode.setBalanceFactor(BALANCE); // 高度未发生变化，停止上行
                        break;
                    }
                }else{  //旋转
                    if(thisNode.balanceFactor==lastNode.balanceFactor) //情况A
                        rotateA(thisNode, lastNode);
                    else {    //情况B 的1,2两种可能
                        avlTree<T> lastLastNode = getHighSubTree(lastNode);
                        rotateB(thisNode, lastNode, lastLastNode);
                    }
                    break;  //旋转后，该节点高度不变，停止上行
                }
                lastNode = thisNode;
                thisNode = thisNode.parent;
                subInfo = getSubInfo(lastNode);
            }
        }
    }

    //删除节点并返回之,先进行一般二叉查找树的删除操作，之后调节平衡因子
    public avlTree<T> delete(T deleteData){
        avlTree<T> searchResult = findLocation(deleteData);
        avlTree<T> adjustNode;  //为上行调整的起点
        int subInfo = getSubInfo(searchResult); //存储删除子树分支信息

        if(checkHeadNode(searchResult) || searchResult.getData().compareTo(deleteData)!=0) {     // 空树和找不到删除节点情况
            throw new TreeViolationException("Delete data " + deleteData+ " not exists!");
        }

        // 先对其进行普通二叉查找树的删除操作
        if(searchResult.left==null && searchResult.right==null){    //删除节点为叶子节点的情况
            adjustNode = deleteNoChild(searchResult);
        }else if(searchResult.left!=null && searchResult.right!=null) {   //删除节点有两个孩子
            // 等价于删除前趋节点，故重新复制subInfo
            avlTree<T> preNode = getPreNode(searchResult);
            subInfo = getSubInfo(preNode);
            // 从删除节点的父节点处，上行调整平衡因子
            adjustNode = deleteTwoChild(searchResult);
            // 设置返回节点
            searchResult = new avlTree<T>(deleteData);
        }else{          //删除节点只有一个孩子
            adjustNode = deleteOneChild(searchResult);
        }

        //调整平衡因子
        avlTree<T> thisNode = adjustNode;
        avlTree<T> lastNode;

        while(!checkHeadNode(thisNode)){
            if(thisNode.balanceFactor==BALANCE) {   //高度不变，调整后停止上行
                thisNode.setBalanceFactor(modifyMap.get(-subInfo)); //这里是删除，所以取反
                break;
            }else if(thisNode.balanceFactor==modifyMap.get(subInfo))    //删除子树为较高子树，调整后继续上行
                thisNode.setBalanceFactor(BALANCE);
            else{   //删除子树为较短子树，需要旋转
                lastNode = getHighSubTree(thisNode);

                //由于删除操作会继续上行，因为旋转导致thisNode指向变换，故旋转后要修正thisNode的位置
                if(lastNode.balanceFactor==BALANCE) { //对应情况C
                    rotateC(thisNode, lastNode);
                    thisNode = lastNode;    //修正thisNode
                }
                else if(lastNode.balanceFactor == thisNode.balanceFactor) {   //对应情况A
                    rotateA(thisNode, lastNode);
                    thisNode = lastNode;
                }
                else{   //对应情况B 1,2,3 所有可能
                    avlTree<T> lastLastNode = getHighSubTree(lastNode);
                    rotateB(thisNode, lastNode, lastLastNode);
                    thisNode = lastLastNode;
                }
            }
            lastNode = thisNode;
            thisNode = thisNode.parent;
            subInfo = getSubInfo(lastNode);
        }

        return searchResult;
    }

    //删除节点没有孩子的情况,返回删除节点的父节点
    private avlTree<T> deleteNoChild(avlTree<T> deleteNode){
        int subInfo = getSubInfo(deleteNode);
        setRelation(deleteNode.parent, null, subInfo);

        avlTree<T> parentNode = deleteNode.parent;
        deleteNode.clear();

        return parentNode;
    }

    //删除节点有一个孩子的情况,返回删除节点的父节点，因为子树不需要调整平衡因子
    private avlTree<T> deleteOneChild(avlTree<T> deleteNode){
        int subInfo = getSubInfo(deleteNode);
        avlTree<T> child = getHighSubTree(deleteNode);
        setRelation(deleteNode.parent, child, subInfo);
        avlTree<T> parentNode = deleteNode.parent;
        deleteNode.clear();

        return parentNode;
    }

    //删除节点有两个孩子的情况
    //利用二叉查找树中该节点的前趋（后继）节点无左（右）子树，进行替换,然后删除其前趋（后继）节点
    private avlTree<T> deleteTwoChild(avlTree<T> deleteNode){
        avlTree<T> preNode = getPreNode(deleteNode);

        T originData = deleteNode.getData();
        deleteNode.setData(preNode.getData());
        preNode.setData(originData);
        deleteNode = preNode;
        avlTree<T> parentNode;

        if(deleteNode.left==null && deleteNode.right==null)
            parentNode = deleteNoChild(deleteNode);
        else
            parentNode = deleteOneChild(deleteNode);

        return parentNode;
    }

    //情况A对应的旋转，根据平衡因子，旋转节点X和R，并调整平衡因子
    private void rotateA(avlTree<T> X, avlTree<T> R) {
        avlTree<T> parent = X.parent;
        int XsubInfo = getSubInfo(X);

        // 判断是左旋转还是右旋转
        if (X.balanceFactor == BALANCE)
            throw new TreeViolationException("The node " + X.getData() + " is balance state, dont need rotation!");
        else if (X.balanceFactor == LEFT_HIGHER) {  //左旋转
            setRelation(X, R.right, LEFT_SUB);
            setRelation(R, X, RIGHT_SUB);
        } else {    //右旋转
            setRelation(X, R.left, RIGHT_SUB);
            setRelation(R, X, LEFT_SUB);
        }
        setRelation(parent, R, XsubInfo);

        // 调整平衡因子
        X.setBalanceFactor(BALANCE);
        R.setBalanceFactor(BALANCE);
    }

    // 针对失衡节点和高子树节点的平衡因子不同的情况B，设置的旋转,与A不同之处仅在于平衡因子的设置
    private void rotateB(avlTree<T> X, avlTree<T> R, avlTree<T> Q) {
        avlTree<T> parent = X.parent;
        int XsubInfo = getSubInfo(X);
        int RsubInfo = getSubInfo(R);

        // 先作旋转操作,此处将两次旋转作一次操作
        if(RsubInfo==LEFT_SUB){ //注意先后顺序
            setRelation(R, Q.left, RIGHT_SUB);
            setRelation(X, Q.right, LEFT_SUB);
            setRelation(Q, X, RIGHT_SUB);
            setRelation(Q, R, LEFT_SUB);
        }else{  //右旋同理
            setRelation(R, Q.right, LEFT_SUB);
            setRelation(X, Q.left, RIGHT_SUB);
            setRelation(Q, X, LEFT_SUB);
            setRelation(Q, R, RIGHT_SUB);
        }
        setRelation(parent, Q, XsubInfo);

        // 调整平衡因子
        Q.setBalanceFactor(BALANCE);
        if(Q.balanceFactor==BALANCE){ //B3
            R.setBalanceFactor(BALANCE);
            X.setBalanceFactor(BALANCE);
        }else if(Q.balanceFactor==X.balanceFactor){ //B1
            R.setBalanceFactor(BALANCE);
            reverseBalanceFactor(X);
        }else{  //B2
            X.setBalanceFactor(BALANCE);
            reverseBalanceFactor(R);
        }
    }

    //针对删除引起的特殊旋转的情况C，设置的旋转
    private void rotateC(avlTree<T> X, avlTree<T> R){
        avlTree<T> parent = X.parent;
        int XsubInfo = getSubInfo(X);

        // 先旋转
        if(X.balanceFactor==BALANCE)
            throw new TreeViolationException("The node "+X.getData()+" need not rotate!");
        else if(X.balanceFactor==LEFT_HIGHER){
            setRelation(X, R.right, LEFT_SUB);
            setRelation(R, X, RIGHT_SUB);
        }else{
            setRelation(X, R.left, RIGHT_SUB);
            setRelation(R, X, LEFT_SUB);
        }
        setRelation(parent, R, XsubInfo);

        //调整平衡因子
        if(X.balanceFactor==LEFT_HIGHER)
            R.setBalanceFactor(RIGHT_HIGHER);
        else
            R.setBalanceFactor(LEFT_HIGHER);
    }

    //中序遍历avl树
    public static <T extends Comparable<T>> void inOrderTraverse(avlTree<T> treeNode){
        if(treeNode.left!=null) {
            inOrderTraverse(treeNode.left);
        }
        if(treeNode.getData()!=null)    //头结点不输出
            System.out.println(treeNode.getData() + " "+ treeNode.balanceFactor);
        if(treeNode.right!=null){
            inOrderTraverse(treeNode.right);
        }
    }

    //获取节点前趋,只针对此处节点有两个孩子的情况
    private avlTree<T> getPreNode(avlTree<T> node){
        avlTree<T> preNode = node.left;

        while (preNode.right!=null){    //寻找前趋节点
            preNode = preNode.right;
        }

        return preNode;
    }

    //清空树的链接
    private void clear(){
        left=null;
        right=null;
        parent=null;
        setBalanceFactor(BALANCE);
    }
}