文章目录

提示：以下是本篇文章正文内容，Java系列学习将会持续更新

一、红黑树的概念

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

红黑树的性质:最长路径最多是最短路径的2倍

原因 ：每条路径黑色节点数相同，则 最短路径 = 没有红色节点的路径 (一般不会出现这种极端情况)；最长路径 = 红色节点最多的路径(由于红色节点不能连续，所以最多也就是和黑色节点数相同)。所以, 最长路径 = 2 x 最短路径 = 2 x 黑色节点数每个结点不是红色就是黑色根节点是黑色的如果一个节点是红色的，则它的两个孩子结点是黑色的【 没有2个连续的红色节点 】对于每个结点，从该结点到其所有后代叶结点的简单路径上，均包含 相同数目的黑色结点每个叶子结点都是黑色的 (此处的叶子结点指的是空结点)二、插入和调整

红黑树是在二叉搜索树的基础上加上其平衡限制条件，因此红黑树的插入可分为两步：

按照二叉搜索的树规则插入新节点检测新节点插入后，红黑树的性质是否造到破坏

因为新节点的默认颜色是红色，因此：如果其 双亲节点的颜色是黑色 ，没有违反红黑树任何性质，则不需要调整；但当新插入节点的 双亲节点颜色为红色时 ，就违反了性质三不能有连在一起的红色节点，此时需要对红黑树分情况来讨论。

约定: cur为当前节点，p为父节点，u为叔叔节点，g为祖父节点。

情况一: cur为红，p为红，g为黑，u存在且为红解决方式：将p,u改为黑，g改为红，然后把g当成cur，继续向上调整。情况二: cur为红，p为红，g为黑，u不存在/u为黑说明: u的情况有两种如果u节点不存在，则cur- -定是新插入节点，因为如果cur不是新插入节点，则cur和p一定有一个节点的颜色是黑色，就不满足性质4:每条路径黑色节点个数相同。如果u节点存在,则其-定是黑色的，那么cur节点原来的颜色一定是黑色的,现在看到其是红色的原因是因为cur的子树在调整的过程中将cur节点的颜色由黑色改成红色。

解决方式：

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

四、删除

我们知道删除需先找到“替代点”来替代删除点而被删除，也就是删除的是替代点，而替代点N的至少有一个子节点为NULL，那么，若N为红色，则两个子节点一定都为NULL（必须地），那么直接把N删了，不违反任何性质，ok，结束了；若N为黑色，另一个节点M不为NULL，则另一个节点M一定是红色的，且M的子节点都为NULL（按性质来的，不明白，自己分析一下）那么把N删掉，M占到N的位置，并改为黑色，不违反任何性质，ok，结束了；若N为黑色，另一个节点也为NULL，则把N删掉，该位置置为NULL，显然这个黑节点被删除了，破坏了性质5，那么要以N节点为起始点检索看看属于那种情况，并作相应的操作，另还需说明N为黑点（也许是NULL，也许不是，都一样），P为父节点，S为兄弟节点（这个我真想给兄弟节点叫B（brother）多好啊，不过人家图就是S我也不能改，在重画图，太浪费时间了！S也行呵呵，就当是sister也行，哈哈）分为以下5中情况：

情形1：S为红色（那么父节点P一定是黑，子节点一定是黑），N是P的左孩子（或者N是P的右孩子）。

操作：P、S变色，并交换----相当于AVL中的右右中旋转即以P为中心S向左旋（或者是AVL中的左左中的旋转），未结束。

解析：我们知道P的左边少了一个黑节点，这样操作相当于在N头上又加了一个红节点----不违反任何性质，但是到通过N的路径仍少了一个黑节点，需要再把对N进行一次检索，并作相应的操作才可以平衡（暂且不管往下看）。

情形2：P、S及S的孩子们都为黑。

操作：S改为红色，未结束。

解析：S变为红色后经过S节点的路径的黑节点数目也减少了1，那个从P出发到其叶子节点到所有路径所包含的黑节点数目（记为num）相等了。但是这个num比之前少了1，因为左右子树中的黑节点数目都减少了！一般地，P是他父节点G的一个孩子，那么由G到其叶子节点的黑节点数目就不相等了，所以说没有结束，需把P当做新的起始点开始向上检索。

情形3：P为红（S一定为黑），S的孩子们都为黑。

操作：P该为黑，S改为红，结束。

解析：这种情况最简单了，既然N这边少了一个黑节点，那么S这边就拿出了一个黑节点来共享一下，这样一来，S这边没少一个黑节点，而N这边便多了一个黑节点，这样就恢复了平衡，多么美好的事情哈！

情形4：P任意色，S为黑，N是P的左孩子，S的右孩子SR为红，S的左孩子任意（或者是N是P的右孩子，S的左孩子为红，S的右孩子任意）。

操作：SR（SL）改为黑，P改为黑，S改为P的颜色，P、S变换--这里相对应于AVL中的右右中的旋转（或者是AVL中的左左旋转），结束。

解析：P、S旋转有变色，等于给N这边加了一个黑节点，P位置（是位置而不是P）的颜色不变，S这边少了一个黑节点；SR有红变黑，S这边又增加了一个黑节点；这样一来又恢复了平衡，结束。

情形5：P任意色，S为黑，N是P的左孩子，S的左孩子SL为红，S的右孩子SR为黑（或者N是P的有孩子，S的右孩子为红，S的左孩子为黑）。

操作：SL（或SR）改为黑，S改为红，SL（SR）、S变换；此时就回到了情形4，SL（SR）变成了黑S，S变成了红SR（SL），做情形4的操作即可，这两次变换，其实就是对应AVL的右左的两次旋转（或者是AVL的左右的两次旋转）。

解析：这种情况如果你按情形4的操作的话，由于SR本来就是黑色，你无法弥补由于P、S的变换（旋转）给S这边造成的损失！所以我没先对S、SL进行变换之后就变为情形4的情况了，何乐而不为呢？

五、性能分析

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

红黑树的应用：java集合框架中的：TreeMap、TreeSet底层使用的就是红黑树C++ STL库 – map/set、mutil_map/mutil_setlinux内核：进程调度中使用红黑树管理进程控制块，epoll在内核中实现时使用红黑树管理事件块其他一些库：比如nginx中用红黑树管理timer等六、完整代码

public class RBTree {     class RBTreeNode {         RBTreeNode left = null;        RBTreeNode right = null;        RBTreeNode parent = null;        COLOR color; // 节点的颜色        int val;        public RBTreeNode(int val) {             this.val = val;            // 默认新增节点为红色            this.color = COLOR.RED;        }    }    public RBTreeNode root;    // 插入    public boolean insert(int val) {         RBTreeNode node = new RBTreeNode(val);        if (root == null) {             this.root = node;            root.color = COLOR.BLACK;            return true;        }        RBTreeNode parent = null;        RBTreeNode cur = root;        while (cur != null) {             if (val == cur.val) {                 return false;            } else if (val < cur.val) {                 parent = cur;                cur = cur.left;            } else {                 parent = cur;                cur = cur.right;            }        }        // 此时，cur = null        if (val < parent.val) {             parent.left = node;        } else {             parent.right = node;        }        node.parent = parent;        cur = node;        // 调整颜色        // 新节点插入后，如果parent节点的颜色是红色，一定违反性质三        while (parent != null && parent.color == COLOR.RED) {             RBTreeNode grandFather = parent.parent;            if (parent == grandFather.left) {                 RBTreeNode uncle = grandFather.right;                if (uncle != null && uncle.color == COLOR.RED) {                     // 情况一：叔叔节点存在且为红,                    // 解决方式：将叔叔和父节点改为黑色，祖父节点改为红色                    // 如果祖父的双亲节点的颜色是红色，需要继续往上调整                    parent.color = COLOR.BLACK;                    uncle.color = COLOR.BLACK;                    grandFather.color = COLOR.RED;                    // 把 g当成cur，继续向上调整                    cur = grandFather;                    parent = cur.parent;                } else {  // 此时，叔叔节点不存在 || 叔叔节点存在，但是颜色是黑色                    // 再讨论cur是左孩子还是右孩子 ?                    if (cur == parent.left) {                         // 情况二                        rotateR(grandFather);                        parent.color = COLOR.BLACK;                        grandFather.color = COLOR.RED;                    } else {                         // 情况三                        rotateL(parent);                        RBTreeNode temp = parent;                        parent = cur;                        cur = temp;                    }                }            } else {                 // parent == grandFather.right                // 以上情况是插入左边，此时是插入到右边，原理一样                RBTreeNode uncle = grandFather.left;                if (uncle != null && uncle.color == COLOR.RED) {                     // 情况一：叔叔节点存在且为红,                    // 解决方式：将叔叔和父节点改为黑色，祖父节点改为红色                    // 如果祖父的双亲节点的颜色是红色，需要继续往上调整                    parent.color = COLOR.BLACK;                    uncle.color = COLOR.BLACK;                    grandFather.color = COLOR.RED;                    // 把 g当成cur，继续向上调整                    cur = grandFather;                    parent = cur.parent;                } else {  // 此时，叔叔节点不存在 || 叔叔节点存在，但是颜色是黑色                    // 再讨论cur是左孩子还是右孩子 ?                    if (cur == parent.right) {                         // 情况二                        rotateL(grandFather);                        parent.color = COLOR.BLACK;                        grandFather.color = COLOR.RED;                    } else {                         // 情况三                        rotateR(parent);                        RBTreeNode temp = parent;                        parent = cur;                        cur = temp;                    }                }            }        }        // 在上述循环更新期间，可能会将根节点给成红色，因此此处必须将根节点改为黑色        root.color = COLOR.BLACK;        return true;    }    // 左单旋    private void rotateL(RBTreeNode p) {         // p 的母节点        RBTreeNode pp = p.parent;        // p 的右孩子        RBTreeNode subR = p.right;        // subR 的左孩子，可能不存在        RBTreeNode subRL = subR.left;        // subR 提上去        if (pp == null) {             this.root = subR;        } else if (pp.left == p) {             pp.left = subR;        } else {             // pp.right == parent            pp.right = subR;        }        subR.parent = pp;        // p 作为 subR 的左孩子        subR.left = p;        p.parent = subR;        // p 与 subRL 连接        p.right = subRL;        if (subRL != null) {             subRL.parent = p;        }    }    // 右单旋    private void rotateR(RBTreeNode p) {         // p 的父节点        RBTreeNode pp = p.parent;        // p 的左孩子        RBTreeNode subL = p.left;        // subL 的右孩子，可能不存在        RBTreeNode subLR = subL.right;        if (pp == null) {             this.root = subL;        } else if (pp.left == p) {             pp.left = subL;        } else {             pp.right = subL;        }        subL.parent = pp;        subL.right = p;        p.parent = subL;        p.left = subLR;        if (subLR != null) {             subLR.parent = p;        }    }    /**     * 打印二叉树, 中序遍历的结果     **/    @Override    public String toString() {         List<Integer> list = new ArrayList<>();        inOrder(list, root);        return list.toString() + "\n" + "是否标准红黑树: " + isValidRBTree();    }    // 中序遍历    private void inOrder(List<Integer> list, RBTreeNode root) {         if (root == null) {             return;        }        inOrder(list, root.left);        list.add(root.val);        inOrder(list, root.right);    }    /**     * 检验是否符合红黑树的性质     */    private boolean isValidRBTree() {         // 空树也是红黑树        if (root == null) {             return true;        }        // 根节点是黑色        if (root.color != COLOR.BLACK) {             System.err.println("违反了性质2：根节点不是黑色");            return false;        }        // 获取单条路径中节点的个数        int blackCount = 0;        RBTreeNode cur = root;        while (cur != null) {             if (cur.color == COLOR.BLACK) {                 blackCount ++;            }            cur = cur.left;        }        // 具体的检验方式        return _isValidRBtree(root, 0, blackCount);    }    // 检验是否存在连续的红色节点    // 检验是否每条路径黑色节点数相同    private boolean _isValidRBtree(RBTreeNode root, int pathCount, int blackCount) {         if (root == null) {             return true;        }        // 遇到一个黑色节点，统计当前路径中黑色节点个数        if(root.color == COLOR.BLACK) {             pathCount ++;        }        // 验证性质4        RBTreeNode parent = root.parent;        if(parent != null && parent.color == COLOR.RED && root.color == COLOR.RED) {             System.err.println("违反了性质4：有连在一起的红色节点");            return true;        }        // 验证性质5        // 如果是叶子节点，则一条路径已经走到底，检验该条路径中黑色节点总个数是否与先前统计的结果相同        if (root.left == null && root.right == null) {             if (pathCount != blackCount) {                 System.err.println("违反了性质5：每条路径中黑色节点个数不一致");                return false;            }        }        // 以递归的方式检测 root 的左右子树        return _isValidRBtree(root.left, pathCount, blackCount) &&                _isValidRBtree(root.right, pathCount, blackCount);    }}

总结:

提示：这里对文章进行总结：

以上就是今天的学习内容，本文是Java高阶数据结构的学习，剖析红黑树底层原理，红黑树的时间复杂度，红黑树的插入以及插入时的平衡调整。之后的学习内容将持续更新！！！