R-B Tree简介
R-B Tree，全称是Red-Black Tree，又称为“红黑树”，它一种特殊的二叉查找树。红黑树的每个节点上都有存储位表示节点的颜色，可以是红(Red)或黑(Black)。
红黑树的特性:
（1）每个节点或者是黑色，或者是红色。
（2）根节点是黑色。
（3）每个叶子节点（NIL）是黑色。 [注意：这里叶子节点，是指为空(NIL或NULL)的叶子节点！]
（4）如果一个节点是红色的，则它的子节点必须是黑色的。
（5）从一个节点到该节点的子孙节点的所有路径上包含相同数目的黑节点。
注意：
(01) 特性(3)中的叶子节点，是只为空(NIL或null)的节点。
(02) 特性(5)，确保没有一条路径会比其他路径长出俩倍。因而，红黑树是相对是接近平衡的二叉树。
结构定义
enum RBTColor{RED, BLACK};
template <class T>
class RBTNode{
public:
RBTColor color; // 颜色
T key; // 关键字(键值)
RBTNode *left; // 左孩子
RBTNode *right; // 右孩子
RBTNode *parent; // 父结点
RBTNode(T value, RBTColor c, RBTNode *p, RBTNode *l, RBTNode *r):
key(value),color(c),parent(),left(l),right(r) {}
};
红黑树的应用
红黑树的应用比较广泛，主要是用它来存储有序的数据，它的时间复杂度是O(lgn)，效率非常之高。
例如，Java集合中的TreeMap 和 TreeSet，C++ STL中的set、map，以及Linux虚拟内存的管理，都是通过红黑树去实现的。
红黑树的基本操作(一) 左旋和右旋
红黑树的基本操作是添加、删除。在对红黑树进行添加或删除之后，都会用到旋转方法。为什么呢？道理很简单，添加或删除红黑树中的节点之后，红黑树就发生了变化，可能不满足红黑树的5条性质，也就不再是一颗红黑树了，而是一颗普通的树。而通过旋转，可以使这颗树重新成为红黑树。简单点说，旋转的目的是让树保持红黑树的特性。
旋转包括两种：左旋 和 右旋。下面分别对它们进行介绍。
1. 左旋
对x进行左旋，意味着"将x变成一个左节点"。
左旋的伪代码《算法导论》：参考上面的示意图和下面的伪代码，理解“红黑树T的节点x进行左旋”是如何进行的。
LEFT-ROTATE(T, x)
01 y ← right[x] // 前提：这里假设x的右孩子为y。下面开始正式操作
02 right[x] ← left[y] // 将 “y的左孩子” 设为 “x的右孩子”，即 将β设为x的右孩子
03 p[left[y]] ← x // 将 “x” 设为 “y的左孩子的父亲”，即 将β的父亲设为x
04 p[y] ← p[x] // 将 “x的父亲” 设为 “y的父亲”
05 if p[x] = nil[T]
06 then root[T] ← y // 情况1：如果 “x的父亲” 是空节点，则将y设为根节点
07 else if x = left[p[x]]
08 then left[p[x]] ← y // 情况2：如果 x是它父节点的左孩子，则将y设为“x的父节点的左孩子”
09 else right[p[x]] ← y // 情况3：(x是它父节点的右孩子) 将y设为“x的父节点的右孩子”
10 left[y] ← x // 将 “x” 设为 “y的左孩子”
11 p[x] ← y // 将 “x的父节点” 设为 “y”
理解左旋之后，看看下面一个更鲜明的例子。你可以先不看右边的结果，自己尝试一下。
2. 右旋
对x进行左旋，意味着"将x变成一个左节点"。
右旋的伪代码《算法导论》：参考上面的示意图和下面的伪代码，理解“红黑树T的节点y进行右旋”是如何进行的。
RIGHT-ROTATE(T, y)
01 x ← left[y] // 前提：这里假设y的左孩子为x。下面开始正式操作
02 left[y] ← right[x] // 将 “x的右孩子” 设为 “y的左孩子”，即 将β设为y的左孩子
03 p[right[x]] ← y // 将 “y” 设为 “x的右孩子的父亲”，即 将β的父亲设为y
04 p[x] ← p[y] // 将 “y的父亲” 设为 “x的父亲”
05 if p[y] = nil[T]
06 then root[T] ← x // 情况1：如果 “y的父亲” 是空节点，则将x设为根节点
07 else if y = right[p[y]]
08 then right[p[y]] ← x // 情况2：如果 y是它父节点的右孩子，则将x设为“y的父节点的左孩子”
09 else left[p[y]] ← x // 情况3：(y是它父节点的左孩子) 将x设为“y的父节点的左孩子”
10 right[x] ← y // 将 “y” 设为 “x的右孩子”
11 p[y] ← x // 将 “y的父节点” 设为 “x”
旋转总结：
(01) 左旋 和 右旋 是相对的两个概念，原理类似。理解一个也就理解了另一个。
(02) 下面谈谈如何区分 左旋 和 右旋。
在实际应用中，若没有彻底理解 左旋 和 右旋，可能会将它们混淆。下面谈谈我对如何区分 左旋 和 右旋 的理解。
红黑树的插入操作
首先红黑树是二叉排序树，按排序树的方式插入一个结点之后，此结点肯定是叶子结点，那么到底应该给这个新结点涂什么颜色，涂黑的话，当前的分支会多一个黑结点，破坏了性质5，要恢复很麻烦，而涂红则没有影响，所以直接对新插入的结点涂红。
然后可以判断一下这个新结点是不是根（刚建树），如果是根则涂黑，以满足性质2。
但是如果它有父结点，那就要根据父结点的颜色分情况讨论了：
（以下情况都假设父结点在左边，在右边的情况都是对称的）。
一、如果新插入结点的父结点为黑色，则什么都不用做。
插入结点是红的，不会破坏性质。（新结点也可以在右边）
二、父结点为红色
如果父结点为红色，那由于性质2，说明父结点肯定不是根结点，那一定有祖父结点，且为黑色（性质4），叔叔结点可能有也可能为null。
从祖父结点来看，其父结点分支黑结点数为0（NULL这种东西不想多说），那么叔叔结点分支黑结点数也必须为0，所以进一步推断叔叔为null或者为红结点。那么就再分出这两种情况：
（1）叔叔为红结点的情况。
涂色之后，grandparent为根时的样子
grandparent不为根的情况，之后将其当成新结点进行操作
（2）叔叔为null时的情况
为了先解决parent这里的问题，肯定也只能将其涂黑再说，但是这样就多了一个黑结点，这里只有一种解决方法，就是对grandparent进行右旋，这样grandparent使右边多了一个黑结点，那么将其涂红即可。
要注意的是，之前的各种情况，新插入结点都是在左边，其实在右边也是一样的，但是这里就不同了，新插入的结点必须在左边，如果在右边，会在grandparent右旋之后成为其左孩子，这样一来，grandparent为红，新插入结点也为红，破坏了性质4，看下图。
所以应先对parent进行左旋操作，再将new和parent指针互换
最后对grandparent右旋变成：
到这里为止，红黑树的插入操作就全部解析完了。
/*
* 红黑树插入修正函数
*
* 在向红黑树中插入节点之后(失去平衡)，再调用该函数；
* 目的是将它重新塑造成一颗红黑树。
*
* 参数说明：
* root 红黑树的根
* node 插入的结点 // 对应《算法导论》中的z
*/
template <class T>
void RBTree<T>::insertFixUp(RBTNode<T>* &root, RBTNode<T>* node)
{
RBTNode<T> *parent, *gparent;
// 若“父节点存在，并且父节点的颜色是红色”
while ((parent = rb_parent(node)) && rb_is_red(parent))
{
gparent = rb_parent(parent);
//若“父节点”是“祖父节点的左孩子”
if (parent == gparent->left)
{
// Case 1条件：叔叔节点是红色
{
RBTNode<T> *uncle = gparent->right;
if (uncle && rb_is_red(uncle))
{
rb_set_black(uncle);
rb_set_black(parent);
rb_set_red(gparent);
node = gparent;
continue;//将祖父当成新插入结点继续修复
}
}
// Case 2条件:对于新插入结点在右边的情况，要将其转到左边来
if (parent->right == node)
{
RBTNode<T> *tmp;
leftRotate(root, parent);
tmp = parent;
parent = node;
node = tmp;
}
// Case 3条件：叔叔是空，且当前节点是左孩子。
rb_set_black(parent);
rb_set_red(gparent);
rightRotate(root, gparent);
}
else//若“z的父节点”是“z的祖父节点的右孩子”
{
// Case 1条件：叔叔节点是红色
{
RBTNode<T> *uncle = gparent->left;
if (uncle && rb_is_red(uncle))
{
rb_set_black(uncle);
rb_set_black(parent);
rb_set_red(gparent);
node = gparent;
continue;
}
}
// Case 2条件：对于新插入结点在左边的情况，要将其转到右边来
if (parent->left == node)
{
RBTNode<T> *tmp;
rightRotate(root, parent);
tmp = parent;
parent = node;
node = tmp;
}
// Case 3条件：叔叔是空，且当前节点是右孩子。
rb_set_black(parent);
rb_set_red(gparent);
leftRotate(root, gparent);
}
}
// 将根节点设为黑色
rb_set_black(root);
}
红黑树的删除操作
看了N篇博客，只感觉下面这篇的删除操作讲得非常好，先把链接贴出来再说：红黑树删除操作
然后是我自己的理解。
首先红黑树是二叉排序树，按排序树的方式删除一个结点，有三种情况：
（1）如果待删除的结点是叶子结点，则直接删除即可。
（2）如果待删除的结点只有一个孩子，则将父结点的指针指向它的孩子。
（3）如果待删除的结点有两个孩子，则可以找它的后继，将值覆盖过来，之后情况转变成删除前驱或者后继结点，回到（1）和（2）。
那么再根据颜色的不同，接下来情况就非常多了，这就是红黑树删除操作麻烦的地方，切忌浮躁，务必静下心来仔细分析。
第三种情况：
此情况因为可以转变成前面两种情况，相当于已经解决了。
第二种情况（一个孩子）：
此情况是个软柿子，可以先捏掉：
根据性质5，可以推断出的是，待删除结点必定是黑色（红色结点不可能只有一个孩子），且唯一的子树一定是一个红色孩子。所以这种情况可以在删除时就处理掉，用红色孩子顶替待删除结点，再将其涂成黑色。
变成：
第一种情况（叶子）：
首先，如果待删除结点为红色，则直接结束了。
如果待删除结点为黑色，这种情况下，此条分支不可能通过涂色的方式弥补缺少的黑色，所以要判断其兄弟和侄子的状况，希望通过兄弟那边分支的旋转，来保持黑色的数量：
（1）如果兄弟是黑色。
这种情况下，一旦deleted被删除，左边就比右边少了一个黑色结点，parent红色或者黑色都有可能，那两个侄子要么为null，要么为红色。
同样先捏软柿子：
1-1.如果两个侄子都为null，parent为红色
deleted结点被删除之后
此时只要将parent涂黑，brother涂红即可。
1-2.如果两个侄子都为null，parent为黑色
deleted结点被删除之后
这时，不论如何涂色，都无法让弥补左边缺少的一个黑色，所以只能先把brother涂红，让左右黑色数量相同，但是这样parent这棵树一定会少一个黑色，所以需要对parent进行又一轮的调整。
1-3.左侄子为红色（在网上见过两种调整方法，其中一种是将其转换成另一种情况，这里选择一步调整到位）
红色结点是不会影响红黑性质的，所以希望能够利用一下这个红结点。
删除deleted结点之后，经过一系列变换：
可以看到，左侄子被涂上了parent的颜色，目的是为了能够在后面顶替parent，而parent有自己的任务，就是去弥补左子树缺少的黑色。
1-4.右侄子为红色
brother涂上了parent的颜色为了顶替parent，parent的任务是去弥补左子树缺少的黑色，而右侄子则涂黑保持黑色数量相等。
（2）如果兄弟是红色，那么可以先转换成黑兄的情况。
可以肯定的是，那两个侄子肯定不为null。
parent左旋一下，然后parent和brother交换颜色，之后brother指向最下面那个结点。这样一来，就变成了上面的黑兄情况。
到这里为止，删除操作就全部分析完，这当然只是左孩子位置的情况，对称情况的分析是一样的。
/*
* 红黑树删除修正函数
*
* 在从红黑树中删除插入节点之后(红黑树失去平衡)，再调用该函数；
* 目的是将它重新塑造成一颗红黑树。
*
* 参数说明：
* root 红黑树的根
* node 待修正的节点
*/
template <class T>
void RBTree<T>::removeFixUp(RBTNode<T>* &root, RBTNode<T> *node, RBTNode<T> *parent)
{
RBTNode<T> *other;
// 如果顶替结点是黑色结点，并且不是根结点。替代节点为黑色，那么他肯定没有子节点了
while ((!node || rb_is_black(node)) && node != root)
{
//左孩子位置的所有情况
if (parent->left == node)
{
other = parent->right;
// case1 红兄，brother涂黑，parent涂红，parent左旋，replace的兄弟改变了，变成了黑兄的情况
if (rb_is_red(other))
{
// Case 1: x的兄弟w是红色的
rb_set_black(other);
rb_set_red(parent);
leftRotate(root, parent);
other = parent->right;
}
// 经过上面，不管进没进if，兄弟都成了黑色
// case2 黑兄，且兄弟的两个孩子都为黑或者都没孩纸
if ((!other->left || rb_is_black(other->left)) &&
(!other->right || rb_is_black(other->right)))
{
// 如果parent此时为红，则把brother的黑色转移到parent上
if (parent->color == RED)
{
rb_set_black(parent);
rb_set_red(other);
break;
}
else
{
// 如果此时parent为黑，即此时全黑了，则把brother涂红，导致brother分支少一个黑，使整个分支都少了一个黑，需要对parent又进行一轮调整
rb_set_red(other);
node = parent;
parent = rb_parent(node);
}
}
else
{
if (!other->right || rb_is_black(other->right))
{
// case3 黑兄，兄弟的左孩子为红色
rb_set_black(other->left);
rb_set_red(other);
rightRotate(root, other);
other = parent->right;
}
// Case 4: 黑兄 兄弟的右孩子为红色
rb_set_color(other, rb_color(parent));
rb_set_black(parent);
rb_set_black(other->right);
leftRotate(root, parent);
node = root;
break;
}
}
else//对称位置的情况，把旋转方向反回来
{
other = parent->left;
if (rb_is_red(other))
{
// Case 1: x的兄弟w是红色的
rb_set_black(other);
rb_set_red(parent);
rightRotate(root, parent);
other = parent->left;
}
// 经过上面，不管进没进if，兄弟都成了黑色
// case2 黑兄，且兄弟的两个孩子都为黑或者都没孩纸
if ((!other->left || rb_is_black(other->left)) &&
(!other->right || rb_is_black(other->right)))
{
// 如果parent此时为红，则把brother的黑色转移到parent上
if (parent->color == RED)
{
rb_set_black(parent);
rb_set_red(other);
break;
}
else
{
// 如果此时parent为黑，即此时全黑了，则把brother涂红，导致brother分支少一个黑，使整个分支都少了一个黑，需要对parent又进行一轮调整
rb_set_red(other);
node = parent;
parent = rb_parent(node);
}
}
else
{
if (!other->left || rb_is_black(other->left))
{
// Case 3: x的兄弟w是黑色的，并且w的左孩子是红色
rb_set_black(other->right);
rb_set_red(other);
leftRotate(root, other);
other = parent->left;
}
// Case 4: x的兄弟w是黑色的；并且w的右孩子是红色的
rb_set_color(other, rb_color(parent));
rb_set_black(parent);
rb_set_black(other->left);
rightRotate(root, parent);
node = root;
break;
}
}
}
if (node)
rb_set_black(node);
}
红黑树完整实现代码
#ifndef RBTREE_H
#define RBTREE_H
#include <stdlib.h>
#include <iostream>
using namespace std;
enum RBTColor{RED, BLACK};
template <class T>
class RBTNode{
public:
RBTColor color; // 颜色
T key; // 关键字(键值)
RBTNode *left; // 左孩子
RBTNode *right; // 右孩子
RBTNode *parent; // 父结点
RBTNode(T value, RBTColor c, RBTNode *p, RBTNode *l, RBTNode *r):
key(value),color(c),parent(),left(l),right(r) {}
};
template <class T>
class RBTree {
private:
RBTNode<T> *mRoot; // 根结点
public:
RBTree();
~RBTree();
// 中序遍历"红黑树"
void inOrder();
// (递归实现)查找"红黑树"中键值为key的节点
RBTNode<T>* search(T key);
// (非递归实现)查找"红黑树"中键值为key的节点
RBTNode<T>* iterativeSearch(T key);
// 将结点(key为节点键值)插入到红黑树中
void insert(T key);
// 删除结点(key为节点键值)
void remove(T key);
private:
// 中序遍历"红黑树"
void inOrder(RBTNode<T>* tree) const;
// (递归实现)查找"红黑树x"中键值为key的节点
RBTNode<T>* search(RBTNode<T>* x, T key) const;
// (非递归实现)查找"红黑树x"中键值为key的节点
RBTNode<T>* iterativeSearch(RBTNode<T>* x, T key) const;
// 左旋
void leftRotate(RBTNode<T>* &root, RBTNode<T>* x);
// 右旋
void rightRotate(RBTNode<T>* &root, RBTNode<T>* y);
// 插入函数
void insert(RBTNode<T>* &root, RBTNode<T>* node);
// 插入修正函数
void insertFixUp(RBTNode<T>* &root, RBTNode<T>* node);
// 删除函数
void remove(RBTNode<T>* &root, RBTNode<T> *node);
// 删除修正函数
void removeFixUp(RBTNode<T>* &root, RBTNode<T> *node, RBTNode<T> *parent);
// 销毁红黑树
void destroy(RBTNode<T>* &tree);
#define rb_parent(r) ((r)->parent)
#define rb_color(r) ((r)->color)
#define rb_is_red(r) ((r)->color==RED)
#define rb_is_black(r) ((r)->color==BLACK)
#define rb_set_black(r) do { (r)->color = BLACK; } while (0)
#define rb_set_red(r) do { (r)->color = RED; } while (0)
#define rb_set_parent(r,p) do { (r)->parent = (p); } while (0)
#define rb_set_color(r,c) do { (r)->color = (c); } while (0)
};
/*
* 对红黑树的节点(x)进行左旋转
*
* 左旋示意图(对节点x进行左旋)：
* px px
* / /
* x y
* / \ --(左旋)--> / \ #
* lx y x ry
* / \ / \
* ly ry lx ly
*
*
*/
template <class T>
void RBTree<T>::leftRotate(RBTNode<T>* &root, RBTNode<T>* x)
{
// 设置x的右孩子为y
RBTNode<T> *y = x->right;
// 将 “y的左孩子” 设为 “x的右孩子”；
// 如果y的左孩子非空，将 “x” 设为 “y的左孩子的父亲”
x->right = y->left;
if (y->left != NULL)
y->left->parent = x;
// 将 “x的父亲” 设为 “y的父亲”
y->parent = x->parent;
if (x->parent == NULL)
{
root = y; // 如果 “x的父亲” 是空节点，则将y设为根节点
}
else
{
if (x->parent->left == x)
x->parent->left = y; // 如果 x是它父节点的左孩子，则将y设为“x的父节点的左孩子”
else
x->parent->right = y; // 如果 x是它父节点的左孩子，则将y设为“x的父节点的左孩子”
}
// 将 “x” 设为 “y的左孩子”
y->left = x;
// 将 “x的父节点” 设为 “y”
x->parent = y;
}
/*
* 对红黑树的节点(y)进行右旋转
*
* 右旋示意图(对节点y进行左旋)：
* py py
* / /
* y x
* / \ --(右旋)--> / \ #
* x ry lx y
* / \ / \ #
* lx rx rx ry
*
*/
template <class T>
void RBTree<T>::rightRotate(RBTNode<T>* &root, RBTNode<T>* y)
{
// 设置x是当前节点的左孩子。
RBTNode<T> *x = y->left;
// 将 “x的右孩子” 设为 “y的左孩子”；
// 如果"x的右孩子"不为空的话，将 “y” 设为 “x的右孩子的父亲”
y->left = x->right;
if (x->right != NULL)
x->right->parent = y;
// 将 “y的父亲” 设为 “x的父亲”
x->parent = y->parent;
if (y->parent == NULL)
{
root = x; // 如果 “y的父亲” 是空节点，则将x设为根节点
}
else
{
if (y == y->parent->right)
y->parent->right = x; // 如果 y是它父节点的右孩子，则将x设为“y的父节点的右孩子”
else
y->parent->left = x; // (y是它父节点的左孩子) 将x设为“x的父节点的左孩子”
}
// 将 “y” 设为 “x的右孩子”
x->right = y;
// 将 “y的父节点” 设为 “x”
y->parent = x;
}
/*
* 将结点插入到红黑树中
*
* 参数说明：
* root 红黑树的根结点
* node 插入的结点 // 对应《算法导论》中的node
*/
template <class T>
void RBTree<T>::insert(RBTNode<T>* &root, RBTNode<T>* node)
{
RBTNode<T> *y = NULL;
RBTNode<T> *x = root;
// 1. 将红黑树当作一颗二叉查找树，将节点添加到二叉查找树中。
while (x != NULL)
{
y = x;
if (node->key < x->key)
{
x = x->left;
}
else if (node->key > x->key)
{
x = x->right;
}
else
{
printf("insert value %d exist \n",node->key);
return;
}
}
node->parent = y;
if (y != NULL)
{
if (node->key < y->key)
{
y->left = node;
}
else
{
y->right = node;
}
}
else
{
root = node;
}
// 2. 设置节点的颜色为红色
node->color = RED;
// 3. 将它重新修正为一颗二叉查找树
insertFixUp(root, node);
}
/*
* 将结点(key为节点键值)插入到红黑树中
*
* 参数说明：
* tree 红黑树的根结点
* key 插入结点的键值
*/
template <class T>
void RBTree<T>::insert(T key)
{
RBTNode<T> *z = NULL;
// 如果新建结点失败，则返回。
if ((z = new RBTNode<T>(key,BLACK,NULL,NULL,NULL)) == NULL)
return ;
insert(mRoot, z);
}
/*
* 红黑树插入修正函数
*
* 在向红黑树中插入节点之后(失去平衡)，再调用该函数；
* 目的是将它重新塑造成一颗红黑树。
*
* 参数说明：
* root 红黑树的根
* node 插入的结点 // 对应《算法导论》中的z
*/
template <class T>
void RBTree<T>::insertFixUp(RBTNode<T>* &root, RBTNode<T>* node)
{
RBTNode<T> *parent, *gparent;
// 若“父节点存在，并且父节点的颜色是红色”
while ((parent = rb_parent(node)) && rb_is_red(parent))
{
gparent = rb_parent(parent);
//若“父节点”是“祖父节点的左孩子”
if (parent == gparent->left)
{
// Case 1条件：叔叔节点是红色
{
RBTNode<T> *uncle = gparent->right;
if (uncle && rb_is_red(uncle))
{
rb_set_black(uncle);
rb_set_black(parent);
rb_set_red(gparent);
node = gparent;
continue;//将祖父当成新插入结点继续修复
}
}
// Case 2条件:对于新插入结点在右边的情况，要将其转到左边来
if (parent->right == node)
{
RBTNode<T> *tmp;
leftRotate(root, parent);
tmp = parent;
parent = node;
node = tmp;
}
// Case 3条件：叔叔是空，且当前节点是左孩子。
rb_set_black(parent);
rb_set_red(gparent);
rightRotate(root, gparent);
}
else//若“z的父节点”是“z的祖父节点的右孩子”
{
// Case 1条件：叔叔节点是红色
{
RBTNode<T> *uncle = gparent->left;
if (uncle && rb_is_red(uncle))
{
rb_set_black(uncle);
rb_set_black(parent);
rb_set_red(gparent);
node = gparent;
continue;
}
}
// Case 2条件：对于新插入结点在左边的情况，要将其转到右边来
if (parent->left == node)
{
RBTNode<T> *tmp;
rightRotate(root, parent);
tmp = parent;
parent = node;
node = tmp;
}
// Case 3条件：叔叔是空，且当前节点是右孩子。
rb_set_black(parent);
rb_set_red(gparent);
leftRotate(root, gparent);
}
}
// 将根节点设为黑色
rb_set_black(root);
}
/*
* 删除结点(node)，并返回被删除的结点
*
* 参数说明：
* root 红黑树的根结点
* node 删除的结点
*/
template <class T>
void RBTree<T>::remove(RBTNode<T>* &root, RBTNode<T> *node)
{
RBTNode<T> *child, *parent;
RBTColor color;
// 被删除节点的"左右孩子都不为空"的情况。
if ( (node->left != NULL) && (node->right != NULL) )
{
// 被删节点的后继节点。(称为"取代节点")
// 用它来取代"被删节点"的位置，然后再将"被删节点"去掉。
RBTNode<T> *replace = node;
// 获取后继节点
replace = replace->right;
while (replace->left != NULL)
replace = replace->left;
// "node节点"不是根节点(只有根节点不存在父节点)
if (rb_parent(node))
{
if (rb_parent(node)->left == node)
rb_parent(node)->left = replace;
else
rb_parent(node)->right = replace;
}
else
// "node节点"是根节点，更新根节点。
root = replace;
// child是"取代节点"的右孩子，也是需要"调整的节点"。
// "取代节点"肯定不存在左孩子！因为它是一个后继节点。
child = replace->right;
parent = rb_parent(replace);
// 保存"取代节点"的颜色
color = rb_color(replace);
// "被删除节点"是"它的后继节点的父节点"
if (parent == node)
{
parent = replace;
}
else
{
// child不为空
if (child)
{
rb_set_parent(child, parent);
}
//因为是后继，所以是左节点
parent->left = child;
replace->right = node->right;
rb_set_parent(node->right, replace);
}
replace->parent = node->parent;
replace->color = node->color;
replace->left = node->left;
node->left->parent = replace;
if (color == BLACK)
removeFixUp(root, child, parent);
delete node;
return ;
}
if (node->left !=NULL)
child = node->left;
else
child = node->right;
parent = node->parent;
// 保存"取代节点"的颜色
color = node->color;
if (child)
child->parent = parent;
// "node节点"不是根节点
if (parent)
{
if (parent->left == node)
parent->left = child;
else
parent->right = child;
}
else
root = child;
if (color == BLACK)
removeFixUp(root, child, parent);
delete node;
}
/*
* 删除红黑树中键值为key的节点
*
* 参数说明：
* tree 红黑树的根结点
*/
template <class T>
void RBTree<T>::remove(T key)
{
RBTNode<T> *node;
// 查找key对应的节点(node)，找到的话就删除该节点
if ((node = search(mRoot, key)) != NULL)
remove(mRoot, node);
}
/*
* 红黑树删除修正函数
*
* 在从红黑树中删除插入节点之后(红黑树失去平衡)，再调用该函数；
* 目的是将它重新塑造成一颗红黑树。
*
* 参数说明：
* root 红黑树的根
* node 待修正的节点
*/
template <class T>
void RBTree<T>::removeFixUp(RBTNode<T>* &root, RBTNode<T> *node, RBTNode<T> *parent)
{
RBTNode<T> *other;
// 如果顶替结点是黑色结点，并且不是根结点。替代节点为黑色，那么他肯定没有子节点了
while ((!node || rb_is_black(node)) && node != root)
{
//左孩子位置的所有情况
if (parent->left == node)
{
other = parent->right;
// case1 红兄，brother涂黑，parent涂红，parent左旋，replace的兄弟改变了，变成了黑兄的情况
if (rb_is_red(other))
{
// Case 1: x的兄弟w是红色的
rb_set_black(other);
rb_set_red(parent);
leftRotate(root, parent);
other = parent->right;
}
// 经过上面，不管进没进if，兄弟都成了黑色
// case2 黑兄，且兄弟的两个孩子都为黑或者都没孩纸
if ((!other->left || rb_is_black(other->left)) &&
(!other->right || rb_is_black(other->right)))
{
// 如果parent此时为红，则把brother的黑色转移到parent上
if (parent->color == RED)
{
rb_set_black(parent);
rb_set_red(other);
break;
}
else
{
// 如果此时parent为黑，即此时全黑了，则把brother涂红，导致brother分支少一个黑，使整个分支都少了一个黑，需要对parent又进行一轮调整
rb_set_red(other);
node = parent;
parent = rb_parent(node);
}
}
else
{
if (!other->right || rb_is_black(other->right))
{
// case3 黑兄，兄弟的左孩子为红色
rb_set_black(other->left);
rb_set_red(other);
rightRotate(root, other);
other = parent->right;
}
// Case 4: 黑兄 兄弟的右孩子为红色
rb_set_color(other, rb_color(parent));
rb_set_black(parent);
rb_set_black(other->right);
leftRotate(root, parent);
node = root;
break;
}
}
else//对称位置的情况，把旋转方向反回来
{
other = parent->left;
if (rb_is_red(other))
{
// Case 1: x的兄弟w是红色的
rb_set_black(other);
rb_set_red(parent);
rightRotate(root, parent);
other = parent->left;
}
// 经过上面，不管进没进if，兄弟都成了黑色
// case2 黑兄，且兄弟的两个孩子都为黑或者都没孩纸
if ((!other->left || rb_is_black(other->left)) &&
(!other->right || rb_is_black(other->right)))
{
// 如果parent此时为红，则把brother的黑色转移到parent上
if (parent->color == RED)
{
rb_set_black(parent);
rb_set_red(other);
break;
}
else
{
// 如果此时parent为黑，即此时全黑了，则把brother涂红，导致brother分支少一个黑，使整个分支都少了一个黑，需要对parent又进行一轮调整
rb_set_red(other);
node = parent;
parent = rb_parent(node);
}
}
else
{
if (!other->left || rb_is_black(other->left))
{
// Case 3: x的兄弟w是黑色的，并且w的左孩子是红色
rb_set_black(other->right);
rb_set_red(other);
leftRotate(root, other);
other = parent->left;
}
// Case 4: x的兄弟w是黑色的；并且w的右孩子是红色的
rb_set_color(other, rb_color(parent));
rb_set_black(parent);
rb_set_black(other->left);
rightRotate(root, parent);
node = root;
break;
}
}
}
if (node)
rb_set_black(node);
}
template<class T>
RBTNode<T>* RBTree<T>::search(RBTNode<T> *x,T key) const
{
if(x == NULL || x->key == key)
return x;
if(key < x->key)
return search(x->left,key);
else
return search(x->right,key);
}
template<class T>
RBTNode<T>* RBTree<T>::search(T key)
{
search(mRoot,key);
}
template<class T>
RBTNode<T>* RBTree<T>::iterativeSearch(RBTNode<T> *x,T key) const
{
while(x && (x->key != key))
{
if(key < x->key)
x = x->left;
else
x = x->right;
}
return x;
}
template<class T>
RBTNode<T>* RBTree<T>::iterativeSearch(T key)
{
iterativeSearch(mRoot,key);
}
template<class T>
void RBTree<T>::inOrder(RBTNode<T> *tree) const
{
if(tree)
{
inOrder(tree->left);
cout<<tree->key<<" ";
inOrder(tree->right);
}
}
template<class T>
void RBTree<T>::inOrder()
{
inOrder(mRoot);
}
template<class T>
RBTree<T>::RBTree():mRoot(NULL)
{
mRoot = NULL;
}
template<class T>
RBTree<T>::~RBTree()
{
//destroy();
}
#endif // RBTREE_H
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
