JAVA中的数据结构 - 真正的去理解红黑树
一， 红黑树所处数据结构的位置：java
在JDK源码中, 有treeMap和JDK8的HashMap都用到了红黑树去存储sql
红黑树能够当作B树的一种: 数据库
从二叉树看，红黑树是一颗相对平衡的二叉树数据结构
二叉树-->搜索二叉树-->平衡搜索二叉树--> 红黑树源码分析
从N阶树看，红黑树就是一颗 2-3-4树code
N阶树-->B（B-）树索引
故我提取出了红黑树部分的源码，去说明红黑树的理解源码
看以前，理解红黑树的几个特性，后面的操做都是为了让树符合红黑树的这几个特性，从而知足对查找效率的O(logn)hash
二，红黑树特性，以及保持的手段io
1，根和叶子节点都是黑色的
2，不能有有连续两个红色的节点
3， 从任一节点到它所能到达得叶子节点的全部简单路径都包含相同数目的黑色节点
这几个特效，我的理解就是规定了红黑树是一颗2-3-4的B树了，从而知足了O(logn)查找效率
保持特性的手段，经过下面这些手段，让红黑树知足红黑树的特性，若是要尝试理解，能够从2-3-4树的向上增加，后面有详细介绍
固然，这些改变也都是在O(logn)内完成的，主要改变方式有
1， 改变颜色
2， 左旋
3， 右旋
三，从JDK源码来理解
主要看个人注释，逻辑的理解
先看TreeMap
//对treeMap的红黑树理解注解. 2017.02.16 by 何锦彬 JDK,1.7.51<br> <br>/** From CLR */
private void fixAfterInsertion(Entry<K, V> x) {
//新加入红黑树的默认节点就是红色
x.color = RED;
/**
* 1. 如为根节点直接跳出
*/
while (x != null && x != root && x.parent.color == RED) {
if (parentOf(x) == leftOf(parentOf(parentOf(x)))) {
//若是X的父节点（P）是其父节点的父节点（G）的左节点
//即 下面这种状况
/**
* G
* P(RED) U
*/
//获取其叔(U)节点
Entry<K, V> y = rightOf(parentOf(parentOf(x)));
if (colorOf(y) == RED) {
// 这种状况，对应下面 图：状况一
/**
* G
* P(RED) U(RED)
* X
*/
//若是叔节点是红色的（父节点有判断是红色）. 便是双红色，比较好办，经过改变颜色就行. 把P和U都设置成黑色而后,X加到P节点。 G节点看成新加入节点继续迭代
setColor(parentOf(x), BLACK);
setColor(y, BLACK);
setColor(parentOf(parentOf(x)), RED);
x = parentOf(parentOf(x));
} else {
//处理红父，黑叔的状况
if (x == rightOf(parentOf(x))) {
// 这种状况，对应下面 图：状况二
/**
* G
* P(RED) U(BLACK)
* X
*/
//若是X是右边节点
x = parentOf(x);
// 进行左旋
rotateLeft(x);
}
//左旋后，是这种状况了，对应下面 图：状况三
/**
* G
* P(RED) U(BLACK)
* X
*/
// 到这，X只能是左节点了，并且P是红色，U是黑色的状况
//把P改为黑色，G改为红色，以G为节点进行右旋
setColor(parentOf(x), BLACK);
setColor(parentOf(parentOf(x)), RED);
rotateRight(parentOf(parentOf(x)));
}
} else {
//父节点在右边的
/**
* G
* U P(RED)
*/
//获取U
Entry<K, V> y = leftOf(parentOf(parentOf(x)));
if (colorOf(y) == RED) {
//红父红叔的状况
/**
* G
* U(RED) P(RED)
*/
setColor(parentOf(x), BLACK);
setColor(y, BLACK);
setColor(parentOf(parentOf(x)), RED);
//把G看成新插入的节点继续进行迭代
x = parentOf(parentOf(x));
} else {
//红父黑叔，而且是右父的状况
/**
* G
* U(RED) P(RED)
*/
if (x == leftOf(parentOf(x))) {
//若是插入的X是左节点
/**
* G
* U(BLACK) P(RED)
* X
*/
x = parentOf(x);
//以P为节点进行右旋
rotateRight(x);
}
//右旋后
/**
* G
* U(BLACK) P(RED)
* X
*/
setColor(parentOf(x), BLACK);
setColor(parentOf(parentOf(x)), RED);
//以G为节点进行左旋
rotateLeft(parentOf(parentOf(x)));
}
}
}
//红黑树的根节点始终是黑色
root.color = BLACK;
}
再看看HashMap的实现，
在HashMap中，在JDK8后开始用红黑树代替链表，查找由O(n) 变成了 O(Logn)
源码分析以下:
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
//JDK8 的hashmap，链表到了8就须要变成颗红黑树了
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
红黑树的维护代码部分以下：
//hashmap的红黑树平衡
static <K,V> TreeNode<K,V> balanceInsertion(TreeNode<K,V> root,
TreeNode<K,V> x) {
x.red = true;
//死循环加变量定义，总感受JAVA不多这样写代码 哈
for (TreeNode<K,V> xp, xpp, xppl, xppr;;) {
//xp X父节点， XPP X的祖父节点， XPPL 祖父左节点 XXPR 祖父右节点
if ((xp = x.parent) == null) {
x.red = false;
return x;
}
// 若是父节点是黑色， 或者XP父节点是空，直接返回
else if (!xp.red || (xpp = xp.parent) == null)
return root;
// 下面的代码就和上面的很treeMap像了，
if (xp == (xppl = xpp.left)) {
// 第一种状况, 赋值xppl
//父节点是左节点的状况,下面这种
/**
* G
* P(RED) U
*/
if ((xppr = xpp.right) != null && xppr.red) {
//若是红叔的状况
// 这种状况，对应下面 图：状况一
/**
* G
* P(RED) U(RED)
* X
*/
//改变其颜色，
xppr.red = false;
xp.red = false;
xpp.red = true;
x = xpp;
}
else {
// 黑叔的状况
// 这种状况
/**
* G
* P(RED) U(BLACK)
*/
if (x == xp.right) {
//若是插入节点在右边 这种
// 这种状况，对应下面 图：状况二
/**
* G
* P(RED) U(BLACK)
* X
*/
//须要进行左旋
root = rotateLeft(root, x = xp);
xpp = (xp = x.parent) == null ? null : xp.parent;
}
//左旋后状况都是这种了，对应下面 图：状况三
/**
* G
* P(RED) U(BLACK)
* X
*/
// 到这，X只能是左节点了，并且P是红色，U是黑色的状况
if (xp != null) {
//把P改为黑色，G改为红色, 以G为节点进行右旋
xp.red = false;
if (xpp != null) {
xpp.red = true;
root = rotateRight(root, xpp);
}
}
}
}
else {
//父节点在右边的
/**
* G
* U P(RED)
*/
//获取U
if (xppl != null && xppl.red) {
//红父红叔的状况
/**
* G
* U(RED) P(RED)
*/
xppl.red = false;
xp.red = false;
xpp.red = true;
x = xpp;
}
else {
if (x == xp.left) {
//若是插入的X是右节点
/**
* G
* U(BLACK) P(RED)
* X
*/
root = rotateRight(root, x = xp);
xpp = (xp = x.parent) == null ? null : xp.parent;
}
//右旋后
/**
* G
* U(BLACK) P(RED)
* X
*/
if (xp != null) {
//把P改为黑色，G改为红色,
xp.red = false;
if (xpp != null) {
xpp.red = true;
//以G节点左旋
root = rotateLeft(root, xpp);
}
}
}
}
}
状况图以下
状况1
状况2
状况3
JDK源码处理红黑树的流程图
可见，其实处理逻辑实现都同样的
三，我的对红黑树理解的方法
1, 如何理解红黑树的O(lgN)的特性？
从2-3-4树去理解
红黑树，实际上是一颗 2-3-4的B树，B树都是向上增加的，若是不理解向上增加能够先看看2-3树，这样理解就能知道为何能O（logn）的查找了
2, 如何理解红黑树的红黑节点意义？
能够把红色节点当作是链接父节点的组成的一个大节点(2个或3个或4个节点组成的一个key)，以下:
（此图转自网上）
红色的就是和父节点组成了大节点，
好比
节点7和6，6是红色节点组成，故和它父节点7组成了一个大节点，即 2-3-4树的 6, 7节点
又如
节点 9和10和11，9和10为红色节点，故和10组成了一个2-3-4的3阶节点， 9,10,11（注意顺序有的关性）
3 , B树是如何保持O(lgn)的复杂度的呢?
B+树都是从底布开始往上生长，自动平衡，如 2-3-4树，当节点达到了3个时晋升到上个节点，因此不会产生单独生长一边的状况，造成平衡。
留个问题
4， 数据库里的索引为何不用红黑树而是用B+树（Mysql）呢？
后续解答
欢迎关注个人公众号，重现线上各类BUG， 一块儿来构建咱们的知识体系
- 1. JAVA中的数据结构 - 真正的去理解红黑树
- 2. 红黑树理解 - 数据结构
- 3. 数据结构--红黑树
- 4. 数据结构-红黑树
- 5. 数据结构 红黑树
- 6. 数据结构：红黑树
- 7. 数据结构 ——红黑树
- 8. 数据结构---红黑树
- 9. 数据结构 —— 红黑树
- 10. 数据结构_红黑树
- 更多相关文章...
- • XML 树结构 - XML 教程
- • Redis在Java Web中的应用 - Redis教程
- • Flink 数据传输及反压详解
- • TiDB 在摩拜单车在线数据业务的应用和实践
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. JAVA中的数据结构 - 真正的去理解红黑树
- 2. 红黑树理解 - 数据结构
- 3. 数据结构--红黑树
- 4. 数据结构-红黑树
- 5. 数据结构 红黑树
- 6. 数据结构：红黑树
- 7. 数据结构 ——红黑树
- 8. 数据结构---红黑树
- 9. 数据结构 —— 红黑树
- 10. 数据结构_红黑树