文章目录
提示:以下是本篇文章正文内容, 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_set
- linux 内核:进程调度中使用红黑树管理进程控制块, 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高阶数据结构的学习,剖析红黑树底层原理,红黑树的时间复杂度,红黑树的插入以及插入时的平衡调整。之后的学习内容将持续更新!!!