一、红黑树的介绍
先来看下算法导论对R-B Tree的介绍：
红黑树，一种二叉查找树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。
通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其
他路径长出俩倍，因而是接近平衡的。
前面说了，红黑树，是一种二叉查找树，既然是二叉查找树，那么它必满足二叉查找树的一般性质。
下面，在具体介绍红黑树之前，咱们先来了解下 二叉查找树的一般性质：
1.在一棵二叉查找树上，执行查找、插入、删除等操作，的时间复杂度为O（lgn）。
因为，一棵由n个结点，随机构造的二叉查找树的高度为lgn，所以顺理成章，一般操作的执行时间为O（lgn）。
至于n个结点的二叉树高度为lgn的证明，可参考算法导论 第12章 二叉查找树 第12.4节。
2.但若是一棵具有n个结点的线性链，则此些操作最坏情况运行时间为O（n）。
而红黑树，能保证在最坏情况下，基本的动态几何操作的时间均为O（lgn）。
我们知道，红黑树上每个结点内含五个域，color，key，left，right，p。如果相应的指针域没有，则设为NIL。
一般的，红黑树，满足以下性质，即只有满足以下全部性质的树，我们才称之为红黑树：
1）每个结点要么是红的，要么是黑的。
2）根结点是黑的。
3）每个叶结点，即空结点（NIL）是黑的。
4）如果一个结点是红的，那么它的俩个儿子都是黑的。
5）对每个结点，从该结点到其子孙结点的所有路径上包含相同数目的黑结点。
注：实际上考虑的情况有6种，而其中的三种与另外三种是对称的。这取决于下面算法中 p[z] = left[p[p[z]]]这一句。
红黑树插入的第一种情况（RB-INSERT-FIXUP(T, z)代码的具体分析一）
为了保证阐述清晰，重述下RB-INSERT-FIXUP(T, z)的源码：
RB-INSERT-FIXUP(T, z)
1 while color[p[z]] = RED
2 do if p[z] = left[p[p[z]]]
3 then y ← right[p[p[z]]]
4 if color[y] = RED
5 then color[p[z]] ← BLACK ▹ Case 1
6 color[y] ← BLACK ▹ Case 1
7 color[p[p[z]]] ← RED ▹ Case 1
8 z ← p[p[z]] ▹ Case 1
9 else if z = right[p[z]]
10 then z ← p[z] ▹ Case 2
11 LEFT-ROTATE(T, z) ▹ Case 2
12 color[p[z]] ← BLACK ▹ Case 3
13 color[p[p[z]]] ← RED ▹ Case 3
14 RIGHT-ROTATE(T, p[p[z]]) ▹ Case 3
15 else (same as then clause
with "right" and "left" exchanged)
16 color[root[T]] ← BLACK
//case1表示情况1，case2表示情况2，case3表示情况3.
咱们，先来透彻分析红黑树插入的第一种情况：
插入情况1，z的叔叔y是红色的。
第一种情况，即上述代码的第5-8行：
5 then color[p[z]] ← BLACK ▹ Case 1
6 color[y] ← BLACK ▹ Case 1
7 color[p[p[z]]] ← RED ▹ Case 1
8 z ← p[p[z]] ▹ Case 1
如上图所示，a：z为右孩子，b：z为左孩子。
只有p[z]和y（上图a中A为p[z]，D为z，上图b中，B为p[z]，D为y）都是红色的时候，才会执行此情况1.
咱们分析下上图的a情况，即z为右孩子时
因为p[p[z]]，即c是黑色，所以将p[z]、y都着为黑色（如上图a部分的右边），
此举解决z、p[z]都是红色的问题，将p[p[z]]着为红色，则保持了性质5.
红黑树插入的第二种、第三种情况
插入情况2：z的叔叔y是黑色的，且z是右孩子
插入情况3：z的叔叔y是黑色的，且z是左孩子
这俩种情况，是通过z是p[z]的左孩子，还是右孩子区别的。
参照上图，针对情况2，z是她父亲的右孩子，则为了保持红黑性质，左旋则变为情况3，此时z为左孩子，
因为z、p[z]都为黑色，所以不违反红黑性质（注，情况3中，z的叔叔y是黑色的，否则此种情况就变成上述情况1 了）。
我们已经看出来了，情况2，情况3都违反性质4（一个红结点的俩个儿子都是黑色的）。
所以情况2->左旋后->情况3，此时情况3同样违反性质4，所以情况3->右旋，得到上图的最后那部分。
注，情况2、3都只违反性质4，其它的性质1、2、3、5都不违背。
下面附上java代码:
效果图如下：
package com.hjzgg.rbt;
import java.awt.Rectangle;
public class RBTNode {
public static final boolean RED = true;
public static final boolean BLACK = false;
public RBTNode[] child = new RBTNode[2];
public RBTNode parent;
public int key;
public boolean color;
public RBTNode(RBTNode parent, int key, boolean color) {
super();
this.parent = parent;
this.key = key;
this.color = color;
child[0] = child[1] = null;
}
private int level;//这个节点在树中的层次
private Rectangle rect;//节点在图形面板中的位置
public int getLevel() {
return level;
}
public void setLevel(int level) {
this.level = level;
}
public Rectangle getRect() {
return rect;
}
public void setRect(Rectangle rect) {
this.rect = rect;
}
}
package com.hjzgg.rbt;
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.HeadlessException;
import java.awt.Rectangle;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.Map;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
public class RBTGraphic {
private RBTNode T = null;
private final int distNode = 50;//节点之间的距离
private final int heightNode = 50;//节点的高度
private final int widthNode = 50;//节点的宽度
private final int levelHeight = 100;//层与层之间的高度
private ArrayList<Rectangle> line = new ArrayList<Rectangle>();
private int curY = 0;
private int curX = 10;
public RBTGraphic(RBTNode T) {
super();
this.T = T;
prepareGraphic();
}
public class TreeFrame extends JFrame{
private JPanel panel = new JPanel(){
@Override
protected void paintComponent(Graphics g) {
super.paintComponent(g);
for(Rectangle rect : line){
g.drawLine(rect.x, rect.y, rect.width, rect.height);
}
}
};
private JScrollPane scrollPane = new JScrollPane(panel);
public TreeFrame() throws HeadlessException {
super();
init();
}
public TreeFrame(String title) throws HeadlessException {
super(title);
init();
}
private void init(){
setLayout(new BorderLayout());
panel.setLayout(null);
drawTree(T);
add(scrollPane, BorderLayout.CENTER);
int width = curX + 50;
int height = curY + 50;
//这里要设置面板的PreferredSize，如果当前Frame大小不能显示PreferredSize那么才会出现滚动条
panel.setPreferredSize(new Dimension(width, height));
if(width > 600) width = 600;
if(height > 300) height = 500;
setBounds(400, 100, width, height);
setVisible(true);
}
public void drawTree(RBTNode o){
if(o==null) return;
JLabel label = new JLabel(o.key+"", JLabel.CENTER);
label.setBounds(o.getRect());
label.setFont(new Font("宋体",Font.BOLD, 32));
label.setForeground(Color.WHITE);
label.setOpaque(true);
if(o.color == RBTNode.RED)
label.setBackground(Color.RED);
else
label.setBackground(Color.BLACK);
panel.add(label);
if(o.child[0]==null && o.child[1]==null) return;
int x = o.getRect().x+ widthNode/2;
int y = o.getLevel()*levelHeight+heightNode;
for(int i=0; i<2; ++i){
drawTree(o.child[i]);
if(o.child[i]==null) continue;
int xx = o.child[i].getRect().x + widthNode/2;
int yy = y+levelHeight-heightNode;
line.add(new Rectangle(x, y, xx, yy));
}
}
}
private void prepareNodeLevel(RBTNode o, int level){//确定每一个节点的层次
if(o==null) return;
o.setLevel(level);
prepareNodeLevel(o.child[0], level+1);
prepareNodeLevel(o.child[1], level+1);
if(curY < (level+1)*levelHeight) curY = (level+1)*levelHeight;
}
private void prepareNodeSize(RBTNode o){//确定节点的坐标位置
if(o==null) return;
if(o.child[0]==null && o.child[1]==null){//终结点
int x = curX; curX+=distNode+widthNode;
int y = o.getLevel()*levelHeight;
o.setRect(new Rectangle(x, y, widthNode, heightNode));
return;
}
prepareNodeSize(o.child[0]);
prepareNodeSize(o.child[1]);
int leftChildx = o.child[0] != null ? o.child[0].getRect().x : o.child[1].getRect().x;
int rightChildx = o.child[1] == null ? o.child[0].getRect().x : o.child[1].getRect().x;
//根据左右两边孩子的节点，确定父节点的坐标尺寸
int parentx = (leftChildx+rightChildx)/2;
int parenty =o.getLevel()*levelHeight;
o.setRect(new Rectangle(parentx, parenty, widthNode, heightNode));
}
private void prepareGraphic(){
prepareNodeLevel(T, 0);
prepareNodeSize(T);
}
}
package com.hjzgg.rbt;
import java.util.Scanner;
public class RBTree {
public RBTNode T = null;
private boolean isRoot = true;//是不是第一个插入的节点，也就是根节点
public void rotateT(RBTNode o, int rotate){//rotate表明旋转方向
RBTNode k = o.child[rotate^1];
if(o.parent==null)
T = k;
else if(o.parent.child[0] == o)
o.parent.child[0] = k;
else
o.parent.child[1] = k;
k.parent = o.parent;
o.child[rotate^1] = k.child[rotate];
k.child[rotate] = o;
o.parent = k;
}
private void rbtInsertFixup(RBTNode o){//红黑树平衡的调整,并更改节点的颜色
if(o.parent.color == RBTNode.RED){
int childIndex;//左子树或者是右子树索引
if(o.parent == o.parent.parent.child[0])
childIndex = 0;
else
childIndex = 1;
//找到o节点对应的叔节点
RBTNode ou = o.parent.parent.child[childIndex^1];
if(ou!=null && ou.color == RBTNode.RED){//如果叔节点的颜色是红色
o.parent.parent.color = RBTNode.RED;
ou.color = RBTNode.BLACK;
o.parent.color = RBTNode.BLACK;
} else {//叔节点是空或者是黑色
if(o == o.parent.child[childIndex^1]){
o = o.parent;
rotateT(o, childIndex);
}
o.parent.color = RBTNode.BLACK;
o.parent.parent.color = RBTNode.RED;
rotateT(o.parent.parent, childIndex^1);
}
T.color = RBTNode.BLACK;
}
}
public void outT(RBTNode o){
if(o==null) return;
System.out.print(o.key+" ");
outT(o.child[0]);
outT(o.child[1]);
}
public void rbtInsert(RBTNode o, RBTNode op, int key, int childIndex){//红黑树的插入
if(o == null){
o = new RBTNode(op, key, RBTNode.RED);
if(op==null){
T = o;
T.color = RBTNode.BLACK;
} else {
op.child[childIndex] = o;
o.parent = op;
}
if(o.color==RBTNode.RED)
rbtInsertFixup(o);
} else if(o.key < key){
rbtInsert(o.child[0], o, key, 0);
if(o.color==RBTNode.RED)
rbtInsertFixup(o);
} else {
rbtInsert(o.child[1], o, key, 1);
if(o.color==RBTNode.RED)
rbtInsertFixup(o);
}
}
public void rbtDelete(){//红黑树的删除
}
public static void main(String[] args) {
RBTree rbt = new RBTree();
Scanner scan = new Scanner(System.in);
for(int i=0; i<15; ++i){
int key = scan.nextInt();
rbt.rbtInsert(rbt.T, null, key, 0);
// rbt.outT(rbt.T);
// System.out.println();
}
new RBTGraphic(rbt.T).new TreeFrame("红黑树");
}
}
/*
2 3 4 6 7 9 11 9 18 14 12 17 19 22 20
*/
