红黑树：个人理解与Python实现
【基本事实1】
红黑树是一种平衡的二叉查找树，无论插入还是删除操作都可以在O(lg n)内实现，而一般的二叉查找树则在极端情况下会退化为线性结构。
红黑树之所以是平衡的二叉查找树，是因为每个节点都有表示其颜色的域值：红或黑，在插入和删除操作的时候依据节点的颜色向平衡的方向调整。根本原因当然是由红黑树定义所决定的：
如果一个二叉查找树满足如下条件，那么它就称作红黑树：
1.每个节点要么是红色，要么是黑色
2.根结点是黑色
3.每个叶节点(NIL)为黑色
4.如果一个节点是红色，其儿子节点一定是黑色
5.对于每个节点，从该节点到其子孙节点的所有路径上包含相同数目的黑节点
【个人理解1】
红黑树的定义中，我认为有这些地方要注意：
1.每个节点只有一种颜色（后面删除节点的操作时引入的“额外一重黑色”则不满足此条件，所以一直要性质1调整）
2.定义中的叶节点是指NIL，它们都是黑色，而且没有子节点。根结点的父节点也是NIL。比如只有一个根节点的红黑树，它有两个叶节点。NIL是没有值的，只是一种存在。（我在Python的实现中，把NIL值都设定为None）
3.如果一个节点是红色的，它一定不是根结点，而且一定有父节点（父节点也一定是黑色的）；如果它有儿子节点则一定是黑色儿子节点（每个节点如果左右儿子都是NIL，我认为它没有儿子）
4.性质5说的就是黑高度了
【基本事实2】
红黑树的旋转
红黑树在INSERT和DELETE的过程中，会使用到旋转操作。红黑树有两种旋转：左旋和右旋
左旋x：从右图到左图的过程
右旋y：从左图到右图的过程
【个人理解2】
1.并非每个节点在INSERT或DELETE的过程中都需要旋转操作
2.左旋就是右儿子y取代父节点x，x作为y的做儿子，y原来的左儿子b成为x现在的右儿子
3.右旋就是左旋的逆向过程
【基本事实3】
红黑树的插入
INSERT一个值的过程，就是在二叉查找树的INSERT操作基础上，根据红黑树性质做必要的调整，比如颜色变化，比如旋转，也就是INSERT_FIXUP的过程
插入的节点一般设定为红色然后再调整
【个人理解3】
假设要插入的节点为z，INSERT操作就是把z放到树的最底层，然后用INSERT_FIXUP区调整。INSERT_FIXUP中要注意的是：
1.如果z的父节点是NIL（即：插入节点z之前红黑树为空），那么把z涂黑，并成为根结点（完成插入）
2.如果z的父节点是黑色的，不用调整（完成插入）
3.如果z的父节点是红色的：
3-0：如果z没有叔叔节点，那么：
3-0-0：如果z为右儿子，且z的父节点p为左儿子，则左旋z的父节点，成为3-0-1；如果z为左儿子，且z的父节点p为右儿子，则右旋z的父节点p，成为3-0-1；
3-0-1：如果z为左儿子，则“父涂黑，爷涂红”，然后如果父节点是左儿子，则“爷右旋”，否则“爷左旋”（完成插入）
3-1：如果z的叔叔节点为黑色，那么：
3-1-0：如果z是右儿子，且z的父节点p为左儿子，则左旋z的父节点，成为3-1-1；如果z为左儿子，且z的父节点p为右儿子，则右旋z的父节点p，成为3-1-1；
3-1-1：如果z是左儿子，那么“父涂黑，爷涂红”，然后如果父节点是左儿子，则“爷右旋”，否则“爷左旋”（完成插入）
3-2：如果z的叔叔节点为红色，那么“父涂黑，叔涂黑，爷涂红”，并对爷爷节点g调用INSERT_FIXUP过程
以上序号和《算法导论》中的对应关系：3-2对应case1，3-1-0对应case2，3-1-1对应case3
【基本事实4】
1.红黑树删除一个节点的操作比较复杂，但也是在二叉查查找树的基础上，调用DELETE_FIXUP过程来调整
2.如果要删除的节点z，它有两个儿子，那么让z的值设定为z的后继节点y的值，然后删除y
3.如果要删除的节点z只有一个儿子x，那就让z的节点p和x成为“父子”。如果z原来是红色的，则不必调用DELETE_FIXUP过程，否则要调用
4.如果要删除的节点z没有儿子：那就直接删除z好了
5.删除节点时引入了“额外的一层黑色”，《算法导论》中文第二版P173这样说：
“在RB—DELETE中，如果被删除的节点y是黑色的，则会产生三个问题。首先，如果y原来是根结点，而y的一个红色的孩子成为了新的根，这就问犯了性质2）。其次，如果x和p[y]（现在也是p[x]）都是红的，就违反了性质4）。第三，删除y将导致先前包含y的任何路径上黑节点个数少1。因此，性质5）被y的一个祖先破坏了。不久者恶问题的一个办法就是把结点x视为还有额外的一重黑色。也就是说，如果将人以包含结点x的路径上黑节点个数加1，则在这种假设下，性质5）成立。当将黑节点y删除时，将其黑色“下推”至其子节点。现在为题变为结点x可能既不是红，又不是黑，从而违反了性质1）。结点x是双重黑色或红黑，这就分别给包含x的路径上黑结点个数贡献2个或1个。x的color属性仍然是RED（如果x是红黑的）或BLACK（如果x是双重黑色）。换言之，一个结点额外的黑色反映在x指向它，而不是它的color属性。”
【个人理解4】
1.当你想举反例推翻某个“结论”时，请注意，你的反例中的红黑树可能并不是红黑树；或者，它满足红黑树的定义，但无法判断是否能通过“每次插入一个节点”的方式生成。
2.因为有“额外一重黑色”的存在，《算法导论》中关于红黑树删除的case1中，调整前后的两幅图虽然“看上去是镜面对称”，但前者不满足性质5，调整后满足性质5
3.《算法导论》中关于红黑树删除的case2中，x现在为黑色，且有额外的一重黑色（就像是背负着子孙们的希望。。。），此时将x和w都去掉一个黑色，然后使p（x）增加额外的一层黑色。由于w原本为黑色，则现在令w为红色即可。此时令new_x=p(x)，若new_x原本为红色，置黑即可结束；否则，对new_x调用DELETE_FIXUP过程
4.DELETE_FIXUP过程，调整的是DELETE(z)过程中z的左/右儿子(当z只有一个儿子时)，或者z的后继的右儿子
#coding:utf8#author:HaxtraZ
#description:红黑树，python实现
from random import randint
RED = 'red'
BLACK = 'black'
class RBT:
def __init__(self):
# self.items = []
self.root = None
self.zlist = []
def LEFT_ROTATE(self, x):
# x是一个RBTnode
y = x.right
if y is None:
# 右节点为空，不旋转
return
else:
beta = y.left
x.right = beta
if beta is not None:
beta.parent = x
p = x.parent
y.parent = p
if p is None:
# x原来是root
self.root = y
elif x == p.left:
p.left = y
else:
p.right = y
y.left = x
x.parent = y
def RIGHT_ROTATE(self, y):
# y是一个节点
x = y.left
if x is None:
# 右节点为空，不旋转
return
else:
beta = x.right
y.left = beta
if beta is not None:
beta.parent = y
p = y.parent
x.parent = p
if p is None:
# y原来是root
self.root = x
elif y == p.left:
p.left = x
else:
p.right = x
x.right = y
y.parent = x
def INSERT(self, val):
z = RBTnode(val)
y = None
x = self.root
while x is not None:
y = x
if z.val < x.val:
x = x.left
else:
x = x.right
z.PAINT(RED)
z.parent = y
if y is None:
# 插入z之前为空的RBT
self.root = z
self.INSERT_FIXUP(z)
return
if z.val < y.val:
y.left = z
else:
y.right = z
if y.color == RED:
# z的父节点y为红色，需要fixup。
# 如果z的父节点y为黑色，则不用调整
self.INSERT_FIXUP(z)
else:
return
def INSERT_FIXUP(self, z):
# case 1:z为root节点
if z.parent is None:
z.PAINT(BLACK)
self.root = z
return
# case 2:z的父节点为黑色
if z.parent.color == BLACK:
# 包括了z处于第二层的情况
# 这里感觉不必要啊。。似乎z.parent为黑色则不会进入fixup阶段
return
# 下面的几种情况，都是z.parent.color == RED:
# 节点y为z的uncle
p = z.parent
g = p.parent # g为x的grandpa
if g is None:
return
# return 这里不能return的。。。
if g.right == p:
y = g.left
else:
y = g.right
# case 3-0:z没有叔叔。即：y为NIL节点
# 注意，此时z的父节点一定是RED
if y == None:
if z == p.right and p == p.parent.left:
# 3-0-0:z为右儿子,且p为左儿子，则把p左旋
# 转化为3-0-1或3-0-2的情况
self.LEFT_ROTATE(p)
p, z = z, p
g = p.parent
elif z == p.left and p == p.parent.right:
self.RIGHT_ROTATE(p)
p, z = z, p
g.PAINT(RED)
p.PAINT(BLACK)
if p == g.left:
# 3-0-1:p为g的左儿子
self.RIGHT_ROTATE(g)
else:
# 3-0-2:p为g的右儿子
self.LEFT_ROTATE(g)
return
# case 3-1:z有黑叔
elif y.color == BLACK:
if p.right == z and p.parent.left == p:
# 3-1-0:z为右儿子,且p为左儿子,则左旋p
# 转化为3-1-1或3-1-2
self.LEFT_ROTATE(p)
p, z = z, p
elif p.left == z and p.parent.right == p:
self.RIGHT_ROTATE(p)
p, z = z, p
p = z.parent
g = p.parent
p.PAINT(BLACK)
g.PAINT(RED)
if p == g.left:
# 3-1-1:p为g的左儿子，则右旋g
self.RIGHT_ROTATE(g)
else:
# 3-1-2:p为g的右儿子，则左旋g
self.LEFT_ROTATE(g)
return
# case 3-2:z有红叔
# 则涂黑父和叔，涂红爷，g作为新的z，递归调用
else:
y.PAINT(BLACK)
p.PAINT(BLACK)
g.PAINT(RED)
new_z = g
self.INSERT_FIXUP(new_z)
def DELETE(self, val):
curNode = self.root
while curNode is not None:
if val < curNode.val:
curNode = curNode.left
elif val > curNode.val:
curNode = curNode.right
else:
# 找到了值为val的元素,正式开始删除
if curNode.left is None and curNode.right is None:
# case1:curNode为叶子节点：直接删除即可
if curNode == self.root:
self.root = None
else:
p = curNode.parent
if curNode == p.left:
p.left = None
else:
p.right = None
elif curNode.left is not None and curNode.right is not None:
sucNode = self.SUCCESOR(curNode)
curNode.val, sucNode.val = sucNode.val, curNode.val
self.DELETE(sucNode.val)
else:
p = curNode.parent
if curNode.left is None:
x = curNode.right
else:
x = curNode.left
if curNode == p.left:
p.left = x
else:
p.right = x
x.parent = p
if curNode.color == BLACK:
self.DELETE_FIXUP(x)
curNode = None
return False
def DELETE_FIXUP(self, x):
p = x.parent
# w:x的兄弟结点
if x == p.left:
w = x.right
else:
w = x.left
# case1:x的兄弟w是红色的
if w.color == RED:
p.PAINT(RED)
w.PAINT(BLACK)
if w == p.right:
self.LEFT_ROTATE(p)
else:
self.RIGHT_ROTATE(p)
if w.color == BLACK:
# case2:x的兄弟w是黑色的，而且w的两个孩子都是黑色的
if w.left.color == BLACK and w.right.color == BLACK:
w.PAINT(RED)
if p.color == BLACK:
return
else:
p.color = BLACK
self.DELETE_FIXUP(p)
# case3:x的兄弟w是黑色的，而且w的左儿子是红色的，右儿子是黑色的
if w.left.color == RED and w.color == BLACK:
w.left.PAINT(BLACK)
w.PAINT(RED)
self.RIGHT_ROTATE(w)
# case4:x的兄弟w是黑色的，而且w的右儿子是红
if w.right.color == RED:
p.PAINT(BLACK)
w.PAINT(RED)
if w == p.right:
self.LEFT_ROTATE(p)
else:
self.RIGHT_ROTATE(p)
def SHOW(self):
self.DISPLAY1(self.root)
return self.zlist
def DISPLAY1(self, node):
if node is None:
return
self.DISPLAY1(node.left)
self.zlist.append(node.val)
self.DISPLAY1(node.right)
def DISPLAY2(self, node):
if node is None:
return
self.DISPLAY2(node.left)
print node.val,
self.DISPLAY2(node.right)
def DISPLAY3(self, node):
if node is None:
return
self.DISPLAY3(node.left)
self.DISPLAY3(node.right)
print node.val,
class RBTnode:
'''红黑树的节点类型'''
def __init__(self, val):
self.val = val
self.left = None
self.right = None
self.parent = None
def PAINT(self, color):
self.color = color
def zuoxuan(b, c):
a = b.parent
a.left = c
c.parent = a
b.parent = c
c.left = b
if __name__ == '__main__':
rbt=RBT()
b = []
for i in range(100):
m = randint(0, 500)
rbt.INSERT(m)
b.append(m)
a = rbt.SHOW()
b.sort()
equal = True
for i in range(100):
if a[i] != b[i]:
equal = False
break
if not equal:
print 'wrong'
else:
print 'OK!'
PS:这篇文章刚写好的时候，代码中是有错误的，而且DELETE_FIXUP()也没有给出；分析中也有小错误。不过现在已经改正了，代码中通过随机生成的数字，用系统的排序和我写的红黑树的排序对比，发现是结果是一样的，所以可以认为前面的算法分析是正确的。不过，速度上其实还是有点慢的，比如我用红黑树去排序，用在一道codeforces的题目中取代系统的sort，结果就会超时。
