红黑树的简单实现-RBTree

红黑树是一个被广泛运用的平衡二叉树，同时满足以下规则
1.每个节点不是红色就是黑色
2.根节点为黑
3.不存在连续红节点
4.每条路径上黑色节点数相等，（空节点视为黑色）
这样一来，红黑树可以保持最长路径不超过最短路径的两倍，保持近似平衡，搜索时间复杂度是O(lgN)

下面是红黑树调节节点平衡与颜色的简介，当插入节点后出现连续红节点后，判断叔叔是否存在和叔叔的颜色，
若是叔叔存在且颜色为红时

叔叔不存在 或者 叔叔存在且颜色为黑时，如下图调整，四种情况四种旋转

下面是实现代码：

#include <iostream>
using namespace std;


enum Color
{
    RED,
    BLACK
};
template <class T>
struct RBTreeNode
{
    RBTreeNode<T>* _left;
    RBTreeNode<T>* _right;
    RBTreeNode<T>* _parent;
    Color _color;
    T _key;

    RBTreeNode(T key)
        :_left(NULL),
        _right(NULL),
        _parent(NULL),
        _color(RED),
        _key(key)
    {}
};

template <class T>
class RBTree
{
    typedef RBTreeNode<T> Node;
public:
    RBTree()
        :_root(NULL)
    {}
    void RotateR(Node* parent)
    {
        Node* subL = parent->_left;
        Node* PParent = parent->_parent;
        Node* subLR = subL->_right;

        parent->_left = subLR;
        subL->_right = parent;
        parent->_parent = subL;
        if (subLR)
        {
            subLR->_parent = parent;
        }
        if (PParent==NULL)
        {
            _root = subL;
            subL->_parent = NULL;
        }
        else if (PParent->_key > parent->_key)
        {
            subL->_parent = PParent;
            PParent->_left = subL;
        }
        else if (PParent->_key < parent->_key)
        {
            subL->_parent = PParent;
            PParent->_right = subL;
        }

    }
    void RotateL(Node* parent)
    {
        Node* PParent = parent->_parent;
        Node* subR = parent->_right;
        Node* subRL = subR->_left;

        parent->_right = subRL;
        subR->_left = parent;
        parent->_parent = subR;
        if (subRL)
        {
            subRL->_parent = parent;
        }
        if (PParent == NULL)
        {
            _root = subR;
            subR->_parent = NULL;
        }
        else if (PParent->_key > parent->_key)
        {
            subR->_parent = PParent;
            PParent->_left = subR;
        }
        else if (PParent->_key < parent->_key)
        {
            subR->_parent = PParent;
            PParent->_right = subR;
        }

    }
    bool Insert(const T& key)
    {
        if (_root == NULL)//空树直接插入
        {
            _root = new Node(key);
            _root->_color = BLACK;
            return true;
        }
        Node* cur = _root;//非空 从根节点开始 向下找位置
        Node* parent = NULL;
        while (cur)
        {
            if (key == cur->_key)
            {
                return false;
            }
            else if (key < cur->_key)
            {
                parent = cur;
                cur = cur->_left;
            }
            else if (key>cur->_key)
            {
                parent = cur;
                cur = cur->_right;
            }
        }

        cur = new Node(key);
        cur->_parent = parent;

        if (parent->_key > key)
        {
            parent->_left = cur;
        }
        else if (parent->_key < key)
        {
            parent->_right = cur;
        }

        //调节节点颜色
        while (parent&&parent->_color == RED)
        {
            Node* PParent = parent->_parent;
            if (PParent->_left == parent)//父亲是祖父的左
            {
                Node* uncle = PParent->_right;
                if (uncle&&uncle->_color == RED)//叔叔为红
                {
                    parent->_color = uncle->_color = BLACK;
                    PParent->_color = RED;
                    cur = PParent;
                    parent = cur->_parent;
                }
                else//叔叔不存在  或者叔叔为黑
                {
                    if (cur == parent->_left)
                    {
                        //右单旋
                        RotateR(PParent);
                        PParent->_color = RED;//祖父变红
                        parent->_color = BLACK;//父亲变黑
                    }
                    else//左右双旋
                    {
                        RotateL(parent);
                        RotateR(PParent);
                        PParent->_color = RED;//祖父 变红
                        cur->_color = BLACK;//当前节点变黑
                    }
                }
            }
            else if (PParent->_right == parent)//父亲是祖父的右
            {
                Node* uncle = PParent->_left;
                if (uncle&&uncle->_color == RED)//叔叔为红
                {
                    parent->_color = uncle->_color = BLACK;
                    PParent->_color = RED;
                    cur = PParent;
                    parent = cur->_parent;
                }
                else//叔叔不存在  或者叔叔为黑
                {
                    if (cur == parent->_right)//cur为父亲的右 左单旋
                    {
                        RotateL(PParent);//左单旋
                        parent->_color = BLACK;//父亲变红
                        PParent->_color = RED;//祖父变黑
                    }
                    else
                    {
                        //右左双旋
                        RotateR(parent);
                        RotateL(PParent);
                        cur->_color = BLACK;
                        PParent->_color = RED;
                    }
                }
            }_root->_color = BLACK;

        }return true;

    }

    void Printf()
    {
        _printf(_root);
    }
    void _printf(Node*& root)
    {
        if (root == NULL)
            return;
        _printf(root->_left);
        printf("%d  ",root->_key);
        _printf(root->_right);
    }
protected:
    Node* _root;
};


int main()
{
    int a[] = {3,2,4,5,7,9,8,0,12,13,15};
    /*int a[] = { 10,5,3 };*/
    /*int a[] = { 10,5,8 };*/
    /*int a[] = { 3,5,10 };*/
    /*int a[] = { 3,10,5};*/
    RBTree<int> t;
    for (int i = 0; i < sizeof(a) / sizeof(a[0]); i++)
        t.Insert(a[i]);
    t.Printf();
    system("pause");
    return 0;
}

结果如下

如有不足 ，请不吝赐教