红黑树是每个节点都带有颜色属性的二叉查找树，颜色为 红色 或 黑色。在二叉查找树强制一般要求以外，对于任何有效的红黑树我们增加了如下的额外要求：
- 节点是红色或黑色。
- 根是黑色。
- 所有叶子都是黑色（叶子是NIL节点）。
- 每个红色节点必须有两个黑色的子节点。（从每个叶子到根的所有路径上不能有两个连续的红色节点。）
- 从任一节点到其每个叶子的所有简单路径都包含相同数目的黑色节点。
下面是一个具体的红黑树的图例：
旋转
旋转是一种能保持二叉搜索树性质的搜索树局部操作。其中两种旋转分别为左旋和右旋：
在某个结点 x 上进行左旋时，假设它的右孩子为y而不是树的 T.nil 结点；x为其右孩子而不是 T.nil 结点的树内任意节点。
左旋以 x 到 y 的链为“支轴”进行，使得 y 成为该子树的新的根节点，x 成为 y 的左孩子，y 的左孩子变成 x 的右孩子；右旋与此相反。
左旋代码：
1 /**
2 * 左旋
3 * 左旋示意图（对节点x进行左旋）：
4 * px px
5 * / /
6 * x y
7 * / \ --(左旋)--> / \
8 * lx y x ry
9 * / \ / \
10 * ly ry lx ly
11 *
12 * @param x
13 */
14 private void leftRotate(RBTNode<T> x) {
15 RBTNode<T> y = x.right; // y是x的右节点
16
17 x.right = y.left; // 把x的左节点变为y的右节点
18 // 若y有左子节点，把y的左节点的父节点换成x
19 if (y.left != null) {
20 y.left.parent = x;
21 }
22
23 y.parent = x.parent; // y的父节点（原来是x）设为x的父节点
24
25 // 若x是根节点，y直接变根节点
26 if (x.parent == null) {
27 this.mRoot = y;
28 } else {
29 if (x.parent.left == x) {
30 x.parent.left = y; // 如果x是x父节点的左孩子，把x的父节点的左孩子指向y
31 } else {
32 x.parent.right = y; // 如果x是x父节点的右孩子，把x的父节点的右孩子指向y
33 }
34 }
35
36 y.left = x; // 将y的左节点指向x
37 x.parent = y; // 将x的父节点设为y
38 }右旋代码：
1 /**
2 * 右旋，操作和左旋相反
3 * 右旋示意图（对节点y进行左旋）：
4 * py py
5 * / /
6 * y x
7 * / \ --(右旋)--> / \
8 * x ry lx y
9 * / \ / \
10 * lx rx rx ry
11 *
12 * @param y
13 */
14 private void rightRotate(RBTNode<T> y) {
15 RBTNode<T> x = y.left; // y的左孩子
16
17 y.left = x.right;
18 if (x.right != null) {
19 x.right.parent = y;
20 }
21
22 x.parent = y.parent;
23
24 if (y.parent == null) {
25 this.mRoot = x;
26 } else {
27 if (y.parent.left == y) {
28 y.parent.left = x;
29 } else {
30 y.parent.right = x;
31 }
32 }
33
34 x.right = y;
35 y.parent = x;
36 }红黑树新结点插入代码：
就像一个普通的二叉搜索树一样，将新结点插入树中，并将其着为红色。之后为了能保证红黑的性质，还需要一个辅助代码对结点重新着色并且旋转。
1 /**
2 * 插入操作
3 *
4 * @param node
5 */
6 private void insert(RBTNode<T> node) {
7 int result;
8 RBTNode<T> y = null;
9 RBTNode<T> x = this.mRoot;
10
11 // 查找树中插入点的父结点y的位置
12 while (x != null) {
13 y = x; // 注意这里，y不是空的
14 result = node.key.compareTo(x.key);
15 if (result < 0) {
16 x = x.left;
17 } else {
18 x = x.right;
19 }
20 }
21
22 node.parent = y;
23 if (y != null) {
24 result = node.key.compareTo(y.key);
25 if (result < 0) {
26 y.left = node;
27 } else {
28 y.right = node;
29 }
30 } else {
31 this.mRoot = node;
32 }
33
34 node.color = RED;
35
36 // 插入后修正树
37 insertFixUp(node);
38 }辅助修正函数：
1 /**
2 * 红黑树插入修正函数
3 *
4 * @param node
5 */
6 private void insertFixUp(RBTNode<T> node) {
7 RBTNode<T> parent, gparent; // 父节点，祖父节点
8
9 while (((parent = parentOf(node)) != null) && isRed(parent)) {
10 gparent = parentOf(parent);
11
12 // 父节点是祖父节点的左孩子
13 if (parent == gparent.left) {
14 RBTNode<T> uncle = gparent.right; // 叔叔节点，祖父的右节点
15
16 // ① 叔叔节点是红色的
17 if ((uncle != null) && isRed(uncle)) {
18 node.setColor(BLACK);
19 parent.setColor(BLACK);
20 gparent.setColor(RED);
21 node = gparent;
22 continue;
23 }
24
25 // ② 叔叔是黑色，且当前节点是右孩子
26 if (parent.right == node) {
27 RBTNode<T> tmp;
28 leftRotate(parent);
29 tmp = parent;
30 parent = node;
31 node = tmp;
32 }
33
34 // ③ 叔叔是黑色，且当前节点是左孩子
35 parent.setColor(BLACK);
36 gparent.setColor(RED);
37 rightRotate(gparent);
38
39 } else { // 父节点是祖父节点的右孩子
40
41 RBTNode<T> uncle = gparent.left; // 叔叔节点，祖父的左节点
42
43 // ① 叔叔节点是红色的
44 if ((uncle != null) && isRed(uncle)) {
45 uncle.setColor(BLACK);
46 parent.setColor(BLACK);
47 gparent.setColor(RED);
48 node = gparent;
49 continue;
50 }
51
52 // ② 叔叔是黑色，且当前节点是左孩子
53 if (parent.left == node) {
54 RBTNode<T> tmp;
55 rightRotate(parent);
56 tmp = parent;
57 parent = node;
58 node = tmp;
59 }
60
61 // ③ 叔叔是黑色，且当前节点是右孩子
62 parent.setColor(BLACK);
63 gparent.setColor(RED);
64 leftRotate(gparent);
65 }
66 }
67
68 this.mRoot.setColor(BLACK);
69 }修正过程实例：
以下图中的 z 为插入后的结点，y 表示叔结点uncle，图中的每个子树的低端的节点是红黑树代码中的边界，边界中每个节点有黑色的哨兵没有画出来。
下面是介绍的是上面代码中 父节点是祖父节点的左孩子 的代码。
先看图中的第一个树，插入的 z 结点和 z.parent 父节点都是 RED，这违反了性质四。
情况 1（得到的是图中的第二个树）：由于图中的第一个树中叔结点是红色，z 结点和 z.parent 父节点都是 RED，结点都要被重新着色，并沿着指针 z 上升；
情况 2（得到的是图中的第三个树）：由于图中的第二个树中 z 及其父节点 z.parent 都为红色，其叔结点为黑色，左旋父节点 z.parent后得到；
情况 3（得到的是图中的第四个树）：z 是其父节点的左孩子，重新着色后右旋的到图中的第四个树，这样之后就是合法的红黑树了。
分析红黑树的插入时间复杂度：
一颗具有 n 个节点的红黑树高度为O(log n)，则按照一个普通的二叉查找树的方式插入结点需要花费 O(log n)；修正代码中，当情况 1发生，指针 z沿着树上升2层，才会执行 while 循环，while 循环可能执行的总次数为 O(log n)。所以红黑树的插入的总的时间复杂度为 O(log n)。此外，插入算法中总的来说旋转次数不超过 2 次。
红黑树的删除：
1 /**
2 * 删除树中某个节点
3 *
4 * @param node 要删除的结点
5 */
6 private void remove(RBTNode<T> node) {
7 RBTNode<T> child, parent;
8 boolean color;
9
10 // 要删除的结点node有2个子结点
11 if ((node.left != null) && (node.right != null)) {
12 RBTNode<T> replace = node;
13
14 // 寻找后继结点
15 replace = replace.right;
16 while (replace.left != null) {
17 replace = replace.left;
18 }
19
20 // 判断删除的结点是不是根结点
21 if (parentOf(node) != null) {
22 if (parentOf(node).left == node) {
23 parentOf(node).left = replace;
24 } else {
25 parentOf(node).right = replace;
26 }
27 } else {
28 this.mRoot = replace;
29 }
30
31
32 child = replace.right; // 后继结点的右孩子？左孩子呢？左孩子有早就是后继结点了，所以直接看后继结点还有没有右孩子
33 parent = parentOf(replace); // 后继结点的父结点
34 color = replace.color; // 后继结点的颜色
35
36 // 要删除的结点node是后继结点的父结点
37 if (parent == node) {
38 parent = replace; // 这里应该后继结点直接替换node，留下后继结点的右子树
39 } else { // 后继结点的父结点不是要删除的结点node
40 // 后继结点的孩子不为空
41 if (child != null)
42 child.setParent(parent); // 把<后继结点的右孩子>的<父结点>设为<后继结点的父结点>
43 parent.left = child; // <后继结点的父结点>的<左孩子>指向<后继结点的右孩子>
44
45 replace.right = node.right; // 后继结点的右孩子指向删除结点的右子树
46 node.right.setParent(replace); //删除结点的右子树的父结点设置为后继结点
47 }
48
49 replace.parent = node.parent;
50 replace.color = node.color;
51 replace.left = node.left;
52 node.left.parent = replace;
53
54 if (color == BLACK)
55 removeFixup(child, parent);
56
57 node = null;
58
59 return;
60 }
61
62 // 选一个要删除的结点的孩子
63 if (node.left != null) {
64 child = node.left;
65 } else {
66 child = node.right;
67 }
68
69 parent = node.parent;
70 color = node.color;
71
72 // 要删除的结点的孩子不为空
73 if (child != null)
74 child.parent = parent;
75
76 // 要删除的结点的父结点是不是树根
77 if (parent != null) {
78 if (parent.left == node) {
79 parent.left = child;
80 } else {
81 parent.right = child;
82 }
83 } else {
84 this.mRoot = child;
85 }
86
87 if (color == BLACK)
88 removeFixup(child, parent);
89
90 node = null;
91 }
删除修正函数：
1 /**
2 * 删除修正函数
3 *
4 * @param x
5 * @param parent
6 */
7 private void removeFixup(RBTNode<T> x, RBTNode<T> parent) {
8 RBTNode<T> w;
9
10 while ((x == null || isBlack(x)) && (x != this.mRoot)) {
11 if (parent.left == x) {
12 w = parent.right;
13
14 // ① x的兄弟结点w是红色的
15 if (isRed(w)) {
16 w.setColor(BLACK); // w染黑
17 parent.setColor(RED);
18 leftRotate(parent);
19 w = parent.right;
20 }
21
22 // ② x的兄弟结点w是黑色的，而且w的两个孩子结点都是黑色的
23 if ((w.left == null || isBlack(w.left)) &&
24 (w.right == null || isBlack(w.right))) {
25 w.setColor(RED);
26 x = parent;
27 parent = parentOf(x);
28
29 } else {
30
31 // ③ x的兄弟结点w是黑色的，w的右孩子是黑色的，w的左孩子是红色的
32 if ((w.right == null || isBlack(w.right)) &&
33 (w.left == null || isBlack(w.left))) {
34 w.left.setColor(BLACK);
35 w.setColor(RED);
36 rightRotate(w);
37 w = parent.right;
38 }
39
40 // ④ x的兄弟结点w是黑色的，w的右孩子是红色的
41 w.setColor(parent.color);
42 parent.setColor(BLACK);
43 w.right.setColor(BLACK);
44 leftRotate(parent);
45 x = this.mRoot;
46
47 break;
48 }
49
50 } else {
51
52 w = parent.left;
53 // ① x的兄弟结点w是红色的
54 if (isRed(w)) {
55 w.setColor(BLACK);
56 parent.setColor(RED);
57 rightRotate(parent);
58 w = parent.left;
59 }
60
61 // ② x的兄弟结点w是黑色的，而且w的两个孩子结点都是黑色的
62 if ((w.left == null || isBlack(w.left)) &&
63 (w.right == null || isBlack(w.right))) {
64 w.setColor(RED);
65 x = parent;
66 parent = parentOf(x);
67 } else {
68
69 // ③ x的兄弟结点w是黑色的，w的右孩子是黑色的，w的左孩子是红色的
70 if (w.left == null || isBlack(w.left)) {
71 w.right.setColor(BLACK);
72 w.setColor(RED);
73 leftRotate(w);
74 w = parent.left;
75 }
76
77 // ④ x的兄弟结点w是黑色的，w的右孩子是红色的
78 w.setColor(parent.color);
79 parent.setColor(BLACK);
80 w.left.setColor(BLACK);
81 rightRotate(parent);
82 x = this.mRoot;
83
84 break;
85 }
86 }
87 }
88
89 if (x != null)
90 x.setColor(BLACK);
91 }
红黑树总的代码（包含测试代码）：
1 package tree;
2
3 /**
4 * @program: MyPractice
5 * @description: 红黑树
6 * @author: Mr.Wu
7 * @create: 2019-08-28 17:19
8 **/
9 public class RBTree<T extends Comparable<T>> {
10 // 根节点
11 private RBTNode<T> mRoot;
12
13 private static final boolean RED = false;
14 private static final boolean BLACK = true;
15
16 private static final int a[] = {10, 40, 30, 60, 90, 70, 20, 50, 80};
17 private static final boolean mDebugInsert = false;
18 private static final boolean mDebugDelete = true;
19
20 /**
21 * 左旋
22 * 左旋示意图（对节点x进行左旋）：
23 * px px
24 * / /
25 * x y
26 * / \ --(左旋)--> / \
27 * lx y x ry
28 * / \ / \
29 * ly ry lx ly
30 *
31 * @param x
32 */
33 private void leftRotate(RBTNode<T> x) {
34 RBTNode<T> y = x.right; // y是x的右节点
35
36 x.right = y.left; // 把y的左节点变为x的右节点
37 // 若y有左子节点，把y的左节点的父节点换成x
38 if (y.left != null) {
39 y.left.parent = x;
40 }
41
42 y.parent = x.parent; // y的父节点（原来是x）设为x的父节点
43
44 // 若x是根节点，y直接变根节点
45 if (x.parent == null) {
46 this.mRoot = y;
47 } else {
48 if (x.parent.left == x) {
49 x.parent.left = y; // 如果x是x父节点的左孩子，把x的父节点的左孩子指向y
50 } else {
51 x.parent.right = y; // 如果x是x父节点的右孩子，把x的父节点的右孩子指向y
52 }
53 }
54
55 y.left = x; // 将y的左节点指向x
56 x.parent = y; // 将x的父节点设为y
57 }
58
59 /**
60 * 右旋，操作和左旋相反
61 * 右旋示意图（对节点y进行左旋）：
62 * py py
63 * / /
64 * y x
65 * / \ --(右旋)--> / \
66 * x ry lx y
67 * / \ / \
68 * lx rx rx ry
69 *
70 * @param y
71 */
72 private void rightRotate(RBTNode<T> y) {
73 RBTNode<T> x = y.left; // y的左孩子
74
75 y.left = x.right;
76 if (x.right != null) {
77 x.right.parent = y;
78 }
79
80 x.parent = y.parent;
81
82 if (y.parent == null) {
83 this.mRoot = x;
84 } else {
85 if (y.parent.left == y) {
86 y.parent.left = x;
87 } else {
88 y.parent.right = x;
89 }
90 }
91
92 x.right = y;
93 y.parent = x;
94 }
95
96 /**
97 * 插入结点
98 *
99 * @param key
100 */
101 public void insert(T key) {
102 RBTNode<T> node = new RBTNode<>(BLACK, key, null, null, null);
103 if (node != null) {
104 insert(node);
105 }
106 }
107
108 /**
109 * 插入操作
110 *
111 * @param node
112 */
113 private void insert(RBTNode<T> node) {
114 int result;
115 RBTNode<T> y = null;
116 RBTNode<T> x = this.mRoot;
117
118 // 查找树中插入点的父结点y的位置
119 while (x != null) {
120 y = x; // 注意这里，y不是空的
121 result = node.key.compareTo(x.key);
122 if (result < 0) {
123 x = x.left;
124 } else {
125 x = x.right;
126 }
127 }
128
129 node.parent = y;
130 if (y != null) {
131 result = node.key.compareTo(y.key);
132 if (result < 0) {
133 y.left = node;
134 } else {
135 y.right = node;
136 }
137 } else {
138 this.mRoot = node;
139 }
140
141 node.color = RED;
142
143 // 插入后修正树
144 insertFixUp(node);
145 }
146
147 /**
148 * 红黑树插入修正函数
149 *
150 * @param node
151 */
152 private void insertFixUp(RBTNode<T> node) {
153 RBTNode<T> parent, gparent; // 父节点 与 祖父节点
154
155 while (((parent = parentOf(node)) != null) && isRed(parent)) {
156 gparent = parentOf(parent);
157
158 // 父节点是祖父节点的左孩子
159 if (parent == gparent.left) {
160 RBTNode<T> uncle = gparent.right; // 叔叔节点，祖父的右节点
161
162 // ① 叔叔节点是红色的
163 if ((uncle != null) && isRed(uncle)) {
164 node.setColor(BLACK);
165 parent.setColor(BLACK);
166 gparent.setColor(RED);
167 node = gparent;
168 continue;
169 }
170
171 // ② 叔叔是黑色，且当前节点是右孩子
172 if (parent.right == node) {
173 RBTNode<T> tmp;
174 leftRotate(parent);
175 tmp = parent;
176 parent = node;
177 node = tmp;
178 }
179
180 // ③ 叔叔是黑色，且当前节点是左孩子
181 parent.setColor(BLACK);
182 gparent.setColor(RED);
183 rightRotate(gparent);
184
185 } else { // 父节点是祖父节点的右孩子
186
187 RBTNode<T> uncle = gparent.left; // 叔叔节点，祖父的左节点
188
189 // ① 叔叔节点是红色的
190 if ((uncle != null) && isRed(uncle)) {
191 uncle.setColor(BLACK);
192 parent.setColor(BLACK);
193 gparent.setColor(RED);
194 node = gparent;
195 continue;
196 }
197
198 // ② 叔叔是黑色，且当前节点是左孩子
199 if (parent.left == node) {
200 RBTNode<T> tmp;
201 rightRotate(parent);
202 tmp = parent;
203 parent = node;
204 node = tmp;
205 }
206
207 // ③ 叔叔是黑色，且当前节点是右孩子
208 parent.setColor(BLACK);
209 gparent.setColor(RED);
210 leftRotate(gparent);
211 }
212 }
213
214 this.mRoot.setColor(BLACK);
215 }
216
217 /**
218 * 删除树中某个值
219 *
220 * @param key
221 */
222 public void remove(T key) {
223 RBTNode<T> node;
224
225 if ((node = search(mRoot, key)) != null)
226 remove(node);
227 }
228
229 /**
230 * 删除树中某个节点
231 *
232 * @param node 要删除的结点
233 */
234 private void remove(RBTNode<T> node) {
235 RBTNode<T> child, parent;
236 boolean color;
237
238 // 要删除的结点node有2个子结点
239 if ((node.left != null) && (node.right != null)) {
240 RBTNode<T> replace = node;
241
242 // 寻找后继结点
243 replace = replace.right;
244 while (replace.left != null) {
245 replace = replace.left;
246 }
247
248 // 判断删除的结点是不是根结点
249 if (parentOf(node) != null) {
250 if (parentOf(node).left == node) {
251 parentOf(node).left = replace;
252 } else {
253 parentOf(node).right = replace;
254 }
255 } else {
256 this.mRoot = replace;
257 }
258
259
260 child = replace.right; // 后继结点的右孩子？左孩子呢？左孩子有早就是后继结点了，所以直接看后继结点还有没有右孩子
261 parent = parentOf(replace); // 后继结点的父结点
262 color = replace.color; // 后继结点的颜色
263
264 // 要删除的结点node是后继结点的父结点
265 if (parent == node) {
266 parent = replace; // 这里应该后继结点直接替换node，留下后继结点的右子树
267 } else { // 后继结点的父结点不是要删除的结点node
268 // 后继结点的孩子不为空
269 if (child != null)
270 child.setParent(parent); // 把<后继结点的右孩子>的<父结点>设为<后继结点的父结点>
271 parent.left = child; // <后继结点的父结点>的<左孩子>指向<后继结点的右孩子>
272
273 replace.right = node.right; // 后继结点的右孩子指向删除结点的右子树
274 node.right.setParent(replace); //删除结点的右子树的父结点设置为后继结点
275 }
276
277 replace.parent = node.parent;
278 replace.color = node.color;
279 replace.left = node.left;
280 node.left.parent = replace;
281
282 if (color == BLACK)
283 removeFixup(child, parent);
284
285 node = null;
286
287 return;
288 }
289
290 // 选一个要删除的结点的孩子
291 if (node.left != null) {
292 child = node.left;
293 } else {
294 child = node.right;
295 }
296
297 parent = node.parent;
298 color = node.color;
299
300 // 要删除的结点的孩子不为空
301 if (child != null)
302 child.parent = parent;
303
304 // 要删除的结点的父结点是不是树根
305 if (parent != null) {
306 if (parent.left == node) {
307 parent.left = child;
308 } else {
309 parent.right = child;
310 }
311 } else {
312 this.mRoot = child;
313 }
314
315 if (color == BLACK)
316 removeFixup(child, parent);
317
318 node = null;
319 }
320
321 /**
322 * 删除修正函数
323 *
324 * @param x
325 * @param parent
326 */
327 private void removeFixup(RBTNode<T> x, RBTNode<T> parent) {
328 RBTNode<T> w;
329
330 while ((x == null || isBlack(x)) && (x != this.mRoot)) {
331 if (parent.left == x) {
332 w = parent.right;
333
334 // ① x的兄弟结点w是红色的
335 if (isRed(w)) {
336 w.setColor(BLACK); // w染黑
337 parent.setColor(RED);
338 leftRotate(parent);
339 w = parent.right;
340 }
341
342 // ② x的兄弟结点w是黑色的，而且w的两个孩子结点都是黑色的
343 if ((w.left == null || isBlack(w.left)) &&
344 (w.right == null || isBlack(w.right))) {
345 w.setColor(RED);
346 x = parent;
347 parent = parentOf(x);
348
349 } else {
350
351 // ③ x的兄弟结点w是黑色的，w的右孩子是黑色的，w的左孩子是红色的
352 if ((w.right == null || isBlack(w.right)) &&
353 (w.left == null || isBlack(w.left))) {
354 w.left.setColor(BLACK);
355 w.setColor(RED);
356 rightRotate(w);
357 w = parent.right;
358 }
359
360 // ④ x的兄弟结点w是黑色的，w的右孩子是红色的
361 w.setColor(parent.color);
362 parent.setColor(BLACK);
363 w.right.setColor(BLACK);
364 leftRotate(parent);
365 x = this.mRoot;
366
367 break;
368 }
369
370 } else {
371
372 w = parent.left;
373 // ① x的兄弟结点w是红色的
374 if (isRed(w)) {
375 w.setColor(BLACK);
376 parent.setColor(RED);
377 rightRotate(parent);
378 w = parent.left;
379 }
380
381 // ② x的兄弟结点w是黑色的，而且w的两个孩子结点都是黑色的
382 if ((w.left == null || isBlack(w.left)) &&
383 (w.right == null || isBlack(w.right))) {
384 w.setColor(RED);
385 x = parent;
386 parent = parentOf(x);
387 } else {
388
389 // ③ x的兄弟结点w是黑色的，w的右孩子是黑色的，w的左孩子是红色的
390 if (w.left == null || isBlack(w.left)) {
391 w.right.setColor(BLACK);
392 w.setColor(RED);
393 leftRotate(w);
394 w = parent.left;
395 }
396
397 // ④ x的兄弟结点w是黑色的，w的右孩子是红色的
398 w.setColor(parent.color);
399 parent.setColor(BLACK);
400 w.left.setColor(BLACK);
401 rightRotate(parent);
402 x = this.mRoot;
403
404 break;
405 }
406 }
407 }
408
409 if (x != null)
410 x.setColor(BLACK);
411 }
412
413 private boolean isRed(RBTNode<T> node) {
414 return (node != null) && (node.color == RED);
415 }
416
417 private boolean isBlack(RBTNode<T> node) {
418 return !isRed(node);
419 }
420
421 /**
422 * 二叉查找，递归
423 *
424 * @param x
425 * @param key
426 * @return
427 */
428 private RBTNode<T> search(RBTNode<T> x, T key) {
429 if (x == null)
430 return x;
431
432 int result = key.compareTo(x.key);
433 if (result < 0) {
434 return search(x.left, key);
435 } else if (result > 0) {
436 return search(x.right, key);
437 } else {
438 return x;
439 }
440 }
441
442 /**
443 * 找结点的父节点
444 *
445 * @param node
446 * @return
447 */
448 private RBTNode<T> parentOf(RBTNode<T> node) {
449 return (node != null) ? node.parent : null;
450 }
451
452 /**
453 * 置空树
454 */
455 public void clear() {
456 destroy(mRoot);
457 mRoot = null;
458 }
459
460 /**
461 * 销毁树
462 *
463 * @param tree
464 */
465 private void destroy(RBTNode<T> tree) {
466 if (tree == null) {
467 return;
468 }
469 if (tree.left != null) {
470 destroy(tree.left);
471 }
472 if (tree.right != null) {
473 destroy(tree.right);
474 }
475
476 tree = null;
477 }
478
479 /**
480 * 先序遍历
481 */
482 public void preOrder() {
483 preOrder(mRoot);
484 }
485
486 /**
487 * 先序遍历
488 *
489 * @param tree
490 */
491 private void preOrder(RBTNode<T> tree) {
492 if (tree != null) {
493 System.out.print(tree.key + " ");
494 preOrder(tree.left);
495 preOrder(tree.right);
496 }
497 }
498
499 public void inOrder() {
500 inOrder(mRoot);
501 }
502
503 /**
504 * 中序遍历
505 *
506 * @param tree
507 */
508 private void inOrder(RBTNode<T> tree) {
509 if (tree != null) {
510 inOrder(tree.left);
511 System.out.print(tree.key + " ");
512 inOrder(tree.right);
513 }
514 }
515
516 /**
517 * 后序遍历
518 */
519 public void postOrder() {
520 postOrder(mRoot);
521 }
522
523 /**
524 * 后序遍历
525 *
526 * @param tree
527 */
528 private void postOrder(RBTNode<T> tree) {
529 if (tree != null) {
530 postOrder(tree.left);
531 postOrder(tree.right);
532 System.out.print(tree.key + " ");
533 }
534 }
535
536 /**
537 * 打印树的信息
538 */
539 public void print() {
540 if (mRoot != null) {
541 print(mRoot, mRoot.key, 0);
542 }
543 }
544
545 /**
546 * 打印树的详细信息
547 *
548 * @param tree
549 * @param key
550 * @param direction
551 */
552 private void print(RBTNode<T> tree, T key, int direction) {
553 if (tree != null) {
554 if (direction == 0) {
555 System.out.printf("%2d(B) is root\n", tree.key);
556 } else {
557 System.out.printf("%2d(%s) is %2d's %6s child\n", tree.key, isRed(tree) ? "R" : "B",
558 key, direction == 1 ? "right" : "left");
559 }
560 print(tree.left, tree.key, -1);
561 print(tree.right, tree.key, 1);
562 }
563 }
564
565 /**
566 * 找树中值最大的结点
567 *
568 * @param tree
569 * @return
570 */
571 private RBTNode<T> maximum(RBTNode<T> tree) {
572 if (tree == null)
573 return null;
574 while (tree.right != null)
575 tree = tree.right;
576 return null;
577 }
578
579 /**
580 * 找树中值最大的结点
581 *
582 * @return
583 */
584 public T maximum() {
585 RBTNode<T> p = maximum(mRoot);
586 if (p != null)
587 return p.key;
588 return null;
589 }
590
591 /**
592 * 找树中值最小的结点
593 *
594 * @param tree
595 * @return
596 */
597 private RBTNode<T> minimum(RBTNode<T> tree) {
598 if (tree == null)
599 return null;
600 while (tree.left != null)
601 tree = tree.left;
602 return tree;
603 }
604
605 /**
606 * 找树中值最小的结点
607 */
608 public T minimum() {
609 RBTNode<T> p = minimum(mRoot);
610 if (p != null)
611 return p.key;
612 return null;
613 }
614
615 /**
616 * 测试主函数
617 * @param args
618 */
619 public static void main(String[] args) {
620 int i, length = a.length;
621 RBTree<Integer> tree = new RBTree<>();
622
623 System.out.printf("== 原始数据: ");
624 for (i = 0; i < length; i++)
625 System.out.printf("%d ", a[i]);
626 System.out.printf("\n");
627
628 for (i = 0; i < length; i++) {
629 tree.insert(a[i]);
630 // 设置mDebugInsert=true,测试"添加函数"
631 if (mDebugInsert) {
632 System.out.printf("== 添加节点: %d\n", a[i]);
633 System.out.printf("== 树的详细信息: \n");
634 tree.print();
635 System.out.printf("\n");
636 }
637 }
638
639 System.out.printf("== 前序遍历: ");
640 tree.preOrder();
641
642 System.out.printf("\n== 中序遍历: ");
643 tree.inOrder();
644
645 System.out.printf("\n== 后序遍历: ");
646 tree.postOrder();
647
648 System.out.printf("\n");
649
650 System.out.printf("== 最小值: %s\n", tree.minimum());
651 System.out.printf("== 最大值: %s\n", tree.maximum());
652 System.out.printf("== 树的详细信息: \n");
653 tree.print();
654
655 System.out.printf("\n");
656
657 // 设置mDebugDelete=true,测试"删除函数"
658 if (mDebugDelete) {
659 for (i = 0; i < length; i++) {
660 tree.remove(a[i]);
661
662 System.out.printf("== 删除节点: %d\n", a[i]);
663 System.out.printf("== 树的详细信息: \n");
664 tree.print();
665
666 System.out.printf("\n");
667 }
668 }
669
670 // 销毁二叉树
671 tree.clear();
672 }
673
674 /** 红黑树结点 RBTNode **/
675 public class RBTNode<T extends Comparable<T>> {
676 boolean color; // 颜色
677 T key; // 关键字
678 RBTNode<T> left;
679 RBTNode<T> right;
680 RBTNode<T> parent;
681
682 public RBTNode(boolean color, T key, RBTNode<T> left, RBTNode<T> right, RBTNode<T> parent) {
683 this.color = color;
684 this.key = key;
685 this.left = left;
686 this.right = right;
687 this.parent = parent;
688 }
689
690 public boolean isColor() {
691 return color;
692 }
693
694 public void setColor(boolean color) {
695 this.color = color;
696 }
697
698 public T getKey() {
699 return key;
700 }
701
702 public void setKey(T key) {
703 this.key = key;
704 }
705
706 public RBTNode<T> getLeft() {
707 return left;
708 }
709
710 public void setLeft(RBTNode<T> left) {
711 this.left = left;
712 }
713
714 public RBTNode<T> getRight() {
715 return right;
716 }
717
718 public void setRight(RBTNode<T> right) {
719 this.right = right;
720 }
721
722 public RBTNode<T> getParent() {
723 return parent;
724 }
725
726 public void setParent(RBTNode<T> parent) {
727 this.parent = parent;
728 }
729 }
730 }来源：oschina
链接：https://my.oschina.net/u/4309066/blog/3411427