RB-Tree比较难的基础数据结构：红黑树是jdk1.7后的HashMap中的底层结构组成之一，是必须掌握的一个难的数据结构。
基础是BST的左旋右旋与查找后续节点三种，红黑树的插入操不算难，而删除操作是最难点；
文章目录
- 相关基础内容
- 遍历
- 前驱后继节点(这里只看BST)
- RB-Tree定义：
- 代码如下：
相关基础内容
遍历
- 前序遍历：根-左-右
- 中序遍历：左-根-右 （在二叉查找树中为从小到大输出）
- 后序遍历：左-右-根
- 层次遍历：从上到下，从左到右
前驱后继节点(这里只看BST)
找寻A节点的前驱后继节点： 通俗讲就是A的前后相邻值；
前驱节点：中序遍历中，A节点前一个节点 (解读：在BST中,即找左子树最大的值；若无左子树，找血缘最近有右子树到此A节点的长辈节点)
后继结点：中序遍历中，A节点后一个节点(解读：在BST中,即找右子树最小的值；若无右子树，找血缘最近有左子树到此A节点的长辈节点)
注意：BST中，删除一个A节点，可以让 节点A与其后续节点B 值互换，然后删除B节点；
———— 原理是：相同中序遍历的结果中，可以有很多种二叉搜索树的结构；所以，直接与后续节点B 值互换，然后删除B节点，就是将一种二叉树结构换成另一种结构，并无大碍；
RB-Tree定义：
- 节点非红必黑；
- 根节点是黑色；
- 每个叶子节点是黑色； （实体叶子都接上黑NULL或NIL节点)
- 一个节点为红色，那存在的父子节点为黑色；(无红红连接)
- 任意一节点到其叶子节点都有相同黑色高度；
代码如下：
- 红黑树的代码定义；
public class RBTree<K extends Comparable<K>,V>{
private static final boolean RED = false;
private static final boolean BLACK = true;
private RBNode root; // 省略get、set
static class RBNote<K extends Comparable<K>,V>{
private RBNode parent;
private RBNode left;
private RBNode right;
private boolean color;
private K key;
private V value;
// 省略 构造方法，get/set
}
}- 左旋操作：(右旋是一样的道理)
// 左旋 p为此次旋转的父节点
/** p pr
* / \ / \
* pl pr => p rr
* / \ /\
* rl rr pl rl
*/
private void leftRotate(RBTree p){
if(p != null) { // 注意p-pl与pr-rr两个不变的结构。
RBNode r = p.right;
// 第一步 rl接到p的右边(parent也要改)
p.right = r.left;
if(r.left != null) {
r.left.parent = p;
}
// 第二部 r(pr)替代p(包含p是谁的子树)
r.parent = p.parent;
if(p.parent == null) {
root = r;
}else if(p.parent.left == p) {
p.parent.left = r;
}else { p.parent.right = r;}
// 第三步，p与pr(即r)替换父子角色
r.left = p;
p.parent = r;
}
}- 插入操作
首先，插入位置一定是 叶子节点；其次，插入的是红节点，此时父节点若为黑则不用调整红黑树；
父节点为红时，爷爷节点一定为黑；此时考虑 两种主要变量：
- p父节点是右子树 还是 左子树
- u叔节点是红 还是 NIL (不可能为黑，因为黑节点的深度)
/* g 插入节点c为红(左右两种情况),p是为红(非红不调整),u为红|NIL(黑色深度),g黑
* / \ 1. p为右子树，u为红(g调红，u与p调黑=深度不变=将c=g当成插入红节点调整)
(红|NIL)u p红 2. p为右子树，u为NIL(这里需要区分c为左右子节点)
* / \ 2.1 c为左边，先右旋变为2.2的情况，再干；
* c红 c红 2.2 c为右，p黑,g红，再根据g左旋(变成爷节点黑，两父辈红)；
* 3. p为左子树，u为红与u为NIL 同1与2的分类，区别在于左右与左右旋
*/public void put(K key , V value){
RBNode t = this.root;
if(t == null){
root = new RBNode<>(key , value == null ? key : value,null);
return ;
}
int cmp ;
RBNode parent;
if(key == null){ throw new NullPointerException();}
do{
parent = t;
cmp = key.compareTo((K)t.key);
if(cmp < 0){
t = t.left;
}else if(cmp > 0){
t = t.right;
}else{
t.setValue(value==null?key:value);
return;
}
} while (t != null);
RBNode<K,Object> e=new RBNode<>(key,value==null?key:value,parent);
if(cmp < 0){
parent.left = e;
}else{
parent.right = e;
}
// 调整 变色 旋转
fixAfterPut(e);
}
/**
* 插入节点后的调整处理(新增开始为红色节点)
* 红黑树：新增红节点c+爷爷黑节点g+父叔为红p 调整为爷红，父叔为黑；若爷为root则调为黑；
* 自己理解：while循环-c不能为null与root且c.parent为红==需调整
* g 插入节点c为红(左右两种情况),p是为红(非红不调整),u为红|NIL(黑色深度),g黑
* / \ 1. p为右子树，u为红(g调红，u与p调黑=深度不变=将c=g当成插入红节点调整)
(红|NIL)u p红 2. p为右子树，u为NIL(这里需要区分c为左右子节点)
* / \ 2.1 c为左边，先右旋变为2.2的情况，再干；
* c红 c红 2.2 c为右，p黑,g红，再根据g左旋(变成爷节点黑，两父辈红)；
* 3. p为左子树，u为红与u为NIL 同1与2的分类，区别在于左右与左右旋
*/
private void fixAfterPut(RBNode<K, Object> x) {
x.color = RED;
// while 递归处理 p.color == red 保证了有g爷爷节点
while(x != null && x != root && x.parent.color == RED){
// p是g的左节点（注意--因为父为红-uncle只能为红与null）
if(parentOf(x) == parentOf(parentOf(x)).left){
RBNode uncle_R = rightOf(parentOf(parentOf(x)));
if(colorOf(uncle_R) == RED){
// 父亲节点和叔叔节点设置为黑色
setColor(parentOf(x),BLACK);
setColor(uncle_R,BLACK);
// 爷爷节点设置为 红色
setColor(parentOf(parentOf(x)),RED);
// 递归处理（将爷爷节点设置为"插入节点"）
x = parentOf(parentOf(x));
}else{ // uncle为null(不可能为黑--因为父为红-uncle只能为红与null-黑色深度)
if(x == parentOf(x).right){
// 如果x是父节点的右节点那么我们需要先根据 父节点 左旋
x = parentOf(x);
leftRotate(x);
}
setColor(parentOf(x),BLACK);
// 将爷爷节点变为红色
setColor(parentOf(parentOf(x)),RED);
// 右旋转 根据爷爷节点右旋转
rightRotate(parentOf(parentOf(x)));
}
}else{ // p是g的右孩子
RBNode uncle_L = leftOf(parentOf(parentOf(x)));
if(colorOf(uncle_L) == RED){
setColor(parentOf(x),BLACK);
setColor(uncle_L,BLACK);
setColor(parentOf(parentOf(x)),RED);
x = parentOf(parentOf(x));
}else{
// 情况2
if( x == parentOf(x).left){
x = parentOf(x);
rightRotate(x);
}
setColor(parentOf(x),BLACK);
setColor(parentOf(parentOf(x)),RED);
leftRotate(parentOf(parentOf(x)));
}
}
}
root.color = BLACK;
}- 删除操作
前提：如果删除的节点右两个子节点，此时需要找到前驱节点或者后继节点可以替换变为 删除叶子节点 与 一个子节点 的情况
/** 分两大类：删除节点D为左右子树两大类(都是非root的黑节点)
* 左子树： 1. B红时：P为黑，PB互换颜色，以P左旋变成2、3、4的情况。
* 2. B黑l、r为黑：B设为红，P指向D循环。
* 3. B黑r黑l红：Bl互换颜色，以B右旋变成4的情况。
* 4. B黑r红：PB互换颜色，r变黑，以p进行左旋(终止D=root)。
* 右子树：同左子树
*/下面第二种情况图没画好：转换后的p应该画成 红色：向上递归
public V remove(K key){ // 先找到这个节点
RBNode node = getNode(key);
if(node == null){
return null;
}// 把值存起来 删除后 返回
V oldValue = (V) node.value;
deleteNode(node);
return oldValue;
}
/**
* 如果删除的节点右两个子节点，此时需要找到前驱节点或者后继节点可以变为 删除叶子节点 与 一个子节点 的情况
*/
private void deleteNode(RBNode node){
// node节点有两个子节点
if(node.left !=null && node.right != null){
// 找到要删除节点的后继节点
RBNode successor = successor(node);
// 然后用后继节点的信息覆盖掉 要删除节点的信息
node.key = successor.key;
node.value = successor.value;
// 然后我们要删除的节点就变为了 后继节点
node = successor;
}
// 删除有一个子节点的情况
RBNode replacement = node.left != null ? node.left : node.right;
if(replacement != null){
// 替代者的父指针指向原来 node 的父节点
replacement.parent = node.parent;
if(node.parent == null){ // 说明 node 是root节点
root = replacement;
}else if(node == node.parent.left){// 双向绑定
node.parent.left = replacement;
}else{
node.parent.right = replacement;
}
node.left = node.right = node.parent = null;
// 替换完成后需要调整平衡--删除的是node/replacement是子节点；
if(node.color == BLACK){
fixAfterRemove(replacement);
}
}else if(node.parent == null){
// 要删除的是root节点
root = null;
}else{
// 1. node节点是叶子节点(node是需要删除的) replacement为null
// 要是先删除就找不到 x.parent了，因为x为null;
if(node.color == BLACK){
fixAfterRemove(node)
}
if(node.parent != null){
if(node == node.parent.left){
node.parent.left = null;
}else{
node.parent.right = null;
}
node = null;
}
}
/** 分两大类：删除节点D为左右子树两大类(都是非root的黑节点)
* 左子树： 1. B红时：P为黑，PB互换颜色，以P左旋变成2、3、4的情况。
* 2. B黑l、r为黑：B设为红，P指向D循环。
* 3. B黑r黑l红：Bl互换颜色，以B右旋变成4的情况。
* 4. B黑r红：PB互换颜色，r变黑，以p进行左旋(终止D=root)。
* 右子树：同左子树
*/
private void fixAfterRemove(RBNode x){
while(x != root && colorOf(x) == BLACK){
// x 是左孩子的情况
if(x == leftOf(parentOf(x))){
RBNode rNode = rightOf(parentOf(x));
// 情况1
if(colorOf(rNode) == RED){ // 2-3-4树的 3节点 交换颜色，然后左旋一次就可以了
setColor(rNode,BLACK);
setColor(parentOf(x),RED);
leftRotate(parentOf(x)); // 左旋一次
rNode = rightOf(parentOf(x)); // 找到真正的兄弟节点
} //情况2
if(colorOf(leftOf(rNode)) == BLACK && colorOf(rightOf(rNode))==BLACK){
setColor(rNode,RED);
x=parentOf(x); // 向上递归
}else{
// 情况3 r为黑，l为红
if(colorOf(rightOf(rNode)) == BLACK){
setColor(rNode,RED);
setColor(leftOf(rNode),BLACK);
rightRotate(rNode);
// 重新调整叔叔节点的位置
rNode = rightOf(parentOf(x));
}
// 情况4
setColor(rNode, colorOf(parentOf(x)));
setColor(parentOf(x),BLACK);
setColor(rightOf(rNode),BLACK);
leftRotate(parentOf(x));
x = root; // 结束循环递归
}
}else{ // 右子树情况，与左子树情况差不多，不解释了。
RBNode rNode = leftOf(parentOf(x));
if(colorOf(rNode) == RED){
setColor(rNode,BLACK);
setColor(parentOf(x),RED);
rightRotate(parentOf(x));
rNode = leftOf(parentOf(x));
}
if(colorOf(rightOf(rNode)) == BLACK && colorOf(leftOf(rNode)) == BLACK){
setColor(rNode,RED);
x=parentOf(x);
}else{
if(colorOf(leftOf(rNode)) == BLACK){
setColor(rNode,RED);
setColor(leftOf(rNode),BLACK);
leftRotate(rNode);
rNode = leftOf(parentOf(x));
}
setColor(rNode, colorOf(parentOf(x)));
setColor(parentOf(x),BLACK);
setColor(leftOf(rNode),BLACK);
rightRotate(parentOf(x));
x = root;
}
}
}
setColor(x,BLACK);
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
