操作:
- GP 置红
- P 置黑
- P 左旋
- 继续执行 case 5 逻辑
左右
: P是GP的左儿子, I是P的右儿子左旋之后
: 转变成了 case 5三角形
: 代表子树, 可能由 case 4 递归到本case 导致有子树结构
case 8: 父节点是红, 叔节点是黑/Nil, 右左
操作:
- GP 置红
- P 置黑
- P 右旋
- 继续执行 case 6 逻辑
右左
: P是GP的右儿子, I是P的左儿子右旋之后
: 转变成了 case 6三角形
: 代表子树, 可能由 case 4 递归到本case 导致有子树结构
public void insert(int v) {
final Node node = new Node();
node.left = node.right = node.parent = null;
node.black = false;
node.value = v;
// case 1: 插入节点是根
if (root == null) {
root = node;
root.black = true;
return;
} else {
Node p = findParent(v);
// case 2: 插入值重复
if (p == null) {
return;
}
setParent(node, p);
if (v > p.value) {
p.right = node;
} else {
p.left = node;
}
fixInsert(node);
}
}
// 找到属于v的parent准备插入
private Node findParent(int v) {
Node pre = root;
Node index = root;
while (index != null) {
// 找到相同值直接返回
if (index.value == v) {
return null;
}
pre = index;
index = v < index.value ? index.left : index.right;
}
return pre;
}
// 平衡红黑树
private void fixInsert(Node node) {
final Node parent = node.parent;
final Node uncle = node.uncle();
final Node grandparent = node.grandparent();
// case 1: 插入节点是根
if (parent == null) {
root = node;
root.black = true;
}
// case 3: 插入节点的 父亲 是黑
else if (parent != null && parent.black) {
// do nothing
}
else if (parent != null && !parent.black) {
// case 4: 插入节点的 父亲 是红, 叔叔 也是红
if (uncle != null && !uncle.black) {
parent.black = true;
uncle.black = true;
// 有叔叔必定有祖父
grandparent.black = false;
// 祖父的父亲是 红, 和祖父冲突了
fixInsert(grandparent);
}
else if (uncle == null || uncle.black) {
// case 5: 叔叔 是黑/空, 左左
if (parent == grandparent.left && node == parent.left) {
parent.black = true;
grandparent.black = false;
rotateRight(grandparent);
}
// case 6: 叔叔 是黑/空, 左右
else if (parent == grandparent.left && node == parent.right) {
rotateLeft(parent);
fixInsert(parent);
}
// case 7: 叔叔 是黑/空, 右右
else if (parent == grandparent.right && node == parent.right) {
parent.black = true;
grandparent.black = false;
rotateLeft(grandparent);
}
// case 8: 叔叔 是黑/空, 右左
else if (parent == grandparent.right && node == parent.left) {
rotateRight(parent);
fixInsert(parent);
}
}
}
}
算法时间复杂度
对于有n个节点的树(由于树的高度趋近logn), f(n) = logn次左右查找对比 + 最多只需要2次旋转 + logn次的颜色替换 = O(logn) + O(1) + O(1) = O(logn)
由于颜色替换十分迅速, 这里可以把logn次替换看成是O(1)复杂度
3. 删除
需要明白的是, 所有的删除操作最终都会变成删除一个叶子节点, 比如下图
以下图示约定
case 1: 树空
操作:
- 删除失败
case 2: 无匹配项
操作:
- 删除失败
case 3: d 是红
操作:
- 直接删除
case 4: d 是黑, s 是红
操作:
- P 置红
- S 置黑
- P 左旋(D 是左儿子) 或者 右旋(D 是右儿子)
- 旋转之后兄弟节点就变为黑色了, 递归到下面的 case 5, 6, 7 进行处理
三角形
: 代表子树, 可能由 case 7,递归到本case 导致有子树结构递归处理
: 之所以需要递归处理, 是因为在旋转之后, 所有路径的黑色节点数和旋转前一样, 若 D节点路径中少了一个黑色节点, 不满足性质6了,需要递归处理一下
P 左旋(D 是左儿子)
右旋(D 是右儿子)
case 5.1: d 是黑, s 是黑, s 右孩子是红 且 d 是左孩子
操作:
- P 和 S 颜色互换
- P 左旋
三角形
: 代表子树, 可能由 case 4,6,7 ,递归到本case 导致有子树结构左旋
: 左旋之后直接平衡了, 可以由下图, 看出, 所有路径旋转之后 D 节点路径中多了一个黑色节点, 其他路径黑色节点数都没变化, 而我们恰巧需要删除 D节点中的一个黑色节点, 至此, 满足性质6, 红黑树刚好平衡
case 5.2: d 是黑, s 是黑, s 左孩子是红 且 d 是右孩子
操作:
- P 和 S 颜色互换
- P 右旋
case 6.1: d 是黑, s 是黑, s 左孩子是红 且 d 是左孩子
操作:
- S 置红, SL 置黑
- S 右旋
- 树的结构就切换成了 case 5.1 的模样, 递归使用 case 5.1 解决
case 6.2: d 是黑, s 是黑, s 右孩子是红 且 d 是右孩子
操作:
- S 置红, SR 置黑
- S 左旋
- 树的结构就切换成了 case 5.2 的模样, 递归使用 case 5.2 解决
case 7: d 是黑, s sl sr 全是黑
操作:
- S 置红
- 递归 P 节点, 平衡红黑树
递归
: S 置红会导致右子树路径上黑节点数量少1, 左子树由于 D(黑节点) 将被删除, 所以路径上黑节点数也会少1, 符合性质6, 但是此时 P 所在树整体所有路径黑色节点数少1, 需要向上递归平衡红黑树
public Node remove(int num) {
// case 1: 树空, 删除失败
if (root == null) {
return null;
} else {
final Node numNode = findNum(root, num);
// case 2: 无匹配项, 删除失败
if (numNode == null) {
return null;
}
// 此时, replaceNode 一定是个叶子节点
final Node replaceNode = findReplaceNode(numNode);
if (replaceNode.black) {
// 所有的删除操作最后都被转换成一种情况, 删除一个叶子节点
fixRemove(replaceNode);
}
replaceNode.value = num;
replaceNode.black = numNode.black;
if (replaceNode.parent != null) {
if (replaceNode.parent.left == replaceNode) {
replaceNode.parent.left = null;
} else {
replaceNode.parent.right = null;
}
}
replaceNode.parent = null;
return replaceNode;
}
}
// 平衡红黑树
// r: 替换的节点
private void fixRemove(Node d) {
final Node p = d.parent;
final Node s = d.sibling();
final Node sL = d.siblingLeft();
final Node sR = d.siblingRight();
// case 1: 替换的是根节点
if (root == d) {
root = null;
}
// case 3: 替换的是 红
else if (!d.black) {
// do nothing
d.black = true;
}
// 替换的是 黑
else if (d.black) {
// case 4: s 是红, 可以借, 旋转
if (s != null && !s.black) {
p.black = false;
s.black = true;
if (s == p.left) {
rotateRight§;
} else {
rotateLeft§;
}
fixRemove(d);
} else if ((s == null || s.black)) {
// case 5.1: s是黑, sL是红, r是p的右节点
if ((sL != null && !sL.black) && d == p.right) {
s.black = p.black;
p.black = true;
sL.black = true;
rotateRight§;
}
// case 5.2: s是黑, sR是红, r是p的左节点
else if ((sR != null && !sR.black) && d == p.left) {
s.black = p.black;
p.black = true;
sR.black = true;
rotateLeft§;
}
// case 6.1: s是黑, sL是红, r是p的左节点
else if ((sL != null && !sL.black) && d == p.left) {
s.black = false;
sL.black = true;
rotateRight(s);
fixRemove(d);
}
// case 6.2: s是黑, sR是红, r是p的右节点
else if ((sR != null && !sR.black) && d == p.right) {
s.black = false;
sR.black = true;
rotateLeft(s);
fixRemove(d);
}
}
// case 7: s == sL == sR 全黑
else if ((s == null || s.black) && (sL == null || sL.black) && (sR == null || sR.black)) {
s.black = false;
fixRemove§;
}
}
}
算法时间复杂度
从流程图看:
对于有n个节点的树(由于树的高度趋近logn), f(n) = 查找替换比对次数logn + 变色次数logn + case4 旋转次数logn + case5,6旋转次数2 = 2logn
变色次数logn: 由于变色操作消耗较小, 故可以看成是 O(1)
不对啊, 网上不都说至多旋转三次吗? 怎么从流程图看 case4旋转 会被调用logn次???
最后
光有这些思路和搞懂单个知识的应用是还远远不够的,在Android开源框架设计思想中的知识点还是比较多的,想要搞懂还得学会整理和规划:我们常见的**Android热修复框架、插件化框架、组件化框架、图片加载框架、网络访问框架、RxJava响应式编程框架、IOC依赖注入框架、最近架构组件Jetpack等等Android第三方开源框架,**这些都是属于Android开源框架设计思想的。如下图所示:
这位阿里P8大佬针对以上知识点,熬夜整理出了一本长达1042页的完整版如何解读开源框架设计思想PDF文档,内容详细,把Android热修复框架、插件化框架、组件化框架、图片加载框架、网络访问框架、RxJava响应式编程框架、IOC依赖注入框架、最近架构组件Jetpack等等Android第三方开源框架这些知识点从源码分析到实战应用都讲的简单明了。
由于文档内容过多,篇幅受限,只能截图展示部分
整理不易,觉得有帮助的朋友可以帮忙点赞分享支持一下小编~
你的支持,我的动力;祝各位前程似锦,offer不断!!!
《Android学习笔记总结+移动架构视频+大厂面试真题+项目实战源码》,点击传送门,即可获取!
访问框架、RxJava响应式编程框架、IOC依赖注入框架、最近架构组件Jetpack等等Android第三方开源框架这些知识点从源码分析到实战应用都讲的简单明了。**
由于文档内容过多,篇幅受限,只能截图展示部分
[外链图片转存中…(img-OFzb8zdh-1715326903737)]
[外链图片转存中…(img-s9eMEA9Y-1715326903738)]
整理不易,觉得有帮助的朋友可以帮忙点赞分享支持一下小编~
你的支持,我的动力;祝各位前程似锦,offer不断!!!
《Android学习笔记总结+移动架构视频+大厂面试真题+项目实战源码》,点击传送门,即可获取!