红黑树

性质导致了 强约束,也导致了O（lgn）的高度

 

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

性质2. 根是黑色。

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

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

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

 

得出的结论

1 从根到叶子的最长的可能路径不多于最短的可能路径的两倍长

2 最短的可能路径都是黑色节点，最长的可能路径有交替的红色和黑色节点

3 红色结点的父结点或子节点一定是黑色结点

4 在五个性质前提下推导出树的高度为o（lgn）的结论，

   即进行插入或删除时，只需关注保持五个性质，而五个性质决定了算法的复杂度为o（lgn）

 

插入需要注意的点

1 插入新节点总是红色节点

2 如果插入节点的父节点是黑色, 能维持性质

3 如果插入节点的父节点是红色, 破坏了性质. 故需要通过重新着色或旋转, 来维持性质

插入关键部分

解决相邻的两个节点为红色的结点，同时维持任意路径黑高度（黑色结点个数）相同

删除需要需要注意的点

1 如果删除的是红色节点, 不破坏性质

2 如果删除的是黑色节点, 那么这个路径上就会少一个黑色节点, 破坏了性质. 故需要通过重新着色或旋转, 来维持性质

删除关键部分

如果删除的是左子树黑色结点，维持的最终目的是左右黑高度相同，即维持右子树黑高度的同时，增加左子树的黑高度

代码主要根据上图实现 

#include <iostream>
#include <crtdbg.h>
#include <string>
using namespace std;
/*红黑树*/
/*实现中假设关键元素互不相同*/
typedef int DataType;

class BST
{
private:
    enum {BLACK = 0, RED = 1};
    /*结点的数据结构*/
    struct node
    {
        DataType data;
        bool color;
        node *left;
        node *right;
        node *parent;

        node()
        {
            color = RED;
            left = NULL;
            right = NULL;
            parent = NULL;
            data = 0;
        }
        node *Grandfather()
        {
            if (parent == NULL)
            {
                return NULL;
            }
            return parent->parent;
        }
        node *Uncle()
        {
            if(Grandfather() == NULL)
                return NULL;
            if (parent == Grandfather()->left)
            {
                return Grandfather()->right;
            }
            else
            {
                return Grandfather()->left;
            }
        }
        node *Sibling()
        {
            if (parent->left == this)
            {
                return parent->right;
            }
            else
            {
                return parent->left;
            }
        }
    };
    void Left_rotate(node *p )
    {
        //把y的左子树连接到p的右子树下面，并更新父节点
        node *y = p->right;
        p->right = y->left;
        if (y->left != NIL)
        {
            y->left->parent = p;
        }
        //更新y的父节点
        y->parent = p->parent;
        if (p->parent == NIL) //判断根结点
        {
            root = y;
        }
        //更新原x父节点的子节点
        else if (p == p->parent->left)
        {
            p->parent->left = y;
        }
        else
        {
            p->parent->right = y;
        }
        //更新x 与 y 的关系
        y->left = p;
        p->parent = y;
    }
    void Right_rotate(node *p)
    {
        node *y = p->left;
        p->left = y->right;
        if (y->right != NIL)
        {
            y->right->parent = p;
        }
        y->parent = p->parent;
        if (p->parent == NIL) //判断根结点
        {
            root = y;
        }
        else if (p == p->parent->left)
        {
            p->parent->left = y;
        }
        else
        {
           p->parent->right = y;
        }
        y->right = p;
        p->parent = y;
    }
    string OutputColor(bool color)
    {
        return color ? "RED":"BLACK";
    }
    /*纠正因插入而破坏的性质*/
    void Insert_Fixup(node *p)
    {
        /*由于p结点为红色（新插入默认赋值为红色），
          判断p的父节点是否为红色，如果为红色则破坏了红黑树的性质，需要维护*/
        while(p->parent->color == RED)
        {
            if (p->parent == p->Grandfather()->left) 
            {
                node *y = p->Grandfather()->right;
                if (y->color == RED)  /*case 3*/
                {
                    p->parent->color = BLACK;
                    y->color = BLACK;
                    p->Grandfather()->color = RED;
                    p = p->Grandfather();/*p结点向上移*/
                }
                else if (p == p->parent->right) /*case 2*/
                {
                    p = p->parent;/*p结点向上移*/
                    Left_rotate(p);
                }
                else
                {
                    p->parent->color = BLACK; /*case 3*/
                    p->Grandfather()->color = RED;
                    Right_rotate(p->Grandfather());/*注意是祖父结点*/
                }
            }
            else
            {
                node *y = p->Grandfather()->left;
                if (y->color == RED)  /*case 3*/
                {
                    p->parent->color = BLACK;
                    y->color = BLACK;
                    p->Grandfather()->color = RED;
                    p = p->Grandfather();
                }
                else if (p == p->parent->left) /*case 2*/
                {
                    p = p->parent;
                    Right_rotate(p);
                }
                else
                {
                    p->parent->color = BLACK; /*case 3*/
                    p->Grandfather()->color = RED;
                    Left_rotate(p->Grandfather());
                }
            }
        }
        root->color = BLACK;/*确保插入根结点时，满足红黑树的性质*/
    }
    /*纠正因删除而破坏的性质*/
    void Delete_Fixup(node *p)
    {
        /*判断p结点是否为黑色
         如果是红色不破坏红黑树性质
         原因1.删除红色树黑高度不变2.不存在两个相邻红色结点
         3. 如果y是红色的，就不可能是根，即根仍然是黑色的
         为保证性质任何路径上黑结点个数相同，假设p结点为多重颜色（双黑或红黑）*/
        while (p != root && p->color == BLACK)
        {
            if(p == p->parent->left)
            {
                node *pSibling = p->parent->right;
                if (pSibling->color == RED)/*case1*/
                {
                    pSibling->color = BLACK;
                    Left_rotate(p->parent);
                    pSibling = p->parent->right;
                }
                else if (pSibling->left->color == BLACK && pSibling->right->color == BLACK)/*case2*/
                {
                    pSibling->color = RED;
                    p = p->parent;
                }                
                else
                {
                    if (pSibling->right->color == BLACK)/*case3*/
                    {
                        pSibling->left->color = BLACK;
                        pSibling->color = RED;
                        Right_rotate(pSibling);
                        pSibling = p->parent->right;
                    }
                    pSibling->color = p->parent->color;/*case4*/
                    p->parent->color = BLACK;
                    pSibling->right->color = BLACK;
                    Left_rotate(p->parent);
                    p = root;
                }
            }
            else
            {
                node *pSibling = p->parent->left;
                if (pSibling->color == RED)/*case1*/
                {
                    pSibling->color = BLACK;
                    Left_rotate(p->parent);
                    pSibling = p->parent->left;
                }
                else if (pSibling->left->color == BLACK && pSibling->right->color == BLACK)/*case2*/
                {
                    pSibling->color = RED;
                    p = p->parent;
                }                
                else
                {
                    if (pSibling->left->color == BLACK)/*case3*/
                    {
                        pSibling->right->color = BLACK;
                        pSibling->color = RED;
                        Left_rotate(pSibling);
                        pSibling = p->parent->left;
                    }
                    pSibling->color = p->parent->color;/*case4*/
                    p->parent->color = BLACK;
                    pSibling->right->color = BLACK;
                    Right_rotate(p->parent);
                    p = root;
                }
            }
        }
        p->color = BLACK;
    }
    /*中序遍历*/
    void InOrderTree(node *p)
    {
        if (p == NULL || p == NIL)
        {
            return;
        }
        InOrderTree(p->left);
        cout << p->data << "	" << OutputColor(p->color) << endl;
        InOrderTree(p->right);
    }
    /*获取结点的后继*/
    node *TreeAfter(node *p)
    {
        if (p->right != NIL)
        {
            node *pTemp = p->right;
            while(pTemp != NIL)
            {
                p = pTemp;
                pTemp = p->left;
            }
        }
        return p;
    }
private:
    node *root;
    node *NIL;
public:
    BST()
    {
        NIL = new node();
        NIL->color = BLACK;
        root = NULL;
    }
    ~BST()
    {
        if (root != NULL)
        {
            Destory(root);
            root = NULL;
        }
        delete NIL;
        NIL = NULL;
    }
    void Destory(node *p)
    {
        if (p == NULL || p == NIL)
            return;
        Destory(p->left);
        Destory(p->right);
        delete p;
    }
    void Insert(DataType data)
    {
        node *p = root;
        node *pTemp = NIL;
        while( p != NIL && p != NULL)
        {
            pTemp = p;
            if (data < p->data)
            {
                p = p->left;
            }
            else
            {
                p = p->right;
            }
        }
        node *pNew = new node();
        pNew->parent = pTemp;
        pNew->data = data;
        if (pTemp == NIL)
        {
            root = pNew;
        }
        else
        {
            if (pNew->data < pTemp->data)
            {
                pTemp->left = pNew;
            }
            else
            {
                pTemp->right = pNew;
            }
        }
        pNew->left = NIL;
        pNew->right = NIL;
        Insert_Fixup(pNew);
    }
    /*非递归版本*/
    node* Find(DataType key)
    {
        node *p = root;
        while(p != NULL && p->data != key)
        {
            if (key < p->data)
            {
                p = p->left;
            }
            else
            {
                p = p->right;
            }
        }
        return p;
    }
    void Delete(DataType data)
    {
        /*获取data的指针*/
        node *p = Find(data);
        node *pDelete= NIL;
        node *pNode = NIL;/*要删除节点的子节点*/
        if (p->left == NIL || p->right == NIL)
        {
            pDelete = p;
        }
        else
        {
            pDelete = TreeAfter(p);
        }
        /*获取子结点*/
        if(pDelete->left != NIL)
        {
            pNode = pDelete->left;
        }
        else
        {
            pNode = pDelete->right;
        }
        /*更新父结点*/
        pNode->parent = pDelete->parent;
        /*更新子结点*/
        if (pDelete->parent == NIL)
        {
            root = pNode;
        }
        else if(pDelete->parent->left == pDelete)
        {
            pDelete->parent->left = pNode;
        }
        else
        {
            pDelete->parent->right = pNode;
        }
        if (pDelete != p)
        {
            p->data = pDelete->data;
        }
        /*如果要删除的结点pDelete是红色的，
        不影响黑高度，即不会破坏红黑树的性质*/
        if (pDelete->color == BLACK)
        {
            Delete_Fixup(pNode);
        }
        delete pDelete;
        pDelete = NULL;
    }
    void InOrder()
    {
        if (root == NULL)
        {
            return;
        }
        InOrderTree(root);
        cout << endl;
    }
};

void main()
{
    _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);

     BST bst;
     
     bst.Insert(11);
     bst.Insert(2);
     bst.Insert(14);
     bst.Insert(15);
     bst.Insert(1);
     bst.Insert(7);
     bst.Insert(5);
     bst.Insert(8);
     bst.Insert(4);

     bst.InOrder();

     //bst.Delete(4);
     //bst.Delete(14);
     bst.Delete(7);
     bst.InOrder();

    system("pause");
}

 （转载请注明作者和出处 :)  Seven++ http://www.cnblogs.com/sevenPP/  ）