1.二叉平衡树

本节目标：

• 二叉搜索树回顾以及性能分析
• AVL树
• 红黑树

1.二叉搜索树回顾以及性能分析

1.1二叉搜索树的概念：

二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树：

• 若它的左子树部位空，则左子树所有的节点的值都小于根节点的值
• 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值
• 它的左右子树也分别为二叉搜索树（所以是递归定义）

1.2二叉搜索树的查找

既然将其称之为二叉搜索树，因此这棵树最主要的作用是进行查询，而且其查询原理特别简单，具体如下：

插入和删除操作，也都是建立在查找的基础之上的，那么请同学思考：二叉搜索树的查找效率是多少呢？ 

1.3二叉树查询性能分析

插入和删除操作都必须先查找，查找效率代表了二叉搜索树中各个操作的性能。
对有n个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树平均查找长度是结点在二叉搜索树的深度的函数，即结点越深，则比较次数越多。
但对于同一个关键码集合，如果各关键码插入的次序不同，可能得到不同结构的二叉搜索树：

最优情况下，二叉搜索树为完全二叉树，其平均比较次数为：log2N(也就是说树有多深，比几次，这个很好想，因为是按照层往下比的）
最差情况下，二叉搜索树退化为单支树，其平均比较次数为：N/2 （这个是通过头节点和尾节点改进后的，如果只有头或者尾，就是 N）
问题：如果退化成单支树，二叉搜索树的性能就失去了。那能否进行改进，不论按照什么次序插入关键码，都可以是二叉搜索树的性能最佳？

2.AVL树

2.1 AVL树的概念

二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当于在顺序表中搜索元素，效率低下。因此，两位俄罗斯的数学家G.M.Adelson-Velskii和E.M.Landis在1962年 发明了一种解决上述问题的方法：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度。
一棵AVL树或者是空树，或者是具有以下性质的二叉搜索树：

• 它的左右子树都是AVL树
• 左右子树高度之差(简称平衡因子)的绝对值不超过1(-1/0/1)

如果一棵二叉搜索树是高度平衡的，它就是AVL树。如果它有n个结点，其高度可保持在，搜索时间复杂
度O( log2N)。

2.2 AVL树节点的定义
为了AVL树实现简单，AVL树节点在定义时维护一个平衡因子，具体节点定义如下：

// 节点类，定义AVL树节点
class AVLTreeNode {
    private AVLTreeNode left;   // 左孩子
    private AVLTreeNode right;  // 右孩子
    private AVLTreeNode parent; // 双亲
    private int val;            // 节点值
    private int bf;             // 平衡因子（右子树高度 - 左子树高度）

    public AVLTreeNode(int val) {
        this.val = val;
        this.left = null;
        this.right = null;
        this.parent = null;
        this.bf = 0;
    }

    // Getter和Setter方法
    public int getVal() { return val; }
    public int getBf() { return bf; }
    public void setBf(int bf) { this.bf = bf; }
    public AVLTreeNode getLeft() { return left; }
    public void setLeft(AVLTreeNode left) { this.left = left; }
    public AVLTreeNode getRight() { return right; }
    public void setRight(AVLTreeNode right) { this.right = right; }
    public AVLTreeNode getParent() { return parent; }
    public void setParent(AVLTreeNode parent) { this.parent = parent; }
}

注意：
当前节点的平衡因子=右子树高度-左子树的高度。但是，不是每棵树，都必须有平衡因子，这只是其中的一种实现方式。

2.3 AVL树的插入
AVL树就是在二叉搜索树的基础上引入了平衡因子，因此AVL树也可以看成是二叉搜索树。那么AVL树的插入过程可以分为两步：

1.  按照二叉搜索树的方式插入新节点
2. 调整节点的平衡因子

 // 插入方法
    public void insert(int val) {
        if (root == null) {
            root = new AVLTreeNode(val);
            return;
        }

        AVLTreeNode newNode = new AVLTreeNode(val);
        AVLTreeNode cur = root;
        AVLTreeNode parent = null;

        // 找到插入位置
        while (cur != null) {
            parent = cur;
            if (val < cur.getVal()) {
                cur = cur.getLeft();
            } else if (val > cur.getVal()) {
                cur = cur.getRight();
            } else {
                return; // 忽略重复值
            }
        }

        // 插入新节点
        newNode.setParent(parent);
        if (val < parent.getVal()) {
            parent.setLeft(newNode);
        } else {
            parent.setRight(newNode);
        }

        // 更新平衡因子并平衡树
        updateBalance(newNode);
    }

2.4 AVL树的旋转
如果在一棵原本是平衡的AVL树中插入一个新节点，可能造成不平衡，此时必须调整树的结构，使之平衡化。根据节点插入位置的不同，AVL树的旋转分为四种：
1. 新节点插入较高左子树的左侧---右单旋

2. 新节点插入较高右子树的右侧---左单旋

3. 新节点插入较高左子树的右侧：先左单旋再右单旋【左右双旋】

4. 新节点插入较高右子树的左侧---右左：先右单旋再左单旋【右左双旋】

总结：

新节点插入后，假设以pParent为根的子树不平衡，即pParent的平衡因子为2或者-2，分以下情况考虑
1. pParent的平衡因子为2，说明pParent的右子树高，设pParent的右子树的根为pSubR
当pSubR的平衡因子为1时，执行左单旋
当pSubR的平衡因子为-1时，执行右左双旋
2. pParent的平衡因子为-2，说明pParent的左子树高，设pParent的左子树的根为pSubL
当pSubL的平衡因子为-1是，执行右单旋
当pSubL的平衡因子为1时，执行左右双旋
即：pParent与其较高子树节点的平衡因子时同号时单旋转，异号时双旋转。
旋转完成后，原pParent为根的子树个高度降低，已经平衡，不需要再向上更新。

2.5AVL树的验证：

AVL树是在二叉搜索树的基础上加入了平衡性的限制，因此要验证AVL树，可以分两步：
1. 验证其为二叉搜索树
如果中序遍历可得到一个有序的序列，就说明为二叉搜索树

2. 验证其为平衡树
每个节点子树高度差的绝对值不超过1(注意节点中如果没有平衡因子)
节点的平衡因子是否计算正确

3.验证用例

自己动手画AVL树的创建过程，验证代码是否有漏洞。

2.6AVL树的删除（了解）

因为AVL树也是二叉搜索树，可按照二叉搜索树的方式将节点删除，然后再更新平衡因子，只不过与删除不同的是，删除节点后的平衡因子更新，最差情况下一直要调整到根节点的位置。

1、找到需要删除的节点
2、按照搜索树的删除规则删除节点--参考《二叉搜索树的删除》
3、更新平衡因子，如果出现了不平衡，进行旋转。--单旋，双旋

2.7AVL树性能分析：

AVL树是一棵绝对平衡的二叉搜索树，其要求每个节点的左右子树高度差的绝对值都不超过1，这样可以保证查询时高效的时间复杂度，即log2(N)。但是如果要对AVL树做一些结构修改的操作，性能非常低下，比如：插入时要维护其绝对平衡，旋转的次数比较多，更差的是在删除时，有可能一直要让旋转持续到根的位置。因此：如果需要一种查询高效且有序的数据结构，而且数据的个数为静态的(即不会改变)，可以考虑AVL树，但一个结构经常修改，就不太适合。

3.红黑树

3.1红黑树概念

红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的。

3.2红黑树的性质

1.最长路径最多是最短路径的两倍。

2.每个节点不是红色就是黑色

3.根节点是黑色的

4.如果一个节点是红色的，则它的两个孩子一定是黑色的（没有两个连续的红色节点）

5.对于每个节点，从该节点到其所有后代叶节点的简单路径上，均包含相同数目的黑色节点

6.每个叶子节点都是黑色的（此处的叶子节点指的是空节点）

思考：为什么满足上面的性质，红黑树就能保证：其最长路径中节点个数不会超过最短路径节点个数的两倍？

3.3红黑树节点的定义

思考：在节点的定义中，为什么要将节点的默认颜色给成红色的？

3.4 红黑树的插入
红黑树是在二叉搜索树的基础上加上其平衡限制条件，因此红黑树的插入可分为两步：
1. 按照二叉搜索的树规则插入新节点
2. 检测新节点插入后，红黑树的性质是否造到破坏
因为新节点的默认颜色是红色，因此：如果其双亲节点的颜色是黑色，没有违反红黑树任何性质，则不需要调整；但当新插入节点的双亲节点颜色为红色时，就违反了性质三不能有连在一起的红色节点，此时需要对红黑树分情况来讨论：
约定:cur为当前节点，p为父节点，g为祖父节点，u为叔叔节点
情况一: cur为红，p为红，g为黑，u存在且为红

cur和p均为红，违反了性质三，此处能否将p直接改为黑？
解决方式：将p,u改为黑，g改为红，然后把g当成cur，继续向上调整。
情况二: cur为红，p为红，g为黑，u不存在/u为黑

p为g的左孩子，cur为p的左孩子，则进行右单旋转；相反，
p为g的右孩子，cur为p的右孩子，则进行左单旋转
p、g变色--p变黑，g变红
情况三: cur为红，p为红，g为黑，u不存在/u为黑

p为g的左孩子，cur为p的右孩子，则针对p做左单旋转；相反，
p为g的右孩子，cur为p的左孩子，则针对p做右单旋转
则转换成了情况2

针对每种情况进行相应的处理即可。

// 插入操作
public void insert(int val) {
    if (root == null) {
        root = new RBTreeNode(val);
        root.setRed(false); // 根节点必须黑
        return;
    }

    RBTreeNode newNode = new RBTreeNode(val);
    RBTreeNode cur = root;
    RBTreeNode parent = null;

    while (cur != null) {
        parent = cur;
        if (val < cur.getVal()) {
            cur = cur.getLeft();
        } else if (val > cur.getVal()) {
            cur = cur.getRight();
        } else {
            return; // 忽略重复值
        }
    }

    newNode.setParent(parent);
    if (val < parent.getVal()) {
        parent.setLeft(newNode);
    } else {
        parent.setRight(newNode);
    }

    fixInsert(newNode);
}

private void fixInsert(RBTreeNode node) {
    while (node.getParent() != null && node.getParent().isRed()) {
        RBTreeNode parent = node.getParent();
        RBTreeNode grandparent = parent.getParent();
        RBTreeNode uncle = (grandparent.getLeft() == parent) ? grandparent.getRight() : grandparent.getLeft();

        if (uncle != null && uncle.isRed()) {
            parent.setRed(false);
            uncle.setRed(false);
            grandparent.setRed(true);
            node = grandparent;
        } else {
            if (parent == grandparent.getLeft()) {
                if (node == parent.getRight()) {
                    rotateLeft(parent);
                    node = parent;
                    parent = node.getParent();
                }
                rotateRight(grandparent);
                boolean tempColor = parent.isRed();
                parent.setRed(grandparent.isRed());
                grandparent.setRed(tempColor);
            } else {
                if (node == parent.getLeft()) {
                    rotateRight(parent);
                    node = parent;
                    parent = node.getParent();
                }
                rotateLeft(grandparent);
                boolean tempColor = parent.isRed();
                parent.setRed(grandparent.isRed());
                grandparent.setRed(tempColor);
            }
            break;
        }
    }
    root.setRed(false);
}

从这里可以看出来，确实是三种情况，并且，可以将遇到情况三，先进行旋转，然后使用2的逻辑。

动态演示效果：

以升序插入构建红黑树

以降序插入构建红黑树

随机插入构建红黑树

3.4红黑树验证：

红黑树的检测分为两步：

1.检测其是否满足二叉搜索树（中序遍历是否是有序序列）

2.检测其是否满足红黑树的性质

3.5红黑树的删除

http://www.cnblogs.com/fornever/archive/2011/12/02/2270692.html
http://blog.youkuaiyun.com/chenhuajie123/article/details/11951777

3.5AVL树和红黑树的比较

红黑树和AVL树都是高效的平衡二叉树，增删改查的时间复杂度都是O(log2N )，红黑树不追求绝对平衡，其只需保证最长路径不超过最短路径的2倍，相对而言，降低了插入和旋转的次数，所以在经常进行增删的结构中性能比AVL树更优，而且红黑树实现比较简单，所以实际运用中红黑树更多。

3.7红黑树的应用：

1. java集合框架中的：TreeMap、TreeSet底层使用的就是红黑树
2. C++ STL库 -- map/set、mutil_map/mutil_set
3. linux内核：进程调度中使用红黑树管理进程控制块，epoll在内核中实现时使用红黑树管理事件块
4. 其他一些库：比如nginx中用红黑树管理timer等