数据结构(三), 弄懂红黑树RBTree(多图警告!!!)

最新推荐文章于 2024-09-05 15:16:29 发布

2401_83817971

最新推荐文章于 2024-09-05 15:16:29 发布

阅读量706

点赞数 8

分类专栏：程序员文章标签：数据结构数据库网络

本文链接：https://blog.csdn.net/2401_83817971/article/details/138669104

版权

程序员专栏收录该内容

367 篇文章 0 订阅

订阅专栏

操作:

GP 置红
P 置黑
P 左旋
继续执行 case 5 逻辑

左右: P是GP的左儿子, I是P的右儿子 左旋之后: 转变成了 case 5 三角形: 代表子树, 可能由 case 4 递归到本case 导致有子树结构

截屏2021-04-11 下午3.15.46.png

case 8: 父节点是红, 叔节点是黑/Nil, 右左

操作:

GP 置红
P 置黑
P 右旋
继续执行 case 6 逻辑

右左: P是GP的右儿子, I是P的左儿子 右旋之后: 转变成了 case 6 三角形: 代表子树, 可能由 case 4 递归到本case 导致有子树结构

截屏2021-04-11 下午3.10.23.png

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);
}
}
}

}

算法时间复杂度

红黑树插入流程图.png

对于有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 是红

操作:

直接删除

截屏2021-04-11 下午3.36.37.png

case 4: d 是黑, s 是红

操作:

P 置红
S 置黑
P 左旋(D 是左儿子) 或者右旋(D 是右儿子)
旋转之后兄弟节点就变为黑色了, 递归到下面的 case 5, 6, 7 进行处理

三角形: 代表子树, 可能由 case 7,递归到本case 导致有子树结构 递归处理: 之所以需要递归处理, 是因为在旋转之后, 所有路径的黑色节点数和旋转前一样, 若 D节点路径中少了一个黑色节点, 不满足性质6了,需要递归处理一下

P 左旋(D 是左儿子) 截屏2021-04-11 下午3.49.52.png

右旋(D 是右儿子) 截屏2021-04-11 下午3.55.22.png

case 5.1: d 是黑, s 是黑, s 右孩子是红且 d 是左孩子

操作:

P 和 S 颜色互换
P 左旋

三角形: 代表子树, 可能由 case 4,6,7 ,递归到本case 导致有子树结构 左旋: 左旋之后直接平衡了, 可以由下图, 看出, 所有路径旋转之后 D 节点路径中多了一个黑色节点, 其他路径黑色节点数都没变化, 而我们恰巧需要删除 D节点中的一个黑色节点, 至此, 满足性质6, 红黑树刚好平衡

截屏2021-04-11 下午4.13.55.png

case 5.2: d 是黑, s 是黑, s 左孩子是红且 d 是右孩子

操作:

P 和 S 颜色互换
P 右旋

截屏2021-04-11 下午4.20.55.png

case 6.1: d 是黑, s 是黑, s 左孩子是红且 d 是左孩子

操作:

S 置红, SL 置黑
S 右旋
树的结构就切换成了 case 5.1 的模样, 递归使用 case 5.1 解决

截屏2021-04-11 下午4.29.16.png

case 6.2: d 是黑, s 是黑, s 右孩子是红且 d 是右孩子

操作:

S 置红, SR 置黑
S 左旋
树的结构就切换成了 case 5.2 的模样, 递归使用 case 5.2 解决

截屏2021-04-11 下午4.32.10.png

case 7: d 是黑, s sl sr 全是黑

操作:

S 置红
递归 P 节点, 平衡红黑树

递归: S 置红会导致右子树路径上黑节点数量少1, 左子树由于 D(黑节点) 将被删除, 所以路径上黑节点数也会少1, 符合性质6, 但是此时 P 所在树整体所有路径黑色节点数少1, 需要向上递归平衡红黑树

截屏2021-04-11 下午4.39.53.png

截屏2021-04-11 下午4.40.08.png

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§;
}
}

}

算法时间复杂度

红黑树删除流程图 (1).png

从流程图看:

对于有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学习笔记总结+移动架构视频+大厂面试真题+项目实战源码》，点击传送门，即可获取！

2401_83817971

关注

8
点赞
踩
30

收藏

觉得还不错? 一键收藏
0
评论
数据结构(三), 弄懂红黑树RBTree(多图警告!!!)

光有这些思路和搞懂单个知识的应用是还远远不够的，在Android开源框架设计思想中的知识点还是比较多的，想要搞懂还得学会整理和规划：我们常见的**Android热修复框架、插件化框架、组件化框架、图片加载框架、网络访问框架、RxJava响应式编程框架、IOC依赖注入框架、最近架构组件Jetpack等等Android第三方开源框架，**这些都是属于Android开源框架设计思想的。如下图所示：这位阿里P8大佬针对以上知识点，熬夜整理出了一本长达1042页的完整版如何解读开源框架设计思想。
复制链接

扫一扫