数据结构-平衡二叉树

定义

平衡二叉树，是对二叉搜索树的一种优化。

向二叉搜索树中插入元素时，不同的插入次序，将构造出不同结构的树。通俗来讲，就是会导致树的深度和平均查找长度(ASL averge search length)不同；以下图为例。

明显可以看出，中间(b)这种结构是比较好的。整个二叉搜索树左右两边显得比较平均，不像最后一种完全成了一颗右斜树，或者说是单向链表，同时也可以看到其ASL=3.0 是这三种结构中最小的。

总的来说，目的就是想让整个二叉搜索树变得比较矮胖，而不是高瘦，或者是一边倒的倾斜。因为，矮胖意味着树比较低，使得查找某个元素的能更快速。

平衡因子：Balance Factor,简称BF,BF(T)=h_L-h_R. 其中_L和h_R分别为二叉树左右子树的高度。

平衡二叉树：(AVL 树）：空树，或者任一结点左、右子树高度差的绝对值不超过1. 即|BF(T)|<=1.

图中结点3和5的平衡因子均为2，因此不是平衡二叉树。最后一棵树，根节点7平衡因子为2，同样不是平衡二叉树。

对于给定结点数为n的AVL树，最大高度为O(log₂n).

也就说，从n个数中，查找一个特定值时，最多需要log₂n次。因此，AVL 是一种特别适合进行查找操作的树。

平衡二叉树的调整

四种失衡的情况

在平衡二叉树中，当我们插入新的元素时，为了保证二叉搜索树的特性，很容易导致某些结点失衡，即该结点的平衡因子大于1。

而在二叉树中，任意结点孩子最多只有左右两个，而且导致失去平衡的必要条件就是当前结点的两颗子树的高度差等于2。因此，致使一个结点失衡的插入操作有以下4中。

• 在结点的左子树的左子树插入元素,LL 插入；
• 在结点的左子树的右子树插入元素,LR 插入；
• 在结点的右子树的左子树插入元素,RL 插入；
• 在结点的右子树的右子树插入元素,RR 插入。

• LL(一）中结点1的插入导致结点8失衡，而插入的位置是在其左子树的左子树上，同样LL(二）中，结点3插入同样导致结点8失衡，这里需要注意子树是从受影响的结点算起，虽然3插在了右边，但他依旧是在8（失衡结点）左子树的左子树上，因此属于LL 插入。
• LR(一）,结点5插入导致结点8失衡，插入位置是在其左子树的右子树上，同样LR(二)结点7的插入也是同理，因此这二者都属于LR 插入。

后面两种失衡现象可以当做是前两者的镜像，原理都是一样的。

对四种失衡情况的调整策略

面对以上4种失衡的情况，在AVL 树中将采用LL(左左)，LR(左右)，RR(右右)和RL(右左) 四种旋转方式进行调整。

1. LL(左左）旋转

如图，这种情况下B_L结点插入元素导致结点A失衡，因此我们的操作就是围绕失衡的结点（图中A）和导致其失衡的结点（图中B）进行。具体来说就是围绕结点B 将树顺时针（左手）旋转，最终结果就是B成为了根节点（相对而言），A 变成了B的右子树，而B原来的右子树（B_R）变成了A 的左子树。

看一下代码实现：

    /**
     * 左旋
     *
     * @param node 失衡结点 
     * @return 旋转后根节点
     */
    private TreeNode<T> leftRotate(TreeNode<T> node) {
        // 将失衡结点的左子树赋给一个临时结点，也就是将A的左子树B 赋给新的结点
        TreeNode<T> newRoot = node.leftChild;
        // 将B 被右子树BR 挂在A 的左子树上
        node.leftChild = newRoot.rightChild;
        // B 的右子树为失衡的结点即A
        newRoot.rightChild = node;
        // 结点A 的高度为左右子树高度最大值加1
        node.height = getMax(height(node.leftChild), height(node.rightChild)) + 1;
        // 结点B 的高度为左右子树高度最大值加1
        newRoot.height = getMax(height(newRoot.leftChild), newRoot.height) + 1;
        // 返回根节点
        return newRoot;
    }

结合注释应该很好理解。

2. RR(右右）旋转

理解了LL，RR就是同理了，围绕的同样是导致失衡的结点B,只不过旋转方向变成了逆时针（右手向内）。

    /**
     * 右旋
     *
     * @param node
     * @return
     */
    private TreeNode<T> rightRotate(TreeNode<T> node) {
        TreeNode<T> newRoot = node.rightChild;
        node.rightChild = newRoot.leftChild;
        newRoot.leftChild = node;

        node.height = getMax(height(node.leftChild), height(node.rightChild)) + 1;
        newRoot.height = getMax(height(newRoot.rightChild), node.height) + 1;

        return newRoot;
    }

3. LR(右左）旋转

看上面的图可能有点晕，这里看以具体的例子。

上图中Jan结点的插入导致May结点失衡，而Jan结点又处在May结点左子树的右子树上，是LR 插入导致的失衡，面对这种情况我们可以进行LR旋转，需要关注的三个结点是May,Aug和Mar。具体来说，LR 旋转可以分解为RR旋转和LL旋转。首先围绕Aug和Mar,进行一次RR旋转，然后围绕Mar和May在进行一次LL旋转。这样最终就完成了LR 旋转，最终的结果是树仍然为AVL树。

    /**
     * LR 左右旋转
     *
     * @param node
     * @return
     */
    private TreeNode<T> leftRightRotate(TreeNode<T> node) {
        // 首先围绕失衡结点的左子树(图中Aug) 和Mar进行一次右旋，这样Mar 和 Aug 换了位置
        node.leftChild = rightRotate(node.leftChild);
        // 最后，围绕May和Mar进行一次左旋
        return leftRotate(node);
    }

4. RL(左右）旋转

前面说过了，RL其实就是LR 的镜像，因此这里道理都是一样的，只过顺序颠倒而已。

/**
     * RL 右左旋转
     *
     * @param node
     * @return
     */
    private TreeNode<T> rightLeftRotate(TreeNode<T> node) {
        node.rightChild = leftRotate(node.rightChild);
        return rightRotate(node);
    }

AVL 树的实现

以上就是AVL 树所有的理论基础，下面看看如何去实现。

• 结点的定义

AVL 树首先是二叉搜索树，因此它的结点也必须是可比较。同时为了方便，会加入一个表示当前结点高度的height字段。

/**
 * Created by engineer on 2017/10/31.
 *
 * AVL 树节点定义
 */

public class TreeNode<T extends Comparable<T>> {

    // 数据域
    private T data;
    // 左子树
    public TreeNode<T> leftChild;
    // 右子树
    public TreeNode<T> rightChild;

    //当前结点的高度
    public int height;


    public TreeNode(T data) {
        this(null, data, null);
    }

    public TreeNode(TreeNode leftChild, T data, TreeNode rightChild) {
        this(data, leftChild, rightChild, 0);
    }

    public TreeNode(T data, TreeNode<T> leftChild, TreeNode<T> rightChild, int height) {
        this.data = data;
        this.leftChild = leftChild;
        this.rightChild = rightChild;
        this.height = height;
    }

    public T getData() {
        return data;
    }

    public TreeNode<T> getLeftChild() {
        return leftChild;
    }

    public TreeNode<T> getRightChild() {
        return rightChild;
    }

    public void setData(T data) {
        this.data = data;
    }

    public int getHeight() {
        return height;
    }

    public void setHeight(int height) {
        this.height = height;
    }
}

• 平衡二叉树插入

/**
     * 插入结点
     *
     * @param value
     */
    public void insert(T value) {
        root = insert(root, value);
    }

    private TreeNode<T> insert(TreeNode<T> node, T value) {
        if (node == null) {
            // 新建节点
            node = new TreeNode<T>(value);
            if (node == null) {
                return null;
            }
        } else {
            int cmp = value.compareTo(node.getData());

            if (cmp < 0) {    // 应该将value插入到"node的左子树"的情况
                node.leftChild = insert(node.leftChild, value);
                // 插入节点后，若AVL树失去平衡，则进行相应的调节。
                if (height(node.leftChild) - height(node.rightChild) == 2) {
                    if (value.compareTo(node.leftChild.getData()) < 0)
                        node = leftRotate(node);
                    else
                        node = leftRightRotate(node);
                }
            } else if (cmp > 0) {    // 应该将value插入到"node的右子树"的情况
                node.rightChild = insert(node.rightChild, value);
                // 插入节点后，若AVL树失去平衡，则进行相应的调节。
                if (height(node.rightChild) - height(node.leftChild) == 2) {
                    if (value.compareTo(node.rightChild.getData()) > 0)
                        node = rightRotate(node);
                    else
                        node = rightLeftRotate(node);
                }
            } else {    // cmp==0
                System.out.println("添加失败：不允许添加相同的节点！");
            }
        }

        node.height = getMax(height(node.leftChild), height(node.rightChild)) + 1;

        return node;
    }

测试平衡二叉树

public class AvlTreeTest {

    private static Integer[] arrays = new Integer[]{10, 8, 3, 12, 9, 4, 5, 7, 1, 11, 17};

    public static void main(String[] args) {
        AvlTree<Integer> mAvlTree = new AvlTree<>();
        for (int i = 0; i < arrays.length; i++) {
            mAvlTree.insert(arrays[i]);
        }

        mAvlTree.printTree();
    }
}

这里我们测试平衡二叉树采用和上一节二叉搜索树中同样的数据。首先看一下树遍历打印结果：

前序遍历：8 4 3 1 5 7 10 9 12 11 17 
中序遍历：1 3 4 5 7 8 9 10 11 12 17 
后序遍历：1 3 7 5 4 9 11 17 12 10 8 

这样的遍历的结构，相对应的二叉树将是如下：

在和上一节构造的二叉树对比一下:

很明显，平衡二叉树是一种更加友好的搜索树，在平衡二叉树中查找7这个元素，最大比较4次，而在普通的二叉搜索树中需要找6次。总体来说，平衡二叉树结合平衡因子构造出了一颗十分便于查找的二叉搜索树。

好了，平衡二叉树就到这里了。

---

参考文档

AVL树(三)之 Java的实现