树及树的算法（4） —— 红黑树

红黑树是在1972年由德国科学家鲁道夫·贝尔发明的，他称之为“对称二叉B树”，它现代的名字是在 Leo J. Guibas和 Robert Sedgewick 于1978年写的一篇论文中获得的。红黑树的实现是很复杂的，但它的操作有着良好的最坏情况运行时间，并且在实践中是高效的：它可以在O(log n)时间内做查找，插入和删除，这里的n是树中元素的数目。

图：鲁道夫·贝尔

 

红黑树和AVL树一样都对插入时间、删除时间和查找时间提供了最好可能的最坏情况担保。这不只是使它们在时间敏感的应用如实时应用(real time application)中有价值，而且使它们有在提供最坏情况担保的其他数据结构中作为建造板块的价值；例如，在计算几何中使用的很多数据结构都可以基于红黑树。

 

红黑树在函数式编程中也特别有用，在这里它们是最常用的持久数据结构之一，它们用来构造关联数组和集合，在突变之后它们能保持为以前的版本。除了O(log n)的时间之外，红黑树的持久版本对每次插入或删除需要O(log n)的空间。

 

红黑树是 2-3-4树的一种等同。换句话说，对于每个 2-3-4树，都存在至少一个数据元素是同样次序的红黑树。在 2-3-4树上的插入和删除操作也等同于在红黑树中颜色翻转和旋转。这使得 2-3-4树成为理解红黑树背后的逻辑的重要工具，这也是很多介绍算法的教科书在红黑树之前介绍 2-3-4树的原因，尽管 2-3-4树在实践中不经常使用。

 

红黑树是每个节点都带有颜色属性的二叉查找树，颜色为红色或黑色。在二叉查找树强制一般要求以外，对于任何有效的红黑树我们增加了如下的额外要求：

性质1. 节点是红色或黑色。

性质2. 根是黑色。

性质3. 所有叶子都是黑色（叶子是NIL节点）。

性质4. 每个红色节点的两个子节点都是黑色。(从每个叶子到根的所有路径上不能有两个连续的红色节点)

性质5. 从任一节点到其每个叶子的所有简单路径都包含相同数目的黑色节点。

 

这些约束强制了红黑树的关键性质：从根到叶子的最长的可能路径不多于最短的可能路径的两倍长。结果是这个树大致上是平衡的。因为操作比如插入、删除和查找某个值的最坏情况时间都要求与树的高度成比例，这个在高度上的理论上限允许红黑树在最坏情况下都是高效的，而不同于普通的二叉查找树。

 

enum NODECOLOR{
	RED = 0,
	BLACK = 1
};

//红黑树
class RBTree : public BST
{
private:
	NODECOLOR color;
	RBTree* parent; 

public:

	RBTree();

	RBTree* Parent();
	RBTree* GrandParent();
	RBTree* Uncle();
    RBTree* Sibling();

    void AttachKey (Object& object, RBTree& parent);
    void Insert( Object& object, RBTree* prt = 0  );
    void Withdraw (Object& object);

protected:
    void DeleteBalance(RBTree *n);
	void RotateLeft();
	void RotateRight();

private:
    void insert_case1(RBTree& n);
    void insert_case2(RBTree& n);
    void insert_case3(RBTree& n);
    void insert_case4(RBTree& n);
    void insert_case5(RBTree& n);

    void delete_case1(RBTree& n);
    void delete_case2(RBTree& n);
    void delete_case3(RBTree& n);
    void delete_case4(RBTree& n);
    void delete_case5(RBTree& n);
    void delete_case6(RBTree& n);

	bool isRBLeaf();
};
RBTree::RBTree():
BST(),
parent(0),
color(BLACK){}

//找妈妈
RBTree* RBTree::Parent()
{
	if (0 == parent)
	{
		throw domain_error ("invalid operation");
	}
	return parent;
}

//找爷爷
RBTree* RBTree::GrandParent()
{
	if (0 == parent || 0 == parent->Parent())
	{
		throw domain_error ("invalid operation");
	}
	return parent->Parent();
}

//找舅舅
RBTree* RBTree::Uncle()
{
    if (parent == GrandParent()->left)
        return (dynamic_cast<RBTree*> (GrandParent()->right));
    else
        return (dynamic_cast<RBTree*> (GrandParent()->left));
}

//找兄弟
RBTree* RBTree::Sibling()
{
    if (this == this->parent->left)
        return dynamic_cast<RBTree*> (this->parent->right);
    else
        return dynamic_cast<RBTree*> (this->parent->left);
}

void RBTree::AttachKey( Object& object, RBTree& prt )
{
    if (!IsEmpty ())
        throw domain_error ("invalid operation");
    key = &object;
    left = new RBTree ();
    right = new RBTree ();
	color = RED;
    parent = &prt;

	RBTree* tmpLeft = dynamic_cast<RBTree*> (left);
	RBTree* tmpRight = dynamic_cast<RBTree*> (right);
	tmpLeft->parent = this;
	tmpRight->parent = this;
  
}

void RBTree::Insert( Object& object,RBTree* prt )
{
    if (IsEmpty ())
    {
        AttachKey (object, *prt);
        insert_case1(*this);
    }else{    
        int const diff = object.Compare (*key);
        if (diff == 0)
        {
            throw invalid_argument ("duplicate key");
        }
        if (diff < 0)
        {
            BST& bstTmp = Left();
			RBTree& rbTmp = d