文章目录
- 基本定义
- 五大性质
- 红黑树和2-3-4树的关系
- 红黑树和2-3-4树各结点对应关系
- 添加结点到红黑树
- 注意事项
- 添加的所有情况
- 添加导致不平衡
- 叔父节点不是红色节点（祖父节点为红色）
- 添加不平衡LL/RR
- 添加不平衡LR/RL
- 叔父节点是红色节点（祖父节点为黑色）
- 删除
- 删除红色节点
- 删除黑色节点
- 删除黑色叶子节点——情况一
- 删除黑色叶子节点——情况二
- 删除黑色叶子节点——情况三
- 删除黑色叶子节点——情况四
- 红黑树与AVL（平衡二叉树）树比较
- 红黑树与B树B+树比较
- 完整的Java测试代码
- RedBlackTree
- BinaryTreeInfo
- BinaryTrees
- InorderPrinter
- LevelOrderPrinter
- Printer
- Strings
- 总结
基本定义
红黑树是一颗二叉搜索树，它在每个结点上增加了一个存储位来表示结点的颜色，可以是红色或者黑色。
通过对任何一条从根到叶子的简单路径上各个结点的颜色进行约束，红黑树确保没有一条路径会比其他路径长出2倍，因而是近似平衡的。
五大性质
1、结点必须是红色或者黑色。
2、根节点是黑色。
3、叶子结点（外部结点、空结点，不是传统上认为的那种叶子结点，如图中的那些NIL结点）都是黑色
4、红色结点的子结点都是黑色
于是有推论：
4.1、红色结点的父结点都是黑色
4.2、从根结点到叶子结点的所有路径上不能有两个连续的红色结点
5、从任一结点到叶子结点（外部结点、空结点，不是传统上认为的那种叶子结点，如图中的那些NIL结点）的所有路径都包含相同数目的黑色结点
如图所示：
红黑树和2-3-4树的关系
红黑树和4阶B树（2-3-4树）具有等价性
黑色节点与它的红色子节点融合在一起，形成一个B树节点
红黑树的黑色节点个数与4阶B树的节点总个数相等
红黑树和2-3-4树各结点对应关系
红黑红、黑红、红黑、黑
添加结点到红黑树
注意事项
一般新添加的节点默认为红色，这样对红黑树的性质影响最小（性质1、2、3、5都满足，性质4不一定）
如果新添加的节点是根节点，染成黑色即可
添加的所有情况
添加结点到红黑树总共有12中情况；
有4种情况满足红黑树的性质，父节点为黑色节点，因此不需要做任何处理。如下图所示的4种紫红色节点添加情况
有8种情况不满足红黑树的性质，父节点为红色节点（但其实可以归纳为3种情况）。如下图所示的8种紫红色节点添加情况。
添加导致不平衡
添加结点导致红黑树出现不平衡的情况。
叔父节点不是红色节点（祖父节点为红色）
添加不平衡LL/RR
判断条件：叔父节点不是红色节点
父节点是祖父节点的左孩子，自己是父节点的左孩子（LL)
父节点是祖父节点的右孩子，自己是父节点的右孩子（RR)
如何恢复平衡：
1、父节点染成黑色，祖父节点染成红色
2、对祖父节点进行旋转操作（LL是右旋，RR是左旋）
添加不平衡LR/RL
判断条件：叔父节点不是红色节点
父节点是祖父节点的左孩子，自己是父节点的右孩子（LR)
父节点是祖父节点的右孩子，自己是父节点的左孩子（RL)
如何恢复平衡：
1、把自己染成黑色，祖父节点染成红色
2、进行两次旋转，第一次旋转是转换成LL/RR情况，第二次旋转恢复平衡
2.1、LR：先按照父节点左旋，变成LL，再按照祖父节点右旋
2.2、RL：先按照父节点右旋，变成RR，再按照祖父节点左旋
叔父节点是红色节点（祖父节点为黑色）
判断条件：叔父节点为红色
如何恢复平衡：
1、父节点、叔父节点都染成黑色
2、祖父节点染成红色，并把祖父节点当成新添加的节点，继续处理
2.1、如果祖父节点染成红色没有引起双红现象，则处理结束
2.2、如果祖父节点染成红色也导致双红现象，则继续按照是LL/RR，LR/RL，还是叔父节点为红色的三种情况处理，最差情况是处理直到根节点，把根节点染成了红色，这个时候只需要把根节点染成黑色即可。
删除
B树中，最后真正被删除的元素都在叶子节点中。详细见B树（B-tree、B-树）理论详解
删除节点就是上面图的4种情况。
删除红色节点
直接删除，无需任何调整
删除黑色节点
有3种情况
1、拥有两个红色子节点的黑色节点不可能直接被删除，因为会找它的红色子节点替代删除，因此这种情况无需考虑
2、拥有1个红色子节点的黑色节点 (删除黑色节点后，把替代的红色子节点染成黑色即可)
3、黑色叶子节点 (情况比较复杂)
删除黑色叶子节点——情况一
如果兄弟节点是红色节点,
1、把兄弟节点染成黑色，父节点染成红色，对父节点进行旋转2、此时兄弟节点变成黑色，可以继续按照情况2，3，4进行处理
如图所示，40结点的兄弟结点是20，父结点是30。
删除黑色叶子节点——情况二
黑色兄弟节点没有一个红色子节点，
1、如果父节点是红色，把兄弟节点染成红色，父节点染成黑色，完成平衡维护。
2、如果父节点是黑色，把兄弟节点染成红色，把父节点当成待删除的节点，向上递归或循环处理（依然有情况1，2，3，4）。
删除黑色叶子节点——情况三
兄弟节点是左节点，黑色兄弟节点的左孩子是黑色节点，为LR场景，需要先转变为LL，方便后面的平衡旋转。
1、把兄弟节点的右孩子设为黑色，兄弟节点设为红色，对兄弟节点进行左旋，确保兄弟节点有一个红色左孩子，此时变成情况4。
删除黑色叶子节点——情况四
兄弟节点是左节点，兄弟节点的左孩子是红色节点，LL场景，
1、把兄弟节点的颜色设置为父节点的颜色，父节点和兄弟节点的左孩子都设置为黑色，
对父节点进行右旋，恢复平衡。
红黑树与AVL（平衡二叉树）树比较
AVL树的平衡标准比较严格：每个左右子树的高度差不超过1。
红黑树的平衡标准比较宽松：没有一条路径会大于其他路径的两倍。
相对于AVL树来说，红黑树牺牲了部分平衡性以换取插入/删除操作时少量的旋转操作，总体性能要优于 AVL树。
红黑树的平均统计性能优于AVL树，实际应用中更多选择使用红黑树。
红黑树与B树B+树比较
红黑树的分叉少，适合在内存中使用，如果在硬盘中使用的话，当数据量大的时候，红黑树的层高比较高，会带来比较多的磁盘IO，影响查询性能，比如说100万的数据量，用红黑树的话，大概是20层的层高，会有20次磁盘IO。
B树和B+树的分叉比较多，B树分叉一般能到两三百，B+树分叉多的能到上千，所以B树和B+树适合磁盘存储，100万的数据量，一般3层树高即可搞定，只有3次磁盘IO，实际中数据库一般把根节点存放在内存中，所以其实只有两次IO。
完整的Java测试代码
RedBlackTree
package redblacktree;
public class RedBlackTree implements BinaryTreeInfo {
//红黑直接用布尔变量定义
private static final boolean RED = false;
private static final boolean BLACK = true;
//初始化一个唯一的叶结点
private final RBNode nil = new RBNode();
//根结点初始化为nil
private RBNode root = nil;
public RBNode getRoot() {
return root;
}
public void setRoot(RBNode root) {
this.root = root;
}
public RedBlackTree() {
this.root = nil;
}
public RedBlackTree(RBNode root) {
this.root = root;
}
//前序遍历二叉树
public void preorderTreeWalk(RBNode x) {
if(x != nil) {
System.out.print(x.key + " ");
preorderTreeWalk(x.left);
preorderTreeWalk(x.right);
}
}
//中序遍历二叉树
public void inorderTreeWalk(RBNode x) {
if(x != nil) {
inorderTreeWalk(x.left);
System.out.print(x.key + " ");
inorderTreeWalk(x.right);
}
}
//后序遍历二叉树
public void postorderTreeWalk(RBNode x) {
if(x != nil) {
postorderTreeWalk(x.left);
postorderTreeWalk(x.right);
System.out.print(x.key + " ");
}
}
//在二叉搜索树中查询某个值，递归版本
public RBNode treeSearch(RBNode x, Integer k) {
if(x == nil || k == x.key) {
return x;
}
if(k < x.key) {
return treeSearch(x.left, k);
} else {
return treeSearch(x.right, k);
}
}
//在二叉搜索树中查询某个值，循环版本
public RBNode iterativeTreeSearch(RBNode x, Integer k) {
while(x != nil && k != x.key) {
if(k < x.key) {
x = x.left;
} else {
x = x.right;
}
}
return x;
}
//在二叉搜索树中查找包含最小值的节点
public RBNode treeMinimum(RBNode x) {
while (x.left != nil) {
x = x.left;
}
return x;
}
//在二叉搜索树中查找包含最大值的节点
public RBNode treeMaximum(RBNode x) {
while (x.right != nil) {
x = x.right;
}
return x;
}
//查找节点x的后继节点
public RBNode treeSuccessor(RBNode x) {
if(x.right != nil) { //x的右子树不为空，找右子树的最小值
return treeMinimum(x.right);
}
RBNode y = x.parent;
while(y != nil && x == y.right) {
x = y;
y = y.parent;
}
return y;
}
//查找节点x的前驱节点
public RBNode treePredeceessor(RBNode x) {
if(x.left != nil) {
return treeMaximum(x.left);
}
RBNode y = x.parent;
while(y != nil && x == y.left) {
x = y;
y = y.parent;
}
return y;
}
/**
* 围绕x左旋
* xp xp
* / /
* x xr
* / \ ==> / \
* xl xr x rr
* / \ / \
* rl rr xl rl
*
* @param t,x
*/
void leftRotate(RedBlackTree t, RBNode x) {
RBNode y = x.right; //让y等于x的右子节点
x.right = y.left; //将y的左子树转成x的右子树
if(y.left != t.nil) { //假如y的左孩子不为空，将y的左孩子的父亲设置为x
y.left.parent = x;
}
y.parent = x.parent; //将y的父亲设置为x的父亲
if(x.parent == t.nil) {
t.root = y; //考虑x原来为根节点的情况
} else if (x.parent.left == x) {
x.parent.left = y;
} else {
x.parent.right = y;
}
y.left = x;
x.parent = y;
}
/**
* 围绕x右旋
* xp xp
* \ \
* x xl
* / \ => / \
* xl xr ll x
* / \ / \
* ll lr lr xr
*
* @param t,x
*/
void rightRotate(RedBlackTree t, RBNode x) {
RBNode y = x.left; //让y等于x的左子节点
x.left = y.right; //将y的右子树转成x的左子树
if(y.right != t.nil) { //假如y的右孩子不为空，将y的右孩子的父亲设置为x
y.right.parent = x;
}
y.parent = x.parent; //将y的父亲设置为x的父亲
if(x.parent == t.nil) {
t.root = y; //考虑x原来为根节点的情况
} else if (x.parent.left == x) {
x.parent.left = y;
} else {
x.parent.right = y;
}
y.right = x;
x.parent = y;
}
//红黑树的插入操作
public void RBInsert(RedBlackTree t, RBNode z) {
RBNode y = t.nil;
RBNode x = t.root;
while(x != t.nil) {
y = x;
if(z.key < x.key) {
x = x.left;
} else {
x = x.right;
}
}
z.parent = y;
if(y == t.nil) { //说明现在是棵空树
t.root = z;
} else if (z.key < y.key) {
y.left = z;
} else {
y.right = z;
}
z.left = t.nil;
z.right = t.nil;
z.color = RED;
rbInsertFixup(t, z);
}
//插入节点后维护红黑树性质的过程
public void rbInsertFixup(RedBlackTree t, RBNode z) {
while (z.parent.color == RED) {
if(z.parent == z.parent.parent.left) { //z的父节点是z的祖父节点的左孩子
RBNode y = z.parent.parent.right; //让y成为z的叔叔节点
if (y.color == RED) {
/*
* z的父亲和叔叔节点都是红色，
* 根据红黑树性质，z的祖父一定是黑色
* 所以这时候，可以把z的祖父设为红色，
* z的父亲和叔叔都设为黑色，但这可能
* 导致z的祖父产生双红节点的问题，这
* 时候把z设置成z的祖父，继续向上递归
*/
z.parent.color = BLACK;
y.color = BLACK;
z.parent.parent.color = RED;
z = z.parent.parent;
} else {
if (z == z.parent.right) {
/*
* z的父亲是左节点，z是右节点,
* 满足LR不平衡，需要对z的父亲进行左旋,
* 转变成LL不平衡
*/
z = z.parent;
leftRotate(t, z);
}
/*
* z的父亲是左节点，z也是左节点，
* 满足LL不平衡，把z的父亲设为黑色，
* z的祖父设为红色，对z进行右旋，
* 即可满足平衡
*/
z.parent.color = BLACK;
z.parent.parent.color = RED;
rightRotate(t, z.parent.parent);
}
} else {
RBNode y = z.parent.parent.left; //让y成为z的叔叔节点
if (y.color == RED) {
/*
* z的父亲和叔叔节点都是红色，
* 根据红黑树性质，z的祖父一定是黑色
* 所以这时候，可以把z的祖父设为红色，
* z的父亲和叔叔都设为黑色，但这可能
* 导致z的祖父产生双红节点的问题，这
* 时候把z设置成z的祖父，继续向上递归
*/
z.parent.color = BLACK;
y.color = BLACK;
z.parent.parent.color = RED;
z = z.parent.parent;
} else {
if (z == z.parent.left) {
/*
* z的父亲是右节点，z是左节点,
* 满足RL不平衡，需要对z的父亲进行右旋,
* 转变成RR不平衡
*/
z = z.parent;
rightRotate(t, z);
}
/*
* z的父亲是右节点，z也是右节点，
* 满足RR不平衡，把z的父亲设为黑色，
* z的祖父设为红色，对z进行左旋，
* 即可满足平衡
*/
z.parent.color = BLACK;
z.parent.parent.color = RED;
leftRotate(t, z.parent.parent);
}
}
}
t.root.color = BLACK;
}
public void rbTransplant(RedBlackTree t, RBNode u, RBNode v) {
if(u.parent == t.nil) {
t.root = v;
} else if(u == u.parent.left) {
u.parent.left = v;
} else {
u.parent.right = v;
}
v.parent = u.parent;
}
//删除节点操作
public void rbDelete(RedBlackTree t, RBNode z) {
RBNode x;
RBNode y = z;
boolean yOriginalColor = y.color;
if (z.left == t.nil) {
x = z.right;
//z的左孩子为空，用z的右孩子替换z，此时z的右孩子可以为空，也可以不为空
rbTransplant(t, z, z.right);
} else if (z.right == t.nil) {
x = z.left;
//z仅有一个孩子且其为左孩子，用z的左孩子替换z
rbTransplant(t, z , z.left);
} else {
//z有两个孩子，找z的后继节点
y = treeMinimum(z.right);
yOriginalColor = y.color;
x = y.right;
if(y.parent == z) {
x.parent = y;
} else {
//用以y的右孩子为根的树代替以y为根的树
rbTransplant(t, y, y.right);
y.right = z.right;
y.right.parent = y;
}
//用以y为根的树代替以z为根的树
rbTransplant(t, z, y);
y.left = z.left;
y.left.parent = y;
}
//如果删除的为黑节点，需要修复平衡
if (yOriginalColor == BLACK) {
// rbDeleteFixup(t, x);
fixAfterDelete(t, x);
}
}
//删除修复算法导论版代码，用红黑树解释
public void rbDeleteFixup(RedBlackTree t, RBNode x) {
while(x != t.root && x.color == BLACK) {
//x是左孩子
if(x == x.parent.left) {
//w为兄弟节点
RBNode w = x.parent.right;
//w为红色，要旋转成黑色，方便后续操作
if(w.color == RED) {
w.color = BLACK;
x.parent.color = RED;
leftRotate(t, x.parent);
//此时w为黑色
w = x.parent.right;
}
/*
* w是黑色，w的两个孩子都是黑色，
* 没办法通过旋转恢复平衡，只能把w拉下水，设为红色，
* x变成x的父节点，向上递归
*/
if(w.left.color == BLACK && w.right.color == BLACK) {
w.color = RED;
x = x.parent;
} else {
/*
* w是黑色，w的右孩子是黑色，
* w的左孩子是红色，为RL场景
* 此时把w的左孩子设为黑色，
* w设为红色，对w进行右旋，
* 确保w的右孩子为红色，此时为RR场景
*/
if(w.right.color == BLACK) {
w.left.color = BLACK;
w.color = RED;
rightRotate(t, w);
w = x.parent.right;
}
/*
* 此时一定是w为黑色，w的右孩子为红色，
* w设置为x父节点的颜色，
* x父节点设为黑色，
* w的右孩子设置为黑色，
* 这样w路径上多出来一个黑节点，
* 对x的父节点进行左旋，
* 相当于把原来w路径上多出来的黑节点补充到x的路径上，
* 这样就填补了原来删除的黑节点，恢复平衡
*/
w.color = x.parent.color;
x.parent.color = BLACK;
w.right.color = BLACK;
leftRotate(t, x.parent);
/*
* 这里已经恢复平衡，
* 所以直接把x设置为根节点结束循环
*/
x = t.root;
}
} else {
//x是右孩子，w是兄弟节点
RBNode w = x.parent.left;
//w为红色，要旋转成黑色，方便后续操作
if(w.color == RED) {
w.color = BLACK;
x.parent.color = RED;
rightRotate(t, x.parent);
//此时w为黑色
w = x.parent.right;
}
/*
* w是黑色，w的两个孩子都是黑色，
* 没办法通过旋转恢复平衡，只能把w拉下水，设为红色，
* x变成x的父节点，向上递归
*/
if(w.right.color == BLACK && w.left.color == BLACK) {
w.color = RED;
x = x.parent;
} else {
/*
* w是黑色，w的左孩子是黑色，
* w的右孩子是红色，为LR场景
* 此时把w的右孩子设为黑色，
* w设为红色，对w进行左旋，
* 确保w的左孩子一定为红色，此时为LL场景
*/
if(w.left.color == BLACK) {
w.right.color = BLACK;
w.color = RED;
leftRotate(t, w);
w = x.parent.left;
}
/*
* 此时一定是w为黑色，w的左孩子为红色，
* w设置为x父节点的颜色，
* x父节点设为黑色，
* w的左孩子设置为黑色，
* 这样w路径上多出来一个黑节点，
* 对x的父节点进行右旋，
* 相当于把原来w路径上多出来的黑节点补充到x的路径上，
* 这样就填补了原来删除的黑节点，恢复平衡
*/
w.color = x.parent.color;
x.parent.color = BLACK;
w.left.color = BLACK;
rightRotate(t, x.parent);
/*
* 这里已经恢复平衡，
* 所以直接把x设置为根节点结束循环
*/
x = t.root;
}
}
}
/*
* 循环结束，要么x是根节点，
* 要么x是红色节点，
* 直接把x设置成黑色，即可恢复平衡
*/
x.color = BLACK;
}
/**
* 根据2-3-4树解释的红黑树删除
* 删除后的调整处理
* 1.情况1：自己能搞定，对应的叶子节点是3节点或者4节点
* 2.情况2：自己搞不定，需要兄弟节点借，但是兄弟节点不能直接借，找父亲节点借，父亲下来，然后兄弟节点找一个人代替父亲当家
* 3.情况3：跟兄弟节点借，兄弟也没有
* @param t,x
*/
public void fixAfterDelete(RedBlackTree t, RBNode x){
while(x != t.root && x.color == BLACK){
//x是左孩子的情况
if(x == x.parent.left) {
//兄弟节点
RBNode w = x.parent.right;
//判断此时兄弟节点是否是真正的兄弟节点，只有黑色节点才是
if(w.color == RED){
w.color = BLACK;
x.parent.color = RED;
leftRotate(t, x.parent);
//找到真正的兄弟节点
w = x.parent.right;
}
//情况三，找兄弟借，兄弟没得借
if(w.left.color == BLACK && w.right.color == BLACK) {
//把兄弟拉下水，设为红色，向上递归
w.color = RED;
x = x.parent;
}
//情况二，找兄弟借，兄弟有的借
else{
//确保w的右孩子是红色
if(w.right.color == BLACK) {
w.left.color = BLACK;
w.color = RED;
rightRotate(t, w);
w = x.parent.right;
}
/*
* 此时一定是w为黑色，w的右孩子为红色，
* w设置为x父节点的颜色，
* x父节点设为黑色，
* w的右孩子设置为黑色，
* 这样w路径上多出来一个黑节点，
* 对x的父节点进行左旋，
* 相当于把原来w路径上多出来的黑节点补充到x的路径上，
* 这样就填补了原来删除的黑节点，恢复平衡
*/
w.color = x.parent.color;
x.parent.color = BLACK;
w.right.color = BLACK;
leftRotate(t, x.parent);
x = t.root;
}
}
//x是右孩子的情况
else{
//兄弟节点
RBNode w = x.parent.left;
//判断此时兄弟节点是否是真正的兄弟节点，只有黑色节点才是
if(w.color == RED) {
w.color = BLACK;
x.parent.color = RED;
rightRotate(t, x.parent);
//此时w为黑色，才是真正的兄弟节点
w = x.parent.right;
}
//情况三，找兄弟借，兄弟没得借
if(w.left.color == BLACK && w.right.color == BLACK) {
//把兄弟拉下水，设为红色，向上递归
w.color = RED;
x = x.parent;
}
//情况二，找兄弟借，兄弟有的借
else{
//确保w的左孩子是红色
if(w.left.color == BLACK) {
w.right.color = BLACK;
w.color = RED;
leftRotate(t, w);
w = x.parent.right;
}
/*
* 此时一定是w为黑色，w的左孩子为红色，
* w设置为x父节点的颜色，
* x父节点设为黑色，
* w的左孩子设置为黑色，
* 这样w路径上多出来一个黑节点，
* 对x的父节点进行右旋，
* 相当于把原来w路径上多出来的黑节点补充到x的路径上，
* 这样就填补了原来删除的黑节点，恢复平衡
*/
w.color = x.parent.color;
x.parent.color = BLACK;
w.left.color = BLACK;
rightRotate(t, x.parent);
x = t.root;
}
}
}
//情况一、替代节点是红色，则直接染红，补偿删除的黑色节点，这样红黑树依然保持平衡
x.color = BLACK;
}
//红黑树节点类定义
static class RBNode {
private Integer key; //节点值
private RBNode parent; //父节点
private RBNode left; //左孩子
private RBNode right; //右孩子
private boolean color = BLACK;
public RBNode() {
}
public RBNode(Integer key) {
this.key = key;
}
public RBNode(Integer key, RBNode parent) {
this.parent = parent;
this.color = BLACK;
this.key = key;
}
public RBNode(RBNode parent, RBNode left, RBNode right, Integer key, boolean color) {
this.parent = parent;
this.left = left;
this.right = right;
this.key = key;
this.color = color;
}
public Integer getKey() {
return key;
}
public void setKey(Integer key) {
this.key = key;
}
public RBNode getParent() {
return parent;
}
public void setParent(RBNode parent) {
this.parent = parent;
}
public RBNode getLeft() {
return left;
}
public void setLeft(RBNode left) {
this.left = left;
}
public RBNode getRight() {
return right;
}
public void setRight(RBNode right) {
this.right = right;
}
}
@Override
public Object root() {
return root;
}
@Override
public Object left(Object RBNode) {
return ((RBNode)RBNode).left;
}
@Override
public Object right(Object RBNode) {
return ((RBNode)RBNode).right;
}
@Override
public Object string(Object RBNode) {
RBNode myRBNode = (RBNode)RBNode;
String color = myRBNode.color == RED ? "RED" : "BLACK";
return myRBNode.key + "(" + color + ")";
}
public static void main(String[] args) {
RedBlackTree bst = new RedBlackTree();
bst.RBInsert(bst, new RBNode(12));
bst.RBInsert(bst, new RBNode(5));
bst.RBInsert(bst, new RBNode(2));
bst.RBInsert(bst, new RBNode(9));
bst.RBInsert(bst, new RBNode(18));
bst.RBInsert(bst, new RBNode(15));
bst.RBInsert(bst, new RBNode(19));
bst.RBInsert(bst, new RBNode(17));
bst.inorderTreeWalk(bst.root);
System.out.println();
BinaryTrees.print(bst);
bst.rbDelete(bst, bst.treeSearch(bst.root, 12));
System.out.println();
BinaryTrees.print(bst);
}
}
BinaryTreeInfo
package redblacktree;
public interface BinaryTreeInfo {
/**
* who is the root node
*/
Object root();
/**
* how to get the left child of the node
*/
Object left(Object node);
/**
* how to get the right child of the node
*/
Object right(Object node);
/**
* how to print the node
*/
Object string(Object node);
}
BinaryTrees
package redblacktree;
public final class BinaryTrees {
private BinaryTrees() {
}
public static void print(BinaryTreeInfo tree) {
print(tree, null);
}
public static void println(BinaryTreeInfo tree) {
println(tree, null);
}
public static void print(BinaryTreeInfo tree, PrintStyle style) {
if (tree == null || tree.root() == null) return;
printer(tree, style).print();
}
public static void println(BinaryTreeInfo tree, PrintStyle style) {
if (tree == null || tree.root() == null) return;
printer(tree, style).println();
}
public static String printString(BinaryTreeInfo tree) {
return printString(tree, null);
}
public static String printString(BinaryTreeInfo tree, PrintStyle style) {
if (tree == null || tree.root() == null) return null;
return printer(tree, style).printString();
}
private static Printer printer(BinaryTreeInfo tree, PrintStyle style) {
if (style == PrintStyle.INORDER) return new InorderPrinter(tree);
return new LevelOrderPrinter(tree);
}
public enum PrintStyle {
LEVEL_ORDER, INORDER
}
}
InorderPrinter
package redblacktree;
/**
┌──800
┌──760
│ └──600
┌──540
│ └──476
│ └──445
┌──410
│ └──394
381
│ ┌──190
│ │ └──146
│ ┌──40
│ │ └──35
└──12
└──9
*/
public class InorderPrinter extends Printer {
private static String rightAppend;
private static String leftAppend;
private static String blankAppend;
private static String lineAppend;
static {
int length = 2;
rightAppend = "┌" + Strings.repeat("─", length);
leftAppend = "└" + Strings.repeat("─", length);
blankAppend = Strings.blank(length + 1);
lineAppend = "│" + Strings.blank(length);
}
public InorderPrinter(BinaryTreeInfo tree) {
super(tree);
}
@Override
public String printString() {
StringBuilder string = new StringBuilder(
printString(tree.root(), "", "", ""));
string.deleteCharAt(string.length() - 1);
return string.toString();
}
/**
* 生成node节点的字符串
* @param nodePrefix node那一行的前缀字符串
* @param leftPrefix node整棵左子树的前缀字符串
* @param rightPrefix node整棵右子树的前缀字符串
* @return
*/
private String printString(
Object node,
String nodePrefix,
String leftPrefix,
String rightPrefix) {
Object left = tree.left(node);
Object right = tree.right(node);
String string = tree.string(node).toString();
int length = string.length();
if (length % 2 == 0) {
length--;
}
length >>= 1;
String nodeString = "";
if (right != null) {
rightPrefix += Strings.blank(length);
nodeString += printString(right,
rightPrefix + rightAppend,
rightPrefix + lineAppend,
rightPrefix + blankAppend);
}
nodeString += nodePrefix + string + "\n";
if (left != null) {
leftPrefix += Strings.blank(length);
nodeString += printString(left,
leftPrefix + leftAppend,
leftPrefix + blankAppend,
leftPrefix + lineAppend);
}
return nodeString;
}
}
LevelOrderPrinter
package redblacktree;
import java.util.*;
/**
┌───381────┐
│ │
┌─12─┐ ┌─410─┐
│ │ │ │
9 ┌─40─┐ 394 ┌─540─┐
│ │ │ │
35 ┌─190 ┌─476 ┌─760─┐
│ │ │ │
146 445 600 800
*/
public class LevelOrderPrinter extends Printer {
/**
* 节点之间允许的最小间距（最小只能填1）
*/
private static final int MIN_SPACE = 1;
private Node root;
private int minX;
private int maxWidth;
private List<List<Node>> nodes;
public LevelOrderPrinter(BinaryTreeInfo tree) {
super(tree);
root = new Node(tree.root(), tree);
maxWidth = root.width;
}
@Override
public String printString() {
// nodes用来存放所有的节点
nodes = new ArrayList<>();
fillNodes();
cleanNodes();
compressNodes();
addLineNodes();
int rowCount = nodes.size();
// 构建字符串
StringBuilder string = new StringBuilder();
for (int i = 0; i < rowCount; i++) {
if (i != 0) {
string.append("\n");
}
List<Node> rowNodes = nodes.get(i);
StringBuilder rowSb = new StringBuilder();
for (Node node : rowNodes) {
int leftSpace = node.x - rowSb.length() - minX;
rowSb.append(Strings.blank(leftSpace));
rowSb.append(node.string);
}
string.append(rowSb);
}
return string.toString();
}
/**
* 添加一个元素节点
*/
private Node addNode(List<Node> nodes, Object btNode) {
Node node = null;
if (btNode != null) {
node = new Node(btNode, tree);
maxWidth = Math.max(maxWidth, node.width);
nodes.add(node);
} else {
nodes.add(null);
}
return node;
}
/**
* 以满二叉树的形式填充节点
*/
private void fillNodes() {
// 第一行
List<Node> firstRowNodes = new ArrayList<>();
firstRowNodes.add(root);
nodes.add(firstRowNodes);
// 其他行
while (true) {
List<Node> preRowNodes = nodes.get(nodes.size() - 1);
List<Node> rowNodes = new ArrayList<>();
boolean notNull = false;
for (Node node : preRowNodes) {
if (node == null) {
rowNodes.add(null);
rowNodes.add(null);
} else {
Node left = addNode(rowNodes, tree.left(node.btNode));
if (left != null) {
node.left = left;
left.parent = node;
notNull = true;
}
Node right = addNode(rowNodes, tree.right(node.btNode));
if (right != null) {
node.right = right;
right.parent = node;
notNull = true;
}
}
}
// 全是null，就退出
if (!notNull) break;
nodes.add(rowNodes);
}
}
/**
* 删除全部null、更新节点的坐标
*/
private void cleanNodes() {
int rowCount = nodes.size();
if (rowCount < 2) return;
// 最后一行的节点数量
int lastRowNodeCount = nodes.get(rowCount - 1).size();
// 每个节点之间的间距
int nodeSpace = maxWidth + 2;
// 最后一行的长度
int lastRowLength = lastRowNodeCount * maxWidth
+ nodeSpace * (lastRowNodeCount - 1);
// 空集合
Collection<Object> nullSet = Collections.singleton(null);
for (int i = 0; i < rowCount; i++) {
List<Node> rowNodes = nodes.get(i);
int rowNodeCount = rowNodes.size();
// 节点左右两边的间距
int allSpace = lastRowLength - (rowNodeCount - 1) * nodeSpace;
int cornerSpace = allSpace / rowNodeCount - maxWidth;
cornerSpace >>= 1;
int rowLength = 0;
for (int j = 0; j < rowNodeCount; j++) {
if (j != 0) {
// 每个节点之间的间距
rowLength += nodeSpace;
}
rowLength += cornerSpace;
Node node = rowNodes.get(j);
if (node != null) {
// 居中（由于奇偶数的问题，可能有1个符号的误差）
int deltaX = (maxWidth - node.width) >> 1;
node.x = rowLength + deltaX;
node.y = i;
}
rowLength += maxWidth;
rowLength += cornerSpace;
}
// 删除所有的null
rowNodes.removeAll(nullSet);
}
}
/**
* 压缩空格
*/
private void compressNodes() {
int rowCount = nodes.size();
if (rowCount < 2) return;
for (int i = rowCount - 2; i >= 0; i--) {
List<Node> rowNodes = nodes.get(i);
for (Node node : rowNodes) {
Node left = node.left;
Node right = node.right;
if (left == null && right == null) continue;
if (left != null && right != null) {
// 让左右节点对称
node.balance(left, right);
// left和right之间可以挪动的最小间距
int leftEmpty = node.leftBoundEmptyLength();
int rightEmpty = node.rightBoundEmptyLength();
int empty = Math.min(leftEmpty, rightEmpty);
empty = Math.min(empty, (right.x - left.rightX()) >> 1);
// left、right的子节点之间可以挪动的最小间距
int space = left.minLevelSpaceToRight(right) - MIN_SPACE;
space = Math.min(space >> 1, empty);
// left、right往中间挪动
if (space > 0) {
left.translateX(space);
right.translateX(-space);
}
// 继续挪动
space = left.minLevelSpaceToRight(right) - MIN_SPACE;
if (space < 1) continue;
// 可以继续挪动的间距
leftEmpty = node.leftBoundEmptyLength();
rightEmpty = node.rightBoundEmptyLength();
if (leftEmpty < 1 && rightEmpty < 1) continue;
if (leftEmpty > rightEmpty) {
left.translateX(Math.min(leftEmpty, space));
} else {
right.translateX(-Math.min(rightEmpty, space));
}
} else if (left != null) {
left.translateX(node.leftBoundEmptyLength());
} else { // right != null
right.translateX(-node.rightBoundEmptyLength());
}
}
}
}
private void addXLineNode(List<Node> curRow, Node parent, int x) {
Node line = new Node("─");
line.x = x;
line.y = parent.y;
curRow.add(line);
}
private Node addLineNode(List<Node> curRow, List<Node> nextRow, Node parent, Node child) {
if (child == null) return null;
Node top = null;
int topX = child.topLineX();
if (child == parent.left) {
top = new Node("┌");
curRow.add(top);
for (int x = topX + 1; x < parent.x; x++) {
addXLineNode(curRow, parent, x);
}
} else {
for (int x = parent.rightX(); x < topX; x++) {
addXLineNode(curRow, parent, x);
}
top = new Node("┐");
curRow.add(top);
}
// 坐标
top.x = topX;
top.y = parent.y;
child.y = parent.y + 2;
minX = Math.min(minX, child.x);
// 竖线
Node bottom = new Node("│");
bottom.x = topX;
bottom.y = parent.y + 1;
nextRow.add(bottom);
return top;
}
private void addLineNodes() {
List<List<Node>> newNodes = new ArrayList<>();
int rowCount = nodes.size();
if (rowCount < 2) return;
minX = root.x;
for (int i = 0; i < rowCount; i++) {
List<Node> rowNodes = nodes.get(i);
if (i == rowCount - 1) {
newNodes.add(rowNodes);
continue;
}
List<Node> newRowNodes = new ArrayList<>();
newNodes.add(newRowNodes);
List<Node> lineNodes = new ArrayList<>();
newNodes.add(lineNodes);
for (Node node : rowNodes) {
addLineNode(newRowNodes, lineNodes, node, node.left);
newRowNodes.add(node);
addLineNode(newRowNodes, lineNodes, node, node.right);
}
}
nodes.clear();
nodes.addAll(newNodes);
}
private static class Node {
/**
* 顶部符号距离父节点的最小距离（最小能填0）
*/
private static final int TOP_LINE_SPACE = 1;
Object btNode;
Node left;
Node right;
Node parent;
/**
* 首字符的位置
*/
int x;
int y;
int treeHeight;
String string;
int width;
private void init(String string) {
string = (string == null) ? "null" : string;
string = string.isEmpty() ? " " : string;
width = string.length();
this.string = string;
}
public Node(String string) {
init(string);
}
public Node(Object btNode, BinaryTreeInfo opetaion) {
init(opetaion.string(btNode).toString());
this.btNode = btNode;
}
/**
* 顶部方向字符的X（极其重要）
*
* @return
*/
private int topLineX() {
// 宽度的一半
int delta = width;
if (delta % 2 == 0) {
delta--;
}
delta >>= 1;
if (parent != null && this == parent.left) {
return rightX() - 1 - delta;
} else {
return x + delta;
}
}
/**
* 右边界的位置（rightX 或者 右子节点topLineX的下一个位置）（极其重要）
*/
private int rightBound() {
if (right == null) return rightX();
return right.topLineX() + 1;
}
/**
* 左边界的位置（x 或者 左子节点topLineX）（极其重要）
*/
private int leftBound() {
if (left == null) return x;
return left.topLineX();
}
/**
* x ~ 左边界之间的长度（包括左边界字符）
*
* @return
*/
private int leftBoundLength() {
return x - leftBound();
}
/**
* rightX ~ 右边界之间的长度（包括右边界字符）
*
* @return
*/
private int rightBoundLength() {
return rightBound() - rightX();
}
/**
* 左边界可以清空的长度
*
* @return
*/
private int leftBoundEmptyLength() {
return leftBoundLength() - 1 - TOP_LINE_SPACE;
}
/**
* 右边界可以清空的长度
*
* @return
*/
private int rightBoundEmptyLength() {
return rightBoundLength() - 1 - TOP_LINE_SPACE;
}
/**
* 让left和right基于this对称
*/
private void balance(Node left, Node right) {
if (left == null || right == null) return;
// 【left的尾字符】与【this的首字符】之间的间距
int deltaLeft = x - left.rightX();
// 【this的尾字符】与【this的首字符】之间的间距
int deltaRight = right.x - rightX();
int delta = Math.max(deltaLeft, deltaRight);
int newRightX = rightX() + delta;
right.translateX(newRightX - right.x);
int newLeftX = x - delta - left.width;
left.translateX(newLeftX - left.x);
}
private int treeHeight(Node node) {
if (node == null) return 0;
if (node.treeHeight != 0) return node.treeHeight;
node.treeHeight = 1 + Math.max(
treeHeight(node.left), treeHeight(node.right));
return node.treeHeight;
}
/**
* 和右节点之间的最小层级距离
*/
private int minLevelSpaceToRight(Node right) {
int thisHeight = treeHeight(this);
int rightHeight = treeHeight(right);
int minSpace = Integer.MAX_VALUE;
for (int i = 0; i < thisHeight && i < rightHeight; i++) {
int space = right.levelInfo(i).leftX
- this.levelInfo(i).rightX;
minSpace = Math.min(minSpace, space);
}
return minSpace;
}
private LevelInfo levelInfo(int level) {
if (level < 0) return null;
int levelY = y + level;
if (level >= treeHeight(this)) return null;
List<Node> list = new ArrayList<>();
Queue<Node> queue = new LinkedList<>();
queue.offer(this);
// 层序遍历找出第level行的所有节点
while (!queue.isEmpty()) {
Node node = queue.poll();
if (levelY == node.y) {
list.add(node);
} else if (node.y > levelY) break;
if (node.left != null) {
queue.offer(node.left);
}
if (node.right != null) {
queue.offer(node.right);
}
}
Node left = list.get(0);
Node right = list.get(list.size() - 1);
return new LevelInfo(left, right);
}
/**
* 尾字符的下一个位置
*/
public int rightX() {
return x + width;
}
public void translateX(int deltaX) {
if (deltaX == 0) return;
x += deltaX;
// 如果是LineNode
if (btNode == null) return;
if (left != null) {
left.translateX(deltaX);
}
if (right != null) {
right.translateX(deltaX);
}
}
}
private static class LevelInfo {
int leftX;
int rightX;
public LevelInfo(Node left, Node right) {
this.leftX = left.leftBound();
this.rightX = right.rightBound();
}
}
}
Printer
package redblacktree;
public abstract class Printer {
/**
* 二叉树的基本信息
*/
protected BinaryTreeInfo tree;
public Printer(BinaryTreeInfo tree) {
this.tree = tree;
}
/**
* 生成打印的字符串
*/
public abstract String printString();
/**
* 打印后换行
*/
public void println() {
print();
System.out.println();
}
/**
* 打印
*/
public void print() {
System.out.print(printString());
}
}
Strings
package redblacktree;
public class Strings {
public static String repeat(String string, int count) {
if (string == null) return null;
StringBuilder builder = new StringBuilder();
while (count-- > 0) {
builder.append(string);
}
return builder.toString();
}
public static String blank(int length) {
if (length < 0) return null;
if (length == 0) return "";
return String.format("%" + length + "s", "");
}
}
总结
这个实现过程比较复杂，更多的是在提现一个打印结果的实现，没有必要自己去手敲，可以全部拿下来，去运行，看具体核心实现红黑树对应的那些功能。对于红黑树更细节的去使用，我也还在探索中，之后会更加细节的去记录。
ps:计划每日更新一篇博客，今日2023-05-04，日更第十八天。
昨日更新：
B树（B-tree、B-树）理论详解
