红黑树

红黑树与二叉查找树相似，只是增加了一个字段来表示节点是红色还是黑色。为什么要增加这个属性呢？在二叉查找树中，如果节点按照从大到小或从小到大插入，二叉查找树就变成了一个链表。因此增加这个字段来调整树的高度避免它变成一个链表，为什么能避免？

首先看一下红黑树的属性：

1. 每个节点非红即黑。

2. 根节点为黑色。

3. 每个叶子节点都为黑色。

4. 如果一个节点为红色，那么它的子女必须为黑色。

5. 任意节点到它子树叶子节点所有路径都必须包含相同黑色节点个数。

由此可得出定理：

A red-black tree with n internal nodes has height at most 2 lg(n + 1).

 证明：存在任一个节点x，把x到达任一个叶子节点的路径中的黑节点的个数称为黑高度，设为bh(x)。首先证明x的子树中至少有2^bh(x)-1个节点，用归纳法证明。根据x和他子女的红黑属性，可得出x子女的黑高度为bh(x)或bh(x)-1，可假设子女的子树至少有2^bh(x)-1个节点，那么x就至少有2^bh(x)-1-1+2^bh(x)-1-1+1=2^bh(x)-1个节点。设n>=2^bh(x)-1，则bh(x)<=2lg(n+1)。因此红黑属性一定程度保证了树的平衡性。

红黑树实现：

红黑树的实现与二叉查找树的实现相似，只是在插入删除的时候加入调整函数以保证红黑树的属性。

RBTree.h:

// RBTree.h
#pragma  once

typedef  enum  _color
... {
    RED,
    BLACK
} COLOR;

class  RBNode
... {
public:
    RBNode(void):key(0),parent(NULL),left(NULL),right(NULL),color(BLACK)...{}
    RBNode(int value);
public:
    ~RBNode(void);
public:
    int key;
    RBNode *parent;
    RBNode *left;
    RBNode *right;
    COLOR color;
} ;

class  RBTree
... {
public:
    RBTree(void);
    void Insert(int value);
    void Delete(int value);
    RBNode* Max(RBNode *pNode);
    RBNode* Min(RBNode *pNode);
    void Dispose(RBNode *pNode);
public:
    ~RBTree(void);
private:
    void LeftRotate(RBNode *pNode);
    void RightRotate(RBNode *pNode);
    void InsertFixUp(RBNode *pNode);
    RBNode* Successor(RBNode *pNode);
    void DeleteFixUp(RBNode *pNode);
private:
    RBNode* m_pRoot;
    static RBNode *nil;
} ;

RBTree.cpp:

 

#include  " StdAfx.h "
#include  " RBTree.h "

RBNode::RBNode( int  value)
... {
    key=value;
    parent=NULL;
    left=NULL;
    right=NULL;
    color=RED;
}

RBNode:: ~ RBNode()
... {
}

RBNode *  RBTree::nil = new  RBNode();

RBTree::RBTree( void )
... {
    m_pRoot=NULL;
}

RBTree:: ~ RBTree( void )
... {
    Dispose(m_pRoot);
}

void  RBTree::Dispose(RBNode  * pNode)
... {
    if(pNode->left!=nil)
        Dispose(pNode->left);
    if(pNode->right!=nil)
        Dispose(pNode->right);
    delete pNode;
}

void  RBTree::Insert( int  value)
... {
    if(m_pRoot==NULL)
    ...{
        RBNode *pNew=new RBNode();
        pNew->key=value;
        pNew->parent=nil;
        pNew->left=nil;
        pNew->right=nil;
        m_pRoot=pNew;
    }
    else
    ...{
        RBNode *py;
        RBNode *px=m_pRoot;
        while(px!=nil)
        ...{
            py=px;
            if(value<px->key)
            ...{
                px=px->left;
            }
            else if(value>px->key)
            ...{
                px=px->right;
            }
            else
            ...{
                py=nil;
            }
        }
        if(py!=nil)
        ...{
            RBNode *pNew=new RBNode(value);
            pNew->parent=py;
            if(value<py->key)
            ...{
                py->left=pNew;
            }
            else
            ...{
                py->right=pNew;
            }
            pNew->left=nil;
            pNew->right=nil;
            pNew->color=RED;

            if(py!=this->m_pRoot)
                InsertFixUp(pNew);
        }
    }
}

void  RBTree::LeftRotate(RBNode  * pNode)
... {
    if(pNode->right!=nil)
    ...{
        RBNode *y=pNode->right;
        pNode->right=y->left;
        if(nil!=y->left)
        ...{
            y->left->parent=pNode;
        }
        y->parent=pNode->parent;
        if(nil==pNode->parent)
        ...{
            m_pRoot=y;
        }
        else if(pNode=pNode->parent->left)
        ...{
            pNode->parent->left=y;
        }
        else
        ...{
            pNode->parent->right=y;
        }
        y->left=pNode;
        pNode->parent=y;
    }
}

void  RBTree::RightRotate(RBNode  * pNode)
... {
    if(nil!=pNode->left)
    ...{
        RBNode *y=pNode->left;
        pNode->left=y->right;
        if(nil!=y->right)
        ...{
            y->right->parent=pNode;
        }
        y->parent=pNode->parent;
        if(nil==pNode->parent)
        ...{
            m_pRoot=y;
        }
        else if(pNode->parent->left==pNode)
        ...{
            pNode->parent->left=y;
        }
        else
        ...{
            pNode->parent->right=y;
        }
        y->right=pNode;
        pNode->parent=y;
    }
}

void  RBTree::InsertFixUp(RBNode  * pNode)
... {
    while(pNode->parent->color==RED)
    ...{
        RBNode *py;
        if(pNode->parent==pNode->parent->parent->left)
        ...{
            py=pNode->parent->parent->right;
            //Case 1: z's uncle y is red
            if(py->color==RED)
            ...{
                pNode->parent->color=BLACK;
                py->color=BLACK;
                pNode->parent->parent->color=RED;
                pNode=pNode->parent->parent;
            }
            else
            ...{
                //Case 2: z's uncle y is black and z is a right child
                if(pNode==pNode->parent->right)
                ...{
                    pNode=pNode->parent;
                    this->LeftRotate(pNode);
                }
                //Case 3: z's uncle y is black and z is a left child
                pNode->parent->color=BLACK;
                pNode->parent->parent->color=RED;
                this->RightRotate(pNode->parent->parent);
            }
        }
        else
        ...{
            py=pNode->parent->parent->left;
            if(py->color==RED)
            ...{
                pNode->parent->color=BLACK;
                py->color=BLACK;
                pNode->parent->parent->color=RED;
            }
            else
            ...{
                if(pNode==pNode->parent->left)
                ...{
                    pNode=pNode->parent;
                    this->RightRotate(pNode);
                }
                pNode->parent->color=BLACK;
                pNode->parent->parent->color=RED;
                this->LeftRotate(pNode->parent->parent);
            }
        }
    }
    this->m_pRoot->color=BLACK;
}

RBNode *  RBTree::Max(RBNode  * pNode)
... {
    while(pNode->left!=nil)
    ...{
        pNode=pNode->left;
    }
    return pNode;
}

RBNode *  RBTree::Min(RBNode  * pNode)
... {
    while(pNode->right!=nil)
    ...{
        pNode=pNode->right;
    }
    return pNode;
}

RBNode *  RBTree::Successor(RBNode  * pNode)
... {
    if(pNode->right!=nil)
        return Min(pNode->right);
    RBNode* py=pNode->parent;
    while(py!=nil&&pNode==py->right)
    ...{
        pNode=py;
        py=py->parent;
    }
    return py;
}

RBNode *  RBTree::Find( int  value)
... {
    if(this->m_pRoot==nil)
        return NULL;
    else
    ...{
        RBNode *pNode=this->m_pRoot;
        while(pNode->key!=value&&pNode!=nil)
        ...{
            if(value<pNode->key)
            ...{
                pNode=pNode->left;
            }
            else
            ...{
                pNode=pNode->right;
            }
        }
        return pNode==nil?NULL:pNode;
    }
}

void  RBTree::Delete( int  value)
... {
    RBNode *pNode=Find(value);
    RBNode *py,*px;
    if(pNode!=NULL)
    ...{
        if(pNode->left==nil||pNode->right==nil)
        ...{
            py=pNode;
        }
        else
        ...{
            py=this->Successor(pNode);
        }
        if(py->left!=nil)
        ...{
            px=py->left;
        }
        else
        ...{
            px=py->right;
        }
        px->parent=py->parent;
        if(py->parent==nil)
        ...{
            m_pRoot=px;
        }
        else if(py->parent->left=py)
        ...{
            py->parent->left=px;
        }
        else
        ...{
            py->parent->right=px;
        }
        bool isFix=py->color==BLACK?true:false;
        if(py==pNode)
        ...{
            py->parent=pNode->parent;
            py->left=pNode->left;
            py->right=pNode->right;
            py->color=pNode->color;
            delete pNode;
        }
        if(isFix)
            DeleteFixUp(px);
    }
}

void  RBTree::DeleteFixUp(RBNode  * pNode)
... {
    if(pNode==NULL||pNode==nil)
        return;
    while(pNode!=this->m_pRoot&&pNode->color==BLACK)
    ...{
        if(pNode==pNode->parent->left)
        ...{
            RBNode *pw=pNode->parent->right;
            //case1:x's sibling w is red
            if(pw->color=RED)
            ...{
                pNode->parent->color=RED;
                pw->color=BLACK;
                this->LeftRotate(pNode->parent);
                pw=pNode->parent->right;
            }
            //case2:x's sibling w is black, and both of w's children are black
            if(pw->left->color==BLACK&&pw->right->color==BLACK)
            ...{
                pw->color=RED;
                pNode=pNode->parent;
            }
            else
            ...{
                //case3:x's sibling w is black, w's left child is red, and w's right child is black
                if(pw->right->color==BLACK)
                ...{
                    pw->left->color=BLACK;
                    pw->color=RED;
                    this->RightRotate(pw);
                    pw=pNode->parent->right;
                }
                //case4:x's sibling w is black, and w's right child is red
                pw->color=pNode->parent->color;
                pNode->parent->color=BLACK;
                pw->right->color=BLACK;
                this->LeftRotate(pNode->parent);
                pNode=this->m_pRoot;
            }
        }
        else
        ...{
            RBNode *pw=pNode->parent->left;
            if(pw->color==RED)
            ...{
                pNode->parent->color=RED;
                pw->color=BLACK;
                this->RightRotate(pNode->parent);
                pw=pNode->parent->left;
            }
            if(pw->right->color==BLACK&&pw->left->color==BLACK)
            ...{
                pw->color=RED;
                pNode=pNode->parent;
            }
            else
            ...{
                if(pw->left->color==BLACK)
                ...{
                    pw->color=RED;
                    pw->left->color=BLACK;
                    this->LeftRotate(pw);
                    pw=pNode->parent->left;
                }
                pw->color=pNode->parent->color;
                pNode->parent->color=BLACK;
                pw->left->color=RED;
                this->RightRotate(pNode);
                pNode=this->m_pRoot;
            }
        }
    }
    pNode->color=BLACK;
}