红黑树定义
一棵红黑树需要满足这样几个要求：
根节点是黑色的；
每个叶子节点都是黑色的空节点（NIL），也就是说，叶子节点不存储数据；
任何相邻的节点都不能同时为红色，也就是说，红色节点是被黑色节点隔开的；
每个节点，从该节点到达其可达叶子节点的所有路径，都包含相同数目的黑色节点；
平衡调整
在插入、删除节点的过程中，第三、第四点要求可能会被破坏，而“平衡调整”，实际上就是要把被破坏的第三、第四点恢复过来。
红黑树通过节点的左旋和右旋完成平衡调整。
插入操作的平衡调整
红黑树规定，插入的节点必须是红色的。而且，二叉查找树中新插入的节点都是放在叶子节点上。
关于插入操作的平衡调整，有这样两种特殊情况，但是也都非常好处理。
-
如果插入节点的父节点是黑色的，那我们什么都不用做，它仍然满足红黑树的定义。
-
如果插入的节点是根节点，那我们直接改变它的颜色，把它变成黑色就可以了。
除此之外，其他情况都会违背红黑树的定义，于是我们就需要进行调整，调整的过程包含两种基础的操作：左右旋转和改变颜色。
红黑树的平衡调整过程是一个迭代的过程。我们把正在处理的节点叫做关注节点。关注节点会随着不停地迭代处理，而不断发生变化。最开始的关注节点就是新插入的节点。
新节点插入之后，如果红黑树的平衡被打破，那一般会有下面三种情况。我们只需要根据每种情况的特点，不停地调整，就可以让红黑树继续符合定义，也就是继续保持平衡。
我们下面依次来看每种情况的调整过程。提醒你注意下，为了简化描述，我把父节点的兄弟节点叫做叔叔节点，父节点的父节点叫做祖父节点。
调整过程
CASE 1：如果关注节点是 a，它的叔叔节点 d 是红色:
- 将关注节点 a 的父节点 b、叔叔节点 d 的颜色都设置成黑色；
- 将关注节点 a 的祖父节点 c 的颜色设置成红色；
- 关注节点变成 a 的祖父节点 c；
- 跳到 CASE 2 或者 CASE 3。
CASE 2：如果关注节点是 a，它的叔叔节点 d 是黑色，关注节点 a 是其父节点 b 的右子节点：
-
关注节点变成节点 a 的父节点 b；
-
围绕新的关注节点b 左旋；
-
跳到 CASE 3。
CASE 3：如果关注节点是 a，它的叔叔节点 d 是黑色，关注节点 a 是其父节点 b 的左子节点：
-
围绕关注节点 a 的祖父节点 c 右旋；
-
将关注节点 a 的父节点 b、兄弟节点 c 的颜色互换。
-
调整结束。
贴出插入调整代码
/**
* 1. 创建RBTree,定义颜色
* 2. 创建RBNode
* 3. 辅助方法定义：
* 4. parentOf(node),isRed(node),isBlack(node),setRed(node)，setBlack(node),inOrderPrint()
* 5. 左旋方法定义：
* 6. leftRotate(node)
* 7. 右旋方法定义：
* 8. ghtR0tate(node)
* 9. 公开插入接目方法定义：insert(K key,V value)；
* 10. 内部插入接方法定义：insert(RBNode node)；
* 11. 修正插入导致红黑树失衡的方法定义：insertF1xUp(RBNode node)；
*/
public class RBTree<K extends Comparable<K>, V> {
private static final boolean RED = true;
private static final boolean BLACK = false;
private RBNode root;
/**
* 获取当前节点的父节点
*
* @param node
*/
private RBNode parentOf(RBNode node) {
if (node != null) {
return node.parent;
}
return null;
}
/**
* 节点是否为红色
*
* @param node
*/
private boolean isRed(RBNode node) {
if (node != null) {
return node.color == RED;
}
return false;
}
/**
* 节点是否为黑色
*
* @param node
*/
private boolean isBlack(RBNode node) {
if (node != null) {
return node.color == BLACK;
}
return false;
}
/**
* 设置节点为红色
*
* @param node
*/
private void setRed(RBNode node) {
if (node != null) {
node.color = RED;
}
}
/**
* 设置节点为黑色
*
* @param node
*/
private void setBlack(RBNode node) {
if (node != null) {
node.color = BLACK;
}
}
/**
* 中序遍历打印二叉树
*/
public void inOrderPrint() {
inOrderPrint(this.root);
}
private void inOrderPrint(RBNode node) {
if (node != null) {
inOrderPrint(node.left);
System.out.println("key：" + node.key + ",value：" + node.value);
inOrderPrint(node.right);
}
}
/**
* 公开的插入方法
*
* @param key
* @param value
*/
public void insert(K key, V value) {
RBNode node = new RBNode();
node.setKey(key);
node.setValue(value);
//新节点一定为红色! !
node.setColor(RED);
insert(node);
}
private void insert(RBNode node) {
//查找当前node父节点
RBNode parent = null;
RBNode x = this.root;
while (x != null) {
parent = x;
//cmp>0 说明node.key>x.key 要去右子树查找
//cmp==0 说明node.key==x.key 要进行替换操作
//cmp<0 说明node.key<x.key 要去左子树查找
int cmp = node.key.compareTo(x.key);
if (cmp < 0) {
x = x.right;
} else if (cmp == 0) {
x.setValue(node.value);
return;
} else {
x = x.left;
}
}
node.parent = parent;
if (parent != null) {
//判断node与parent的key 谁大
int cmp = node.key.compareTo(parent.key);
if (cmp > 0) { //当前node的key大于parent的key,需要将node放入右子节点
parent.right = node;
} else { //当前node的key小于parent的key,需要将node放入左子节点
parent.left = node;
}
} else {
this.root = node;
}
//需要调用修复红黑树平衡的方法
insertFixup(node);
}
/**
* 插入后修复红黑树平衡的方法
* |---场景1：红黑树为空树,将根节点染色为黑
* |---场景2：插入节点key已存在，不需要处理
* |---场景3：插入节点的父节点为黑色，因为所插入的路径黑色节点没有变化，红黑树依然平衡，不需要处理
* <p>
* 场景4：需要自己处理
* |---场景4：插入节点的父节点为红色
* |---场景4.1：叔叔节点存在，并为红色（父-叔 双红），将爸爸和叔叔染色为黑色，将爷爷染色为红色，并且再以爷爷节点做为当前节点 进行下一轮处理
* |---场景4.2：叔叔节点不存在，或者为黑色，父节点为爷爷节点的左子树
* |---场景4.2.1：插入节点为其父节点的左子节点（LL情况），将爸爸染色为黑色，爷爷染色为红色，然后以爷爷节点右旋，就完成了
* |---场景4.2.2：插入节点为其父节点的右子节点（LR情况），
* 将以爸爸节点进行一次左旋，得到LL双红的情景（4.2.1），指定爸爸节点为当前节点进行下一轮处理
* |---场景4.3：叔叔节点不存在，或者为黑色，父节点为爷爷节点的右子树
* |---场景4.3.1：插入节点为其父节点的右子节点（RR情况）,将爸爸染色为黑色，爷爷染色为红色，然后以爷爷节点左旋，就完成了
* |---场景4.3.2：插入节点为其父节点的左子节点（RL情况），
* 将以爸爸节点进行一次右旋，得到LL双红的情景（4.3.1），指定爸爸节点为当前节点进行下一轮处理
*/
private void insertFixup(RBNode node) {
this.root.setColor(BLACK);
RBNode parent = parentOf(node);
RBNode gparent = parentOf(parent);
//情景4：插入节点的父节点为红色
if (parent != null && isRed(parent)) {
//如果父节点为红色，一定存在爷爷节点，因为根节点为黑色
RBNode uncle = null;
if (parent == gparent.left) {
uncle = gparent.right;
//叔叔节点存在，并为红色（父-叔 双红）
if (uncle != null && isRed(uncle)) {
//将爸爸和叔叔染色为黑色，将爷爷染色为红色，并且再以爷爷节点做为当前节点 进行下一轮处理
setBlack(parent);
setBlack(uncle);
setRed(gparent);
insertFixup(gparent);
return;
}
//场景4.2：叔叔节点不存在，或者为黑色，父节点为爷爷节点的左子树
if (uncle == null || isBlack(uncle)) {
//情景4.2.1：插入节点为其父节点的左子节点（LL情况），将爸爸染色为黑色，爷爷染色为红色，然后以爷爷节点右旋，就完成了
if (node == parent.left) {
setBlack(parent);
setRed(gparent);
rightRotate(gparent);
return;
}
//场景4.2.2：插入节点为其父节点的右子节点（LR情况）
//将以爸爸节点进行一次左旋，得到LL双红的情景（4.2.1），指定爸爸节点为当前节点进行下一轮处理
if (node == parent.right) {
leftRotate(parent);
insertFixup(parent);
return;
}
}
} else { //父节点为爷爷节点的右子树
uncle = gparent.left;
if (uncle != null && isRed(uncle)) {
//将爸爸和叔叔染色为黑色，将爷爷染色为红色，并且再以爷爷节点做为当前节点 进行下一轮处理
setBlack(parent);
setBlack(uncle);
setRed(gparent);
insertFixup(gparent);
return;
}
//场景4.3：叔叔节点不存在，或者为黑色，父节点为爷爷节点的右子树
if (uncle == null || isBlack(uncle)) {
//场景4.3.1：插入节点为其父节点的右子节点（RR情况）,将爸爸染色为黑色，爷爷染色为红色，然后以爷爷节点左旋，就完成了
if (node == parent.right) {
setBlack(parent);
setRed(gparent);
leftRotate(gparent);
return;
}
if (node == parent.left) { //插入节点为其父节点的左子节点（RL情况），
// 将以爸爸节点进行一次右旋，得到LL双红的情景（4.3.1），指定爸爸节点为当前节点进行下一轮处理
rightRotate(parent);
insertFixup(parent);
return;
}
}
}
}
}
/**
* 左旋方法
* 左旋示意图
* p p
* | |
* x y
* / \ ----> / \
* lx y x ry
* / \ / \
* ly ry lx ly
* <p>
* <p>
* 1.将y的左子节点的父节点更新为x，并将x的右子节点指向y的左子节点
* 2.当x的父节点不为空时，更新y的父节点为x的父节点,并将x的父节点 指定 子树（当前x的子树位置）更新为y
* 3.将x的父节点更新为y，将y的左子节点更新为x
*/
private void leftRotate(RBNode x) {
RBNode y = x.right;
//将x的右节点更新为y的左子节点ly
x.right = y.left;
if (y.left != null) {
y.left.parent = x;
}
//2.当x的父节点不为空时，更新y的父节点为x的父节点,并将x的父节点 指定 子树（当前x的子树位置）更新为y
if (x.parent != null) {
y.parent = x.parent;
if (x == x.parent.left) {
x.parent.left = y;
} else {
x.parent.right = y;
}
} else {//说明x为根节点，此时更新y为根节点
this.root = y;
this.root.parent = null;
}
//3.将x的父节点更新为y，将y的左子节点更新为x
x.parent = y;
y.left = x;
}
/**
* 右旋方法
* 右旋示意图
* p p
* | |
* y x
* / \ ----> / \
* x ry lx y
* / \ / \
* lx ly ly ry
* <p>
* <p>
* 1.将y的左子节点指向x的右子节点，并将x的右子节点的父节点更新为y
* 2.当y的父节点不为空时，更新x的父节点为y的父节点,并将y的父节点 指定 子树（当前y的子树位置）更新为x
* 3.将y的父节点更新为x，将x的右子节点更新为y
*/
private void rightRotate(RBNode y) {
RBNode x = y.left;
//将y的左节点更新为x的右子节点ly
y.left = x.right;
if (x.right != null) {
x.right.parent = y;
}
//2.当y的父节点不为空时，更新x的父节点为y的父节点,并将y的父节点 指定 子树（当前y的子树位置）更新为x
if (y.parent != null) {
x.parent = y.parent;
if (y == y.parent.left) {
y.parent.left = x;
} else {
y.parent.right = x;
}
} else {//说明y为根节点，此时更新x为根节点
this.root = x;
this.root.parent = null;
}
//3.将y的父节点更新为x，将x的右子节点更新为y
y.parent = x;
x.right = y;
}
static class RBNode<K extends Comparable<K>, V> {
private RBNode parent;
private RBNode left;
private RBNode right;
private boolean color;
private K key;
private V value;
public RBNode() {
}
public RBNode(RBNode parent, RBNode left, RBNode right, boolean color, K key, V value) {
this.parent = parent;
this.left = left;
this.right = right;
this.color = color;
this.key = key;
this.value = value;
}
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;
}
public boolean isColor() {
return color;
}
public void setColor(boolean color) {
this.color = color;
}
public K getKey() {
return key;
}
public void setKey(K key) {
this.key = key;
}
public V getValue() {
return value;
}
public void setValue(V value) {
this.value = value;
}
}
public void padding(String ch, int n) {
int i;
for (i = 0; i < n; i++)
System.out.printf(ch);
}
void print_node(RBNode root, int level) {
if (root == null) {
padding("\t", level);
System.out.println("NIL");
} else {
print_node(root.right, level + 1);
padding("\t", level);
if (root.color == BLACK) {
System.out.printf(root.key + "(" + (root.isColor() ? "红" : "黑") + ")" + "\n");
} else
System.out.printf(root.key + "(" + (root.isColor() ? "红" : "黑") + ")" + "\n");
print_node(root.left, level + 1);
}
}
public RBNode getRoot() {
return root;
}
void print_tree() {
print_node(this.root, 0);
System.out.printf("-------------------------------------------\n");
}
删除操作的平衡调整
删除操作的平衡调整分为两步，第一步是针对删除节点初步调整。
初步调整只是保证整棵红黑树在一个节点删除之后，仍然满足最后一条定义的要求，也就是说，每个节点，从该节点到达其可达叶子节点的所有路径，都包含相同数目的黑色节点；
第二步是针对关注节点进行二次调整，让它满足红黑树的第三条定义，即不存在相邻的两个红色节点。
1. 针对删除节点初步调整
这里需要注意一下，红黑树的定义中“只包含红色节点和黑色节点”，经过初步调整之后，为了保证满足红黑树定义的最后一条要求，有些节点会被标记成两种颜色，“红 - 黑”或者“黑 - 黑”。如果一个节点被标记为了“黑 - 黑”，那在计算黑色节点个数的时候，要算成两个黑色节点。
CASE 1：如果要删除的节点是 a，它只有一个子节点 b：
-
删除节点 a，并且把节点 b 替换到节点 a 的位置，这一部分操作跟普通的二叉查找树的删除操作一样；
-
节点 a 只能是黑色，节点 b 也只能是红色，其他情况均不符合红黑树的定义。这种情况下，我们把节点 b 改为黑色；
调整结束，不需要进行二次调整。
CASE 2：如果要删除的节点 a 有两个非空子节点，并且它的后继节点就是节点 a 的右子节点 c：
-
如果节点 a 的后继节点就是右子节点 c，那右子节点 c 肯定没有左子树。我们把节点 a 删除，并且将节点 c 替换到节点 a 的位置。这一部分操作跟普通的二叉查找树的删除操作无异；
-
然后把节点 c 的颜色设置为跟节点 a 相同的颜色；
-
如果节点 c 是黑色，为了不违反红黑树的最后一条定义，我们给节点 c 的右子节点 d多加一个黑色，这个时候节点 d 就成了“红 - 黑”或者“黑 - 黑”；
-
这个时候，关注节点变成了节点 d，第二步的调整操作就会针对关注节点来做。
2. 针对关注节点进行二次调整
经过初步调整之后，关注节点变成了“红 - 黑”或者“黑 - 黑”节点。针对这个关注节点，我们再分四种情况来进行二次调整。二次调整是为了让红黑树中不存在相邻的红色节点。
CASE 1：如果关注节点是 a，它的兄弟节点 c 是红色的:
-
围绕关注节点 a 的父节点 b 左旋；
-
关注节点 a 的父节点 b 和祖父节点 c 交换颜色；
-
关注节点不变；
-
继续从四种情况中选择适合的规则来调整。
CASE 2：如果关注节点是 a，它的兄弟节点 c 是黑色的，并且节点 c 的左右子节点 d、e 都是黑色的:
-
将关注节点 a 的兄弟节点 c 的颜色变成红色；
从关注节点 a 中去掉一个黑色，这个时候节点 a 就是单纯的红色或者黑色； -
给关注节点 a 的父节点 b 添加一个黑色，这个时候节点 b 就变成了“红 - 黑”或者“黑 - 黑”；
-
关注节点从 a 变成其父节点 b；
-
继续从四种情况中选择符合的规则来调整。
CASE 3：如果关注节点是 a，它的兄弟节点 c 是黑色，c 的左子节点 d 是红色，c 的右子节点 e 是黑色:
-
围绕关注节点 a 的兄弟节点 c 右旋；
-
节点 c 和节点 d 交换颜色；
-
关注节点不变；
-
跳转到 CASE 4，继续调整。
CASE 4：如果关注节点 a 的兄弟节点 c 是黑色的，并且 c 的右子节点是红色的:
-
围绕关注节点 a 的父节点 b 左旋；
-
将关注节点 a 的兄弟节点 c 的颜色，跟关注节点 a 的父节点 b 设置成相同的颜色；
-
将关注节点 a 的父节点 b 的颜色设置为黑色；
-
从关注节点 a 中去掉一个黑色，节点 a 就变成了单纯的红色或者黑色；
-
将关注节点 a 的叔叔节点 e 设置为黑色；
-
调整结束。
扫一扫
109
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
