红黑树及C++代码实现
红黑树及C++代码实现
红黑树是二叉搜索树的一种,单次插入、删除、查询的时间复杂度都是\(O(log(n))\)。红黑树的应用广泛,STL的set和map、Java的TreeSet和TreeMap等都是使用红黑树实现的
哨兵节点
在红黑树中,所有的叶子节点、根节点的父节点都是一个名为哨兵节点的节点。哨兵节点用于处理边界条件,可以很方便的识别树的边缘,用NIL来表示。哨兵节点替代的是原来空指针的作用,哨兵节点可以降低访问空指针的风险,同时也可以简化代码中的逻辑判断
性质
一颗红黑树必须满足下面五条性质:
- 节点为红色或黑色
- 根节点为黑色
- NIL节点为黑色
- 红色节点的子节点为黑色
- 从根节点到NIL节点的简单路径上的黑色节点数量相同(又或者说从任意一个节点出发到达NIL节点的所有简单路径所经过的黑色节点数量相同)
思考下面的二叉树是否为红黑树
root(B)
\
N(R)
/ \
NL(B) NR(B)
乍一看好像是红黑树,因为根节点到NL和NR的路径上的黑色节点数相同。但实际上这颗树并不是红黑树,将NIL节点画出来一目了然
root(B)
/ \
NIL N(R)
/ \
NL(B) NR(B)
/ \ / \
NIL NIL NIL NIL
注意到根节点到达NIL节点有5条路径,经过的黑色节点(NIL算作黑色节点)数量分别为2、3、3、3、3,并不是全相等的,所以这颗二叉树不是红黑树
同时这也解释了为什么要使用哨兵节点
为什么红黑树效率高
从红黑树的性质出发,在不考虑NIL节点的情况下,假设根节点到叶节点的路径上经过的黑色节点数为\(r\),假设树的高度为\(h\),那么有
其实很好理解,在没有红色节点的情况下,路径上至少都会有\(r\)个黑色节点。有红色节点的情况下,路径节点最多的情况应该是黑红相间
假设红黑树中有\(n\)个节点(不包含NIL节点)那么有
节点最少的情况下,节点应该全为黑色,此时红黑树是一颗满二叉树(红黑树的性质决定)
root(B)
/ \
N(R) S(B)
/ \ / \
NL(B) NR(B) SL(B) SR(B)
/ \ / \ / \ / \
NIL NIL NIL NIL NIL NIL NIL NIL
上面的红黑树的高度为3(不计NIL节点),其节点数为\(2^3-1\),对于全黑的红黑树,其节点数为\(2^r - 1\)
而在全黑的情况下,我们还可以加上一些红色节点,也不会破坏红黑树的性质5,所以有\(n \ge 2^r - 1\)
做一个变形
又因为\(r\le h \le 2r\)
所以可以得到树高\(h\),与节点数\(n\)的关系
红黑树又是一颗二叉搜索树,二叉搜索树进行插入、删除、查找的复杂度取决于树的最大高度,于是我们就可以知道红黑树进行插入、删除、查找的复杂度为\(O(log(n))\)
为什么使用红黑树而不是AVL树
AVL树的最大高度大约为\(\lfloor log_2(n) \rfloor + 1\),比红黑树少一个常数,那为什么STL和Java使用红黑树而不使用AVL树呢?
AVL树的高度小于红黑树,这让它在查询操作的表现比红黑树更加优秀,因为查询操作并不会改变树的结构。但是在面对大量数据写入和删除的情况,AVL树为了保持平衡性,会经常进行旋转,以保证AVL树的左子树和右子树的高度差不超过1。而红黑树对树结构的要求并不像AVL树那么严格,旋转的次数会少于AVL树。这就导致红黑树的整体性能比AVL树更加优秀
旋转
旋转操作用于调整树的结构,很常用
左旋
假如对P点左旋,那么将P的右节点B变为P的父节点,将P变为其左节点A的父节点,将P的右节点B的左节点BL变为P的右节点
P B
/ \ P点左旋 / \
A B -----> P BR
/ \ / \ / \
AL AR BL BR A BL
/ \
AL AR
右旋
与左旋完全反过来
假如对P点右旋,那么将P的左节点A变为P的父节点,将P变为其右节点B的父节点,将P的左节点A的右节点AR变为P的左节点
P A
/ \ P点右旋 / \
A B -----> AL P
/ \ / \ / \
AL AR BL BR AR B
/ \
BL BR
插入
插入节点颜色选取
根据红黑树的性质,节点必须为红色或者黑色中的一种。那么对于插入操作,插入的节点应该是什么颜色呢?
如果插入节点为黑色,那么我们将节点插入以后,红黑树的性质5一定会被打破,有一条路径上的黑色节点数会增加1,好像并不好调整,如果要调整,我们就需要将路径上的一个节点变为红色,以保证性质5成立,但是一个节点变为红色又可能会打破性质4
如果插入节点为红色,那么我们将节点插入以后,红黑树的性质5不会被打破,但性质4却也有可能会被打破
而在后面可以知道,连续两个红色节点是可以调整的
插入红色节点可以省去变红的操作,更加方便。因此选择红色作为插入节点的颜色
Case 1:树为空
直接插入节点,并将节点的颜色变为黑色
Case 2:父节点为黑色节点
直接插入,不需要额外操作
Case 3:父节点为红色节点
-
叔叔节点为红色节点
将父节点以及叔叔节点变为黑色,将祖先节点变为红色。但是调整后祖先节点的父节点可能为红色,违反了性质4,因此我们需要递归的去调整祖先节点,直到没有冲突出现
G(B) G(R) / \ / \ P(R) U(R) -----> P(B) U(B) / / N(R) N(R)
-
叔叔节点为黑色,且插入节点与父节点同为左节点或右节点
这种情况可以直接调整,将祖先节点G旋转,方向与父节点P方向相反,旋转后将父节点变成黑色,祖先节点变为红色
G(B) P(B) / \ G左旋 / \ U(B) P(R) -----> G(R) N(R) \ / N(R) U(B)
-
叔叔节点为黑色,且插入节点与父节点方向相反
这种情况可以转换为上面一种情况,从而直接进行调整。先将父节点P旋转,旋转方向与插入节点的方向相反,旋转后即可按照上面一种情况调整
G(B) G(B) N(B) / \ P右旋 / \ G左旋 / \ U(B) P(R) -----> U(B) N(R) -----> G(R) P(R) / \ N(R) P(R)
删除
双黑节点
在进行删除操作之前,有必要先了解一下双黑节点是什么
在红黑树中,双黑节点(Double Black Node) 是一个逻辑标记,用于表示在删除操作后某个位置需要“补足”一个额外的黑色节点,以维护红黑树的黑高一致性(所有路径的黑色节点数量相同)。它本身不是一种真实的颜色,而是修复红黑树性质时的一种临时状态。
从上面的解释中可以知道,如果某节点被打上双黑节点标记,就意味着这个节点会额外算作一个黑色节点,以保证红黑树的性质。但一个节点不能扮演两个角色,我们需要通过旋转、变色等操作将双黑节点标记消除(注意双黑节点是一个逻辑标记),消除后整棵树仍然是红黑树。
在删除操作时,如果出现了双黑节点,不会立即调整树的结构,而是在之后的删除调整操作进行统一的操作
近侄节点与远侄节点
-
近侄节点:兄弟节点靠近删除节点的子节点
-
远侄节点:兄弟节点远离删除节点的子节点
P
/ \
N S
/ \
SL SR
现在有上面一棵树,对于节点N来说,S为N的兄弟节点,SL则为N的近侄节点,SR则为N的远侄节点
Case 1:删除节点为树中唯一节点
若删除节点为树中的唯一节点,直接删除即可
Case 2:删除节点没有非NIL的子节点
-
删除节点为红色节点
如果删除的节点为红色,直接删除即可,删除后的树依旧是一颗红黑树,满足红黑树的五条性质
P(?) P(?) / \ 删除后 / \ N(R) S(?) ------> NIL S(?) / \ / \ / \ NIL NIL SL(?) SR(?) SL(?) SR(?)
-
删除的节点为黑色节点
P(?) / \ N(B) S(?) / \ / \ NIL NIL SL(?) SR(?)
我们首先删除需要删除的节点N,补上一个NIL节点,所补的NIL节点会被打上双黑节点标记,我们用C来表示这个NIL节点
如果C节点只算做一个黑色节点,那么肯定是不满足性质5的,但是如果C节点算作两个黑色节点,那么就满足性质5了。在后面的删除调整操作我们考虑如何将双黑节点标记去除掉
P(?) P(?) / \ / \ N(B) S(?) ------> C(DB) S(?) / \ / \ / \ NIL NIL SL(?) SR(?) SL(?) SR(?)
Case 3:删除节点有且仅有一个非NIL的子节点
这种情况下删除节点只能是黑色,并且删除节点的非NIL子节点只能是红色
-
如果删除节点是红色,那么删除节点的非NIL子节点一定为黑色,只有这样才能满足性质4。但是注意,从删除节点出发,如果直接走NIL子节点方向,那么路径上经过的黑色节点数为1,但走非NIL子节点方向,路径上经过的黑色节点数是大于1的,至少有非NIL子节点和非NIL子节点下面的NIL子节点两个黑色节点,因此该情况不满足红黑树的性质。
N(R) / \ NIL NR(B) / \ NIL NIL
-
如果删除节点是黑色,删除节点的非NIL节点也为黑色,如同第一种情况,从删除节点出发,走NIL节点方向,路径上经过2个黑色节点,而走非NIL节点方向,路径上至少经过3个黑色节点,因此该情况也不满足红黑树的性质
N(B) / \ NIL NR(B) / \ NIL NIL
因此删除节点只能是黑色,删除节点的非NIL子节点只能是红色
对于这种情况,可以直接调整。删除节点,用非NIL子节点代替该节点,并将节点颜色变成黑色
P(?) P(?)
/ /
N(B) NR(B)
/ \ / \
NIL NR(R) -----> NIL NIL
/ \
NIL NIL
Case 4:删除节点有两个非NIL的子节点
这种情况我们需要找到删除节点的后继节点,即右子树中最小的节点,然后交换两个节点,颜色不交换,然后继续删除需要删除的节点
此时会发现,删除的情况变成了Case 2或者Case 3
这是因为二叉搜索树的后继节点没有左节点,因此后继节点最多只有一个非NIL节点
删除调整
删除调整操作的目的是为了去除在删除过程中出现的双黑节点标记,下面会分成几种情况进行讨论
Case 1: 兄弟节点为黑色且兄弟节点的两个子节点为黑色
-
如果父节点为红色
只需要将兄弟节点S变成红色,父节点P变成黑色就可以直接去掉双黑节点
P(R) P(B) / \ / \ C(DB) S(B) -----> C(B) S(R) / \ / \ SL(B) SR(B) SL(B) SR(B)
调整前后,根节点经过P点到达NIL节点的所有简单路径经过的黑色节点数量是相同的
-
如果父节点为黑色
还是先将兄弟节点S变成红色
但是注意这里并不能像上面那样,直接将S变成红色然后去掉双黑节点就完了,虽然调整后在这颗子树上满足了性质5,但是在整棵树上,经过P节点的路径的黑色节点数会减少一个,与其他路径的黑色节点数量不同,不满足性质5
因此我们需要为父节点打上双黑节点标记,如果P节点算作两个黑色节点,那么就满足性质5了,然后继续调整父节点P,直到没有双黑节点出现
P(B) P(DB) / \ / \ C(DB) S(B) -----> C(B) S(R) / \ / \ SL(B) SR(B) SL(B) SR(B)
Case 2:兄弟节点为黑色并且远侄节点为红色
这种情况可以直接进行调整
这里以删除节点为父节点的左节点为例,将父节点P进行旋转(删除节点在哪边就往哪边旋转),将兄弟节点S的颜色变为父节点P的颜色,父节点P和远侄节点SR的颜色变为黑色,去掉双黑标记
P(?) S(?)
/ \ / \
C(DB) S(B) 左旋 P(B) SR(B)
/ \ -----> / \
SL(?) SR(R) C(B) SL(?)
可以看到调整后无论是在局部,还是在整体都是满足红黑树的性质的
Case 3:兄弟节点为黑色并且近侄节点为红色,远侄点为黑色
这种情况需要转换为 Case 2 状态,进而进行调整
这里以删除节点为父节点的左节点为例,将兄弟节点S进行旋转(删除节点在哪边,往反方向旋转),将S的颜色变为红色,将SL的颜色变为黑色,调整后按照 Case 2 继续调整
P(?) P(?)
/ \ / \
C(DB) S(B) 右旋 C(DB) SL(B)
/ \ -----> \
SL(R) SR(B) S(R)
\
SR(B)
Case 4:兄弟节点为红色
根据性质4,父节点一定为黑色,兄弟节点的两个子节点一定是黑色
策略是将兄弟节点变成黑色,然后继续调整。
将父节点P进行旋转(删除节点在哪边就往哪边旋转),将兄弟节点S变成黑色,将父节点P变为红色。之后就可以按照前面的情况进行处理了
P(B) S(B)
/ \ / \
C(DB) S(R) -----> P(R) SR(B)
/ \ / \
SL(B) SR(B) C(DB) SL(B)
此时SL作为新的兄弟节点,继续调整C(DB)节点
测试
正确性测试
-
插入
我们使用洛谷P3879来验证我们的插入是否有问题。经过测试可以AC这道题,通过代码放在最后面(有点长)
-
删除
删除没有找到什么简单的题目,于是就造了一个简单的数据,数据规模为\(10^7\)
下面为生成数据的python代码
import random in_path = "./data.in" out_path = "./data.out" # 数据大小 N = int(1e7) # 数据范围 minNum = 0 # 最大范围我们取节点数的十倍 maxNum = int(N * 10) # 删除节点为一般节点 erase_num = N // 2 if __name__ == '__main__': # 生成N个区间内不重复的随机数 x = random.sample(range(minNum, maxNum), N) # 获取删除的下标 idxs = random.sample(range(0, len(x)), erase_num) # 获取到需要删除的数 y = [x[idx] for idx in idxs] # 我们要算出哪些还存在,需要进行集合运算 set_y = set(y) set_x = set(x) # 计算出最终的答案 set_y = list(set_x - set_y) # 输入 with open(in_path, mode='w', encoding='utf-8') as f: f.write(f"{N}\n") for each in x: f.write(f"{each}\n") f.write(f"{erase_num}\n") for each in y: f.write(f"{each}\n") # 输出 with open(out_path, mode='w', encoding='utf-8') as f: f.write(f"{len(set_y)}\n") for each in set_y: f.write(f"{each}\n")
下面为验证的python代码
import subprocess import time from subprocess import * cpp_path = "./RBTree.cpp" exe_path = "./RBTree.exe" test_cpp_path = "./test.cpp" test_exe_path = "./test.exe" out_path = "./out.out" data_path = "./data.out" in_path = "./data.in" with open(in_path,"r",encoding="utf-8") as f : stdin = f.read() compile_res = subprocess.run(["g++",cpp_path,"-o",exe_path],capture_output=True,text=True,timeout=5) # 编译成功 if compile_res.returncode == 0: st = time.time() run_res = subprocess.run([exe_path],input=stdin,capture_output=True,text=True,timeout=100) ed = time.time() print(f"running time: {(ed - st) * 1000.0}ms") out = run_res.stdout with open(out_path, "w", encoding="utf-8") as f: f.write(out) with open(data_path,"r",encoding="utf-8") as f1,open(out_path,"r",encoding="utf-8") as f2: N1 = int(f1.readline().strip()) N2 = int(f2.readline().strip()) if(N1 != N2) : print("Wrong Answer!") else: # 由于数据是不重复的且输出顺序并不固定,直接用集合判断 data1 = set([int(x.strip()) for x in f1.readlines()]) data2 = set([int(x.strip()) for x in f2.readlines()]) if data1 == data2: print("Accept!") else : print("Wrong Answer!")
下面为测试结果,没问题
-
黑高检验
我们还是来检测一下整颗红黑树的黑高是否正确,检测代码如下
void checkBlackHeight() { bool flag = true; checkBlackHeightHelp(root, flag); if (flag) cout << "right!" << endl; else cout << "error!" << endl; } int checkBlackHeightHelp(Node *N, bool &flag) { // NIL节点为黑色 if (N == NIL) return 1; int left = checkBlackHeightHelp(N->left, flag); int right = checkBlackHeightHelp(N->right, flag); if (left != right) flag = false; return left + (N->color == Color::BLACK ? 1 : 0); }
我们在插入和删除后分别进行一次黑高检验,没有问题
-
性能测试
我们使用STL的set进行对比,数据还是上面删除检验的数据。但首先我们先对程序优化一下,主要是优化输入和输出,数据量大了cin和cout的速度很慢,关闭流同步速度会快很多
在主函数中加入下面的代码即可
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
set测试代码如下
#include <iostream>
using namespace std;
#include <set>
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
set<int> s;
int n;
cin >> n;
for (int i = 0; i < n; i++)
{
int x;
cin >> x;
s.insert(x);
}
int m;
cin >> m;
for (int i = 0; i < m; i++)
{
int x;
cin >> x;
s.erase(x);
}
cout << s.size() << endl;
for (auto x : s)
cout << x << endl;
}
-
RBTree测试结果
-
set测试结果
我们实现的红黑树快了将近10秒,还不错
代码实现
颜色表示
这里用枚举类型表示红色和黑色
enum Color
{
RED,
BLACK
};
红黑树节点表示
使用结构体来表示红黑树的节点
template <typename Key, typename Value>
struct RBTreeNode
{
// 按照key值进行插入删除等操作
Key key;
// value为存储的数据
Value value;
// 左节点指针
RBTreeNode<Key, Value> *left;
// 右节点指针
RBTreeNode<Key, Value> *right;
// 父节点指针
RBTreeNode<Key, Value> *parent;
// 节点颜色
Color color;
RBTreeNode(Color c, RBTreeNode<Key, Value> *l = nullptr, RBTreeNode<Key, Value> *r = nullptr, RBTreeNode<Key, Value> *p = nullptr)
{
color = c, left = l, right = r, parent = p;
}
RBTreeNode(Key k, Value v, Color c, RBTreeNode<Key, Value> *l = nullptr, RBTreeNode<Key, Value> *r = nullptr, RBTreeNode<Key, Value> *p = nullptr)
{
key = k, value = v, color = c, left = l, right = r, parent = p;
}
};
创建节点
为了避免直接New内存(因为不好看),写四个辅助函数用于创建红黑树的节点
但首先我们先给节点类型取个别名,原来节点类型太长了
typedef RBTreeNode<Key, Value> Node;
-
创建红色空节点
// 创建一个空的红色节点 Node *createEmptyRedNode(Node *l = nullptr, Node *r = nullptr, Node *p = nullptr) { return new Node(Color::RED, l, r, p); }
-
创建红色非空节点
// 创建一个非空红色节点 Node *createRedNode(Key key, Value value, Node *l = nullptr, Node *r = nullptr, Node *p = nullptr) { return new Node(key, value, Color::RED, l, r, p); }
-
创建黑色空节点
// 创建一个空的黑色节点 Node *createEmptyBlackNode(Node *l = nullptr, Node *r = nullptr, Node *p = nullptr) { return new Node(Color::BLACK, l, r, p); }
-
创建黑色非空节点
// 创建一个非空黑色节点 Node *createBlackNode(Key key, Value value, Node *l = nullptr, Node *r = nullptr, Node *p = nullptr) { return new Node(key, value, Color::BLACK, l, r, p); }
也为了避免直接用delete释放内存,同样写一个辅助函数来删除节点
// 销毁节点
Node *destroyNode(Node *node)
{
delete node;
}
左旋
// 左旋操作
void leftRotate(Node *p)
{
// 获取旋转节点的右儿子
Node *rightSon = p->right;
// 获取祖先节点
Node *grandParent = p->parent;
// 更新旋转节点
p->right = rightSon->left;
p->parent = rightSon;
// 更新右节点
// 如果右儿子的左节点不为NIL,则将右儿子的左节点的父节点设置为p
if (rightSon->left != NIL)
rightSon->left->parent = p;
rightSon->parent = grandParent;
rightSon->left = p;
// 更新祖先节点
// 如果p为根节点
if (grandParent == NIL)
root = rightSon;
// 如果p为左节点
else if (grandParent->left == p)
grandParent->left = rightSon;
// 如果p为右节点
else
grandParent->right = rightSon;
}
右旋
// 右旋操作
void rightRotate(Node *p)
{
// 获取旋转节点的左儿子
Node *leftSon = p->left;
// 获取祖先节点
Node *grandParent = p->parent;
// 更新旋转节点
p->left = leftSon->right;
p->parent = leftSon;
// 更新左节点
// 如果左儿子的右节点不为NIL,则将左儿子的右节点的父节点设置为p
if (leftSon->right != NIL)
leftSon->right->parent = p;
leftSon->parent = grandParent;
leftSon->right = p;
// 更新祖先节点
// 如果p为根节点
if (grandParent == NIL)
root = leftSon;
// 如果p为左节点
else if (grandParent->left == p)
grandParent->left = leftSon;
// 如果p为右节点
else
grandParent->right = leftSon;
}
插入调整
// 插入调整
void insertFixup(Node *N)
{
// 一直向上调整,直到父节点不是红色,或者父节点为根节点
// 注意这里的N节点一定为红色
while (N->parent->color == Color::RED && N->parent != root)
{
// 如果父节点为左子节点
if (N->parent == N->parent->parent->left)
{
// 获取叔叔节点
Node *U = N->parent->parent->right;
// 如果叔叔节点的颜色也为红色,则将父节点和叔叔节点都变为黑色,祖先节点变为红色,继续向上调整祖先节点
if (U->color == Color::RED)
{
U->color = Color::BLACK;
N->parent->color = Color::BLACK;
N->parent->parent->color = Color::RED;
// 继续调整祖先节点
N = N->parent->parent;
}
else
{
// 调整节点与父节点不同向,需旋转为同向
if (N == N->parent->right)
{
// 旋转N的父节点
N = N->parent;
// 旋转父节点
leftRotate(N);
}
// 调整节点与父节点同向
// 注意要先变色再旋转,旋转之后会改变父子关系,到时候很混乱
// 父节点设置为黑色
N->parent->color = Color::BLACK;
// 祖先节点设置为红色
N->parent->parent->color = Color::RED;
// 旋转祖先节点
rightRotate(N->parent->parent);
}
}
// 如果父节点为右子节点
else
{
// 获取叔叔节点
Node *U = N->parent->parent->left;
// 如果叔叔节点的颜色也为红色,则将父节点和叔叔节点都变为黑色,祖先节点变为红色,继续向上调整祖先节点
if (U->color == Color::RED)
{
U->color = Color::BLACK;
N->parent->color = Color::BLACK;
N->parent->parent->color = Color::RED;
// 继续调整祖先节点
N = N->parent->parent;
}
else
{
// 调整节点与父节点不同向,需旋转为同向
if (N == N->parent->left)
{
// 旋转N的父节点
N = N->parent;
// 旋转父节点
rightRotate(N);
}
// 调整节点与父节点同向
// 注意要先变色再旋转,旋转之后会改变父子关系,到时候很混乱
// 父节点设置为红色
N->parent->color = Color::BLACK;
// 祖先节点设置为红色
N->parent->parent->color = Color::RED;
// 旋转祖先节点
leftRotate(N->parent->parent);
}
}
}
// 根节点可以无责任变成黑色
root->color = Color::BLACK;
}
插入节点
void insert(Key key, Value value)
{
Node *N = createRedNode(key, value, NIL, NIL, NIL);
// 查询节点的父节点
Node *p = NIL;
// 迭代查找临时节点
Node *temp = root;
// 树为空,直接插入
if (root == NIL)
{
N->color = BLACK;
root = N;
size++;
return;
}
while (temp != NIL)
{
p = temp;
// 往左查找
if (N->key < temp->key)
temp = temp->left;
// 往右查找
else if (N->key > temp->key)
temp = temp->right;
// key值已经存在,则替换数据
else
{
temp->value = value;
return;
}
}
size++;
N->parent = p;
// 如果key值比父节点小,则作为左子节点
if (N->key < p->key)
p->left = N;
// 如果key值比父节点大,则作为右子节点
else
p->right = N;
insertFixup(N);
}
节点替换
在删除操作中,我们会经常将一个节点替换为另外一个节点。为了方便,我们封装一个函数用于节点替换
注意在这个替换函数中,只是更新了父节点与替换节点的关系,子节点并没有更新
// 用v替换u
void replace(Node *u, Node *v)
{
// 如果u为root
if (u->parent == NIL)
root = v;
// u为左子节点
else if (u->parent->left == u)
u->parent->left = v;
// u为右子节点
else
u->parent->right = v;
v->parent = u->parent;
}
查询后继节点
在删除操作中,有些情况需要找到删除节点的后继节点,为了方便,依旧是封装一个函数来查询后继节点
后继节点为右子树中最小的一个节点
// 获取最小节点
Node *getMinNode(Node *p)
{
while (p->left != NIL)
p = p->left;
return p;
}
删除调整
// 删除调整
void removeFixup(Node *C)
{
while (C != root && C->color == BLACK)
{
// 如果C为左子节点
if (C == C->parent->left)
{
// 获取兄弟节点
Node *S = C->parent->right;
// 如果兄弟节点为红色,我们需要通过旋转将兄弟节点变为黑色
if (S->color == Color::RED)
{
// 先变色再旋转
S->color = Color::BLACK;
C->parent->color = Color::RED;
leftRotate(C->parent);
// 获取新的兄弟节点
S = C->parent->right;
}
// 兄弟节点的左儿子和右儿子都为黑色
if (S->left->color == Color::BLACK && S->right->color == Color::BLACK)
{
// 父节点为红色
if (C->parent->color == Color::RED)
{
C->parent->color = Color::BLACK;
S->color = Color::RED;
// 已经调整完毕,不需要再进行调整就将C设置为根节点
C = root;
}
// 父节点为黑色
else
{
S->color = Color::RED;
// 父节点成为双黑节点,继续调整父节点
C = C->parent;
}
}
else
{
// 近侄节点为红色,远侄子节点为黑色,需要调整为远侄节点为红色
if (S->right->color == Color::BLACK)
{
// 先变色再旋转
S->color = Color::RED;
S->left->color = Color::BLACK;
rightRotate(S);
// 由于旋转改变了父子关系,所以重新获取一下兄弟节点
S = C->parent->right;
}
// 调整后远侄节点为红色
S->color = C->parent->color;
C->parent->color = Color::BLACK;
S->right->color = Color::BLACK;
leftRotate(C->parent);
// 已经调整完毕,不需要再进行调整就将C设置为根节点
C = root;
}
}
// 如果C为右子节点
else
{
// 获取兄弟节点
Node *S = C->parent->left;
// 如果兄弟节点为红色,我们需要通过旋转将兄弟节点变为黑色
if (S->color == Color::RED)
{
// 先变色再旋转
S->color = Color::BLACK;
C->parent->color = Color::RED;
rightRotate(C->parent);
// 获取新的兄弟节点
S = C->parent->left;
}
// 兄弟节点的左儿子和右儿子都为黑色
if (S->left->color == Color::BLACK && S->right->color == Color::BLACK)
{
// 父节点为红色
if (C->parent->color == Color::RED)
{
C->parent->color = Color::BLACK;
S->color = Color::RED;
// 已经调整完毕,不需要再进行调整就将C设置为根节点
C = root;
}
// 父节点为黑色
else
{
S->color = Color::RED;
// 父节点成为双黑节点,继续调整父节点
C = C->parent;
}
}
else
{
// 近侄节点为红色,远侄子节点为黑色,需要调整为远侄节点为红色
if (S->left->color == Color::BLACK)
{
// 先变色再旋转
S->color = Color::RED;
S->right->color = Color::BLACK;
leftRotate(S);
// 由于旋转改变了父子关系,所以重新获取一下兄弟节点
S = C->parent->left;
}
// 调整后远侄节点为红色
S->color = C->parent->color;
C->parent->color = Color::BLACK;
S->left->color = Color::BLACK;
rightRotate(C->parent);
// 已经调整完毕,不需要再进行调整就将C设置为根节点
C = root;
}
}
}
// 根节点可以无责任变成黑色
root->color = Color::BLACK;
}
删除节点
注意在删除节点有两个非NIL的子节点的情况下,需要交换节点,这里为了方便是直接交换的键和值的,但是如果键和值对象比较大,那么这样效率就很慢,最好还是通过指针交换来达到节点交换的目的
void remove(Key key)
{
Node *N = root;
while (N != NIL)
{
if (N->key == key)
break;
if (key < N->key)
N = N->left;
else
N = N->right;
}
// 树中没有删除的key
if (N == NIL)
return;
// 删除节点为树中唯一节点
// Case 1
if (size == 1)
{
if (root != NIL)
destroyNode(root);
root = NIL;
size--;
return;
}
// Case 4
// 删除节点有两个非NIL的子节点
if (N->left != NIL && N->right != NIL)
{
// 获得后继节点
Node *minNode = getMinNode(N->right);
// 我们这里直接交换键值,方便,但如果键值都是比较大的对象就很慢了,最好还是交换指针
swap(minNode->key, N->key);
swap(minNode->value, N->value);
// 删除节点转换为后继节点,转移到case 2或 case 3
N = minNode;
}
// Case 3
if (N->left == NIL && N->right != NIL)
{
Node *rightSon = N->right;
rightSon->color = N->color;
// 用右子节点替换删除节点
replace(N, rightSon);
// 删除节点
destroyNode(N);
}
// Case 3
else if (N->left != NIL && N->right == NIL)
{
Node *leftSon = N->left;
leftSon->color = N->color;
// 用左子节点替换删除节点
replace(N, leftSon);
// 删除节点
destroyNode(N);
}
// Case 2
else
{
// 此情况为删除节点的两个儿子都为NIL节点
// 删除节点为红色,直接删除即可
if (N->color == Color::RED)
{
Node *parent = N->parent;
if (parent->left == N)
parent->left = NIL;
else
parent->right = NIL;
destroyNode(N);
}
// 删除节点为黑色,出现双黑节点,需要向上调整
else
{
removeFixup(N);
// 调整后删除该节点
Node *parent = N->parent;
if (parent->left == N)
parent->left = NIL;
else
parent->right = NIL;
destroyNode(N);
}
}
size--;
}
查询
查询操作也是很基本也很常用的操作,红黑树的查询操作与其他的二叉搜索树基本一样:比节点小就去左子树查,比节点大就去右子树查,和节点一样大说明查询到了
pair<bool, Value> query(Key key)
{
if (root == NIL)
return {false, Value()};
Node *temp = root;
while (temp != NIL)
{
if (key < temp->key)
temp = temp->left;
else if (key > temp->key)
temp = temp->right;
else
return {true, temp->value};
}
// 最后没有查到
return {false, Value()};
}
注意这个版本的查询返回的value与红黑树中的并不是同一个,而是一个拷贝。如果想通过返回的value操作树内的value,可以返回引用类型
pair<bool, Value&>
遍历数据
这里使用中序遍历整个红黑树,并统计红节点和黑节点个数
void print()
{
int red = 0, black = 0;
printOperation(root, red, black);
cout << "redNode num = " << red << " " << "blackNode num = " << black << endl;
}
void printOperation(Node *p, int &red, int &black)
{
if (p == NIL)
return;
printOperation(p->left, red, black);
if (p->color == Color::RED)
red++;
else
black++;
cout << "key = " << p->key << " value = " << p->value << " color = " << p->color << endl;
printOperation(p->right, red, black);
}
洛谷题目代码
下面代码与完整代码不同,只是实现了插入和查询操作
#include <iostream>
using namespace std;
#include <ctime>
#include <map>
#include <set>
#include <vector>
enum Color
{
RED,
BLACK
};
template <typename Key, typename Value>
struct RBTreeNode
{
// 按照key值进行插入删除等操作
Key key;
// value为存储的数据
Value value;
// 左节点指针
RBTreeNode<Key, Value> *left;
// 右节点指针
RBTreeNode<Key, Value> *right;
// 父节点指针
RBTreeNode<Key, Value> *parent;
// 节点颜色
Color color;
RBTreeNode(Color c, RBTreeNode<Key, Value> *l = nullptr, RBTreeNode<Key, Value> *r = nullptr, RBTreeNode<Key, Value> *p = nullptr)
{
color = c, left = l, right = r, parent = p;
}
RBTreeNode(Key k, Value v, Color c, RBTreeNode<Key, Value> *l = nullptr, RBTreeNode<Key, Value> *r = nullptr, RBTreeNode<Key, Value> *p = nullptr)
{
key = k, value = v, color = c, left = l, right = r, parent = p;
}
};
template <typename Key, typename Value>
class RBTree
{
typedef RBTreeNode<Key, Value> Node;
private:
// 根节点
Node *root;
// 哨兵节点
Node *NIL;
// 节点个数
int size;
// 创建一个空的红色节点
Node *createEmptyRedNode(Node *l = nullptr, Node *r = nullptr, Node *p = nullptr)
{
return new Node(Color::RED, l, r, p);
}
// 创建一个非空红色节点
Node *createRedNode(Key key, Value value, Node *l = nullptr, Node *r = nullptr, Node *p = nullptr)
{
return new Node(key, value, Color::RED, l, r, p);
}
// 创建一个空的黑色节点
Node *createEmptyBlackNode(Node *l = nullptr, Node *r = nullptr, Node *p = nullptr)
{
return new Node(Color::BLACK, l, r, p);
}
// 创建一个非空黑色节点
Node *createBlackNode(Key key, Value value, Node *l = nullptr, Node *r = nullptr, Node *p = nullptr)
{
return new Node(key, value, Color::BLACK, l, r, p);
}
// 销毁节点
void destroyNode(Node *node)
{
delete node;
}
// 左旋操作
void leftRotate(Node *p)
{
// 获取旋转节点的右儿子
Node *rightSon = p->right;
// 获取祖先节点
Node *grandParent = p->parent;
// 更新旋转节点
p->right = rightSon->left;
p->parent = rightSon;
// 更新右节点
// 如果右儿子的左节点不为NIL,则将右儿子的左节点的父节点设置为p
if (rightSon->left != NIL)
rightSon->left->parent = p;
rightSon->parent = grandParent;
rightSon->left = p;
// 更新祖先节点
// 如果p为根节点
if (grandParent == NIL)
root = rightSon;
// 如果p为左节点
else if (grandParent->left == p)
grandParent->left = rightSon;
// 如果p为右节点
else
grandParent->right = rightSon;
}
// 右旋操作
void rightRotate(Node *p)
{
// 获取旋转节点的左儿子
Node *leftSon = p->left;
// 获取祖先节点
Node *grandParent = p->parent;
// 更新旋转节点
p->left = leftSon->right;
p->parent = leftSon;
// 更新左节点
// 如果左儿子的右节点不为NIL,则将左儿子的右节点的父节点设置为p
if (leftSon->right != NIL)
leftSon->right->parent = p;
leftSon->parent = grandParent;
leftSon->right = p;
// 更新祖先节点
// 如果p为根节点
if (grandParent == NIL)
root = leftSon;
// 如果p为左节点
else if (grandParent->left == p)
grandParent->left = leftSon;
// 如果p为右节点
else
grandParent->right = leftSon;
}
// 插入调整
void insertFixup(Node *N)
{
// 一直向上调整,直到父节点不是红色,或者父节点为根节点
// 注意这里的N节点一定为红色
while (N->parent->color == Color::RED && N->parent != root)
{
// 如果父节点为左子节点
if (N->parent == N->parent->parent->left)
{
// 获取叔叔节点
Node *U = N->parent->parent->right;
// 如果叔叔节点的颜色也为红色,则将父节点和叔叔节点都变为黑色,祖先节点变为红色,继续向上调整祖先节点
if (U->color == Color::RED)
{
U->color = Color::BLACK;
N->parent->color = Color::BLACK;
N->parent->parent->color = Color::RED;
// 继续调整祖先节点
N = N->parent->parent;
}
else
{
// 调整节点与父节点不同向,需旋转为同向
if (N == N->parent->right)
{
// 旋转N的父节点
N = N->parent;
// 旋转父节点
leftRotate(N);
}
// 调整节点与父节点同向
// 注意要先变色再旋转,旋转之后会改变父子关系,到时候很混乱
// 父节点设置为黑色
N->parent->color = Color::BLACK;
// 祖先节点设置为红色
N->parent->parent->color = Color::RED;
// 旋转祖先节点
rightRotate(N->parent->parent);
}
}
// 如果父节点为右子节点
else
{
// 获取叔叔节点
Node *U = N->parent->parent->left;
// 如果叔叔节点的颜色也为红色,则将父节点和叔叔节点都变为黑色,祖先节点变为红色,继续向上调整祖先节点
if (U->color == Color::RED)
{
U->color = Color::BLACK;
N->parent->color = Color::BLACK;
N->parent->parent->color = Color::RED;
// 继续调整祖先节点
N = N->parent->parent;
}
else
{
// 调整节点与父节点不同向,需旋转为同向
if (N == N->parent->left)
{
// 旋转N的父节点
N = N->parent;
// 旋转父节点
rightRotate(N);
}
// 调整节点与父节点同向
// 注意要先变色再旋转,旋转之后会改变父子关系,到时候很混乱
// 父节点设置为红色
N->parent->color = Color::BLACK;
// 祖先节点设置为红色
N->parent->parent->color = Color::RED;
// 旋转祖先节点
leftRotate(N->parent->parent);
}
}
}
// 根节点可以无责任变成黑色
root->color = Color::BLACK;
}
// 用v替换u,只更换父节点关系
void replace(Node *u, Node *v)
{
// 如果u为root
if (u->parent == NIL)
root = v;
// u为左子节点
else if (u->parent->left == u)
u->parent->left = v;
// u为右子节点
else
u->parent->right = v;
v->parent = u->parent;
}
// 获取最小节点
Node *getMinNode(Node *p)
{
while (p->left != NIL)
p = p->left;
return p;
}
// 查询全部元素辅助函数
void queryAllHelp(Node *N, vector<Value> &v)
{
if (N == NIL)
return;
queryAllHelp(N->left, v);
v.push_back(N->value);
queryAllHelp(N->right, v);
}
public:
RBTree(/* args */)
{
NIL = createEmptyBlackNode();
NIL->left = NIL, NIL->right = NIL, NIL->parent = NIL;
root = NIL;
size = 0;
}
pair<bool, Value &> query(Key key)
{
Value v;
if (root == NIL)
return {false, v};
Node *temp = root;
while (temp != NIL)
{
if (key < temp->key)
temp = temp->left;
else if (key > temp->key)
temp = temp->right;
else
return {true, temp->value};
}
return {false, v};
}
void insert(Key key, Value value)
{
Node *N = createRedNode(key, value, NIL, NIL, NIL);
// 查询节点的父节点
Node *p = NIL;
// 迭代查找临时节点
Node *temp = root;
// 树为空,直接插入
if (root == NIL)
{
N->color = BLACK;
root = N;
size++;
return;
}
while (temp != NIL)
{
p = temp;
// 往左查找
if (N->key < temp->key)
temp = temp->left;
// 往右查找
else if (N->key > temp->key)
temp = temp->right;
// key值已经存在,则替换数据
else
{
temp->value = value;
return;
}
}
size++;
N->parent = p;
// 如果key值比父节点小,则作为左子节点
if (N->key < p->key)
p->left = N;
// 如果key值比父节点大,则作为右子节点
else
p->right = N;
insertFixup(N);
}
int getSize()
{
return size;
}
vector<Value> queryAll()
{
vector<Value> temp;
queryAllHelp(root, temp);
return temp;
}
~RBTree()
{
}
};
int main()
{
RBTree<string, RBTree<int, int>> tr;
int n;
cin >> n;
for (int i = 1; i <= n; i++)
{
int l;
cin >> l;
for (int j = 0; j < l; j++)
{
string s;
cin >> s;
pair<bool, RBTree<int, int> &> q = tr.query(s);
if (q.first == false)
{
RBTree<int, int> temp;
temp.insert(i, i);
tr.insert(s, temp);
}
else
q.second.insert(i, i);
}
}
int m;
cin >> m;
for (int i = 0; i < m; i++)
{
string s;
cin >> s;
pair<bool, RBTree<int, int> &> q = tr.query(s);
if (q.first == false)
cout << endl;
else
{
vector<int> ans = q.second.queryAll();
for (auto x : ans)
cout << x << " ";
cout << endl;
}
}
}
完整代码
测试情形:第一行给定一个正整数n,随后输入n个数存储在红黑树,然后输入一个正整数m,随后输入m个数表示删除某个数。最后输出树中还存在多少数,并按照从小到大进行输出
#include <iostream>
using namespace std;
#include <ctime>
#include <map>
#include <set>
#include <vector>
enum Color
{
RED,
BLACK
};
template <typename Key, typename Value>
struct RBTreeNode
{
// 按照key值进行插入删除等操作
Key key;
// value为存储的数据
Value value;
// 左节点指针
RBTreeNode<Key, Value> *left;
// 右节点指针
RBTreeNode<Key, Value> *right;
// 父节点指针
RBTreeNode<Key, Value> *parent;
// 节点颜色
Color color;
RBTreeNode(Color c, RBTreeNode<Key, Value> *l = nullptr, RBTreeNode<Key, Value> *r = nullptr, RBTreeNode<Key, Value> *p = nullptr)
{
color = c, left = l, right = r, parent = p;
}
RBTreeNode(Key k, Value v, Color c, RBTreeNode<Key, Value> *l = nullptr, RBTreeNode<Key, Value> *r = nullptr, RBTreeNode<Key, Value> *p = nullptr)
{
key = k, value = v, color = c, left = l, right = r, parent = p;
}
};
template <typename Key, typename Value>
class RBTree
{
typedef RBTreeNode<Key, Value> Node;
private:
// 根节点
Node *root;
// 哨兵节点
Node *NIL;
// 节点个数
int size;
// 创建一个空的红色节点
Node *createEmptyRedNode(Node *l = nullptr, Node *r = nullptr, Node *p = nullptr)
{
return new Node(Color::RED, l, r, p);
}
// 创建一个非空红色节点
Node *createRedNode(Key key, Value value, Node *l = nullptr, Node *r = nullptr, Node *p = nullptr)
{
return new Node(key, value, Color::RED, l, r, p);
}
// 创建一个空的黑色节点
Node *createEmptyBlackNode(Node *l = nullptr, Node *r = nullptr, Node *p = nullptr)
{
return new Node(Color::BLACK, l, r, p);
}
// 创建一个非空黑色节点
Node *createBlackNode(Key key, Value value, Node *l = nullptr, Node *r = nullptr, Node *p = nullptr)
{
return new Node(key, value, Color::BLACK, l, r, p);
}
// 销毁节点
void destroyNode(Node *node)
{
delete node;
}
// 左旋操作
void leftRotate(Node *p)
{
// 获取旋转节点的右儿子
Node *rightSon = p->right;
// 获取祖先节点
Node *grandParent = p->parent;
// 更新旋转节点
p->right = rightSon->left;
p->parent = rightSon;
// 更新右节点
// 如果右儿子的左节点不为NIL,则将右儿子的左节点的父节点设置为p
if (rightSon->left != NIL)
rightSon->left->parent = p;
rightSon->parent = grandParent;
rightSon->left = p;
// 更新祖先节点
// 如果p为根节点
if (grandParent == NIL)
root = rightSon;
// 如果p为左节点
else if (grandParent->left == p)
grandParent->left = rightSon;
// 如果p为右节点
else
grandParent->right = rightSon;
}
// 右旋操作
void rightRotate(Node *p)
{
// 获取旋转节点的左儿子
Node *leftSon = p->left;
// 获取祖先节点
Node *grandParent = p->parent;
// 更新旋转节点
p->left = leftSon->right;
p->parent = leftSon;
// 更新左节点
// 如果左儿子的右节点不为NIL,则将左儿子的右节点的父节点设置为p
if (leftSon->right != NIL)
leftSon->right->parent = p;
leftSon->parent = grandParent;
leftSon->right = p;
// 更新祖先节点
// 如果p为根节点
if (grandParent == NIL)
root = leftSon;
// 如果p为左节点
else if (grandParent->left == p)
grandParent->left = leftSon;
// 如果p为右节点
else
grandParent->right = leftSon;
}
// 插入调整
void insertFixup(Node *N)
{
// 一直向上调整,直到父节点不是红色,或者父节点为根节点
// 注意这里的N节点一定为红色
while (N->parent->color == Color::RED && N->parent != root)
{
// 如果父节点为左子节点
if (N->parent == N->parent->parent->left)
{
// 获取叔叔节点
Node *U = N->parent->parent->right;
// 如果叔叔节点的颜色也为红色,则将父节点和叔叔节点都变为黑色,祖先节点变为红色,继续向上调整祖先节点
if (U->color == Color::RED)
{
U->color = Color::BLACK;
N->parent->color = Color::BLACK;
N->parent->parent->color = Color::RED;
// 继续调整祖先节点
N = N->parent->parent;
}
else
{
// 调整节点与父节点不同向,需旋转为同向
if (N == N->parent->right)
{
// 旋转N的父节点
N = N->parent;
// 旋转父节点
leftRotate(N);
}
// 调整节点与父节点同向
// 注意要先变色再旋转,旋转之后会改变父子关系,到时候很混乱
// 父节点设置为黑色
N->parent->color = Color::BLACK;
// 祖先节点设置为红色
N->parent->parent->color = Color::RED;
// 旋转祖先节点
rightRotate(N->parent->parent);
}
}
// 如果父节点为右子节点
else
{
// 获取叔叔节点
Node *U = N->parent->parent->left;
// 如果叔叔节点的颜色也为红色,则将父节点和叔叔节点都变为黑色,祖先节点变为红色,继续向上调整祖先节点
if (U->color == Color::RED)
{
U->color = Color::BLACK;
N->parent->color = Color::BLACK;
N->parent->parent->color = Color::RED;
// 继续调整祖先节点
N = N->parent->parent;
}
else
{
// 调整节点与父节点不同向,需旋转为同向
if (N == N->parent->left)
{
// 旋转N的父节点
N = N->parent;
// 旋转父节点
rightRotate(N);
}
// 调整节点与父节点同向
// 注意要先变色再旋转,旋转之后会改变父子关系,到时候很混乱
// 父节点设置为红色
N->parent->color = Color::BLACK;
// 祖先节点设置为红色
N->parent->parent->color = Color::RED;
// 旋转祖先节点
leftRotate(N->parent->parent);
}
}
}
// 根节点可以无责任变成黑色
root->color = Color::BLACK;
}
// 删除调整
void removeFixup(Node *C)
{
while (C != root && C->color == BLACK)
{
// 如果C为左子节点
if (C == C->parent->left)
{
// 获取兄弟节点
Node *S = C->parent->right;
// 如果兄弟节点为红色,我们需要通过旋转将兄弟节点变为黑色
if (S->color == Color::RED)
{
// 先变色再旋转
S->color = Color::BLACK;
C->parent->color = Color::RED;
leftRotate(C->parent);
// 获取新的兄弟节点
S = C->parent->right;
}
// 兄弟节点的左儿子和右儿子都为黑色
if (S->left->color == Color::BLACK && S->right->color == Color::BLACK)
{
// 父节点为红色
if (C->parent->color == Color::RED)
{
C->parent->color = Color::BLACK;
S->color = Color::RED;
// 已经调整完毕,不需要再进行调整就将C设置为根节点
C = root;
}
// 父节点为黑色
else
{
S->color = Color::RED;
// 父节点成为双黑节点,继续调整父节点
C = C->parent;
}
}
else
{
// 近侄节点为红色,远侄子节点为黑色,需要调整为远侄节点为红色
if (S->right->color == Color::BLACK)
{
// 先变色再旋转
S->color = Color::RED;
S->left->color = Color::BLACK;
rightRotate(S);
// 由于旋转改变了父子关系,所以重新获取一下兄弟节点
S = C->parent->right;
}
// 调整后远侄节点为红色
S->color = C->parent->color;
C->parent->color = Color::BLACK;
S->right->color = Color::BLACK;
leftRotate(C->parent);
// 已经调整完毕,不需要再进行调整就将C设置为根节点
C = root;
}
}
// 如果C为右子节点
else
{
// 获取兄弟节点
Node *S = C->parent->left;
// 如果兄弟节点为红色,我们需要通过旋转将兄弟节点变为黑色
if (S->color == Color::RED)
{
// 先变色再旋转
S->color = Color::BLACK;
C->parent->color = Color::RED;
rightRotate(C->parent);
// 获取新的兄弟节点
S = C->parent->left;
}
// 兄弟节点的左儿子和右儿子都为黑色
if (S->left->color == Color::BLACK && S->right->color == Color::BLACK)
{
// 父节点为红色
if (C->parent->color == Color::RED)
{
C->parent->color = Color::BLACK;
S->color = Color::RED;
// 已经调整完毕,不需要再进行调整就将C设置为根节点
C = root;
}
// 父节点为黑色
else
{
S->color = Color::RED;
// 父节点成为双黑节点,继续调整父节点
C = C->parent;
}
}
else
{
// 近侄节点为红色,远侄子节点为黑色,需要调整为远侄节点为红色
if (S->left->color == Color::BLACK)
{
// 先变色再旋转
S->color = Color::RED;
S->right->color = Color::BLACK;
leftRotate(S);
// 由于旋转改变了父子关系,所以重新获取一下兄弟节点
S = C->parent->left;
}
// 调整后远侄节点为红色
S->color = C->parent->color;
C->parent->color = Color::BLACK;
S->left->color = Color::BLACK;
rightRotate(C->parent);
// 已经调整完毕,不需要再进行调整就将C设置为根节点
C = root;
}
}
}
// 根节点可以无责任变成黑色
root->color = Color::BLACK;
}
// 用v替换u,只更换父节点关系
void replace(Node *u, Node *v)
{
// 如果u为root
if (u->parent == NIL)
root = v;
// u为左子节点
else if (u->parent->left == u)
u->parent->left = v;
// u为右子节点
else
u->parent->right = v;
v->parent = u->parent;
}
// 获取最小节点
Node *getMinNode(Node *p)
{
while (p->left != NIL)
p = p->left;
return p;
}
// 打印辅助函数
void printHelp(Node *p, int &red, int &black)
{
if (p == NIL)
return;
cout << "key = " << p->key << " value = " << p->value << " color = " << p->color << endl;
printHelp(p->left, red, black);
if (p->color == Color::RED)
red++;
else
black++;
printHelp(p->right, red, black);
}
// 查询全部元素辅助函数
void queryAllHelp(Node *N, vector<Value> &v)
{
if (N == NIL)
return;
queryAllHelp(N->left, v);
v.push_back(N->value);
queryAllHelp(N->right, v);
}
int checkBlackHeightHelp(Node *N, bool &flag)
{
if (N == NIL)
return 1;
int left = checkBlackHeightHelp(N->left, flag);
int right = checkBlackHeightHelp(N->right, flag);
if (left != right)
flag = false;
return left + (N->color == Color::BLACK ? 1 : 0);
}
public:
RBTree(/* args */)
{
NIL = createEmptyBlackNode();
NIL->left = NIL, NIL->right = NIL, NIL->parent = NIL;
root = NIL;
size = 0;
}
pair<bool, Value> query(Key key)
{
if (root == NIL)
return {false, Value()};
Node *temp = root;
while (temp != NIL)
{
if (key < temp->key)
temp = temp->left;
else if (key > temp->key)
temp = temp->right;
else
return {true, temp->value};
}
return {false, Value()};
}
void insert(Key key, Value value)
{
Node *N = createRedNode(key, value, NIL, NIL, NIL);
// 查询节点的父节点
Node *p = NIL;
// 迭代查找临时节点
Node *temp = root;
// 树为空,直接插入
if (root == NIL)
{
N->color = BLACK;
root = N;
size++;
return;
}
while (temp != NIL)
{
p = temp;
// 往左查找
if (N->key < temp->key)
temp = temp->left;
// 往右查找
else if (N->key > temp->key)
temp = temp->right;
// key值已经存在,则替换数据
else
{
temp->value = value;
return;
}
}
size++;
N->parent = p;
// 如果key值比父节点小,则作为左子节点
if (N->key < p->key)
p->left = N;
// 如果key值比父节点大,则作为右子节点
else
p->right = N;
insertFixup(N);
}
void remove(Key key)
{
Node *N = root;
while (N != NIL)
{
if (N->key == key)
break;
if (key < N->key)
N = N->left;
else
N = N->right;
}
// 树中没有删除的key
if (N == NIL)
return;
// 删除节点为树中唯一节点
// Case 1
if (size == 1)
{
if (root != NIL)
destroyNode(root);
root = NIL;
size--;
return;
}
// Case 4
// 删除节点有两个非NIL的子节点
if (N->left != NIL && N->right != NIL)
{
// 获得后继节点
Node *minNode = getMinNode(N->right);
// 我们这里直接交换键值,方便,但如果键值都是比较大的对象就很慢了,最好还是交换指针
swap(minNode->key, N->key);
swap(minNode->value, N->value);
// 删除节点转换为后继节点,转移到case 2或 case 3
N = minNode;
}
// Case 3
if (N->left == NIL && N->right != NIL)
{
Node *rightSon = N->right;
rightSon->color = N->color;
// 用右子节点替换删除节点
replace(N, rightSon);
// 删除节点
destroyNode(N);
}
// Case 3
else if (N->left != NIL && N->right == NIL)
{
Node *leftSon = N->left;
leftSon->color = N->color;
// 用左子节点替换删除节点
replace(N, leftSon);
// 删除节点
destroyNode(N);
}
// Case 2
else
{
// 此情况为删除节点的两个儿子都为NIL节点
// 删除节点为红色,直接删除即可
if (N->color == Color::RED)
{
Node *parent = N->parent;
if (parent->left == N)
parent->left = NIL;
else
parent->right = NIL;
destroyNode(N);
}
// 删除节点为黑色,出现双黑节点,需要向上调整
else
{
removeFixup(N);
// 调整后删除该节点
Node *parent = N->parent;
if (parent->left == N)
parent->left = NIL;
else
parent->right = NIL;
destroyNode(N);
}
}
size--;
}
int getSize()
{
return size;
}
void print()
{
int red = 0, black = 0;
printHelp(root, red, black);
cout << "redNode num = " << red << " " << "blackNode num = " << black << endl;
}
vector<Value> queryAll()
{
vector<Value> temp;
queryAllHelp(root, temp);
return temp;
}
void checkBlackHeight()
{
bool flag = true;
checkBlackHeightHelp(root, flag);
if (flag)
cout << "right!" << endl;
else
cout << "error!" << endl;
}
~RBTree()
{
}
};
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
RBTree<int, int> tr;
int n, m, x;
cin >> n;
for (int i = 1; i <= n; i++)
{
cin >> x;
tr.insert(x, x);
}
// cout << "check black height after insert: ";
// tr.checkBlackHeight();
cin >> m;
for (int i = 1; i <= m; i++)
{
cin >> x;
tr.remove(x);
}
// cout << "check black height after remove: ";
// tr.checkBlackHeight();
vector<int> ans = tr.queryAll();
cout << ans.size() << endl;
for (auto x : ans)
cout << x << endl;
}
感想
红黑树很复杂,特别是删除操作,要考虑很多情况,这篇文章也写了有几天,在网上也找了很多资料,终归是搞出来了,也是见识到了红黑树的”厉害“
水平有限,测试的情况比较少,代码不保证完全正确,如果有问题欢迎指正