红黑树的算法实现

在搜索树的大家族里，红黑树算是用途最广泛的一个代表了。在我们使用的C++STL库中，set、map都是以它作为底层去实现的。当然在一些其他的地方，比如Java集合中的TreeSet和TreeMap，还有Linux虚拟内存的管理，也是通过红黑树去实现的。所以，今天我们来分析一下红黑树是怎样实现的。

红黑树是一棵二叉搜索树，它在每个节点上增加了一个存储位来表示节点的颜色，可以是Red或Black。通过对任何一条从根到叶子简单 路径上的颜色来约束，红黑树保证最长路径不超过最短路径的两倍，因而近似于平衡。

所以我们就把满足下面性质的二叉搜索树称为红黑树：

1. 每个节点不是红色就是黑色
2. 根节点是黑色的
3. 如果有一个节点是红的，那么它的子节点一定是黑的（不存在连续的红节点）
4. 每条路径下存在相同数目的黑节点
5. 每个叶子（NIL）节点是黑色的（这是的叶子节点指的是为（NIL/NULL）的叶子结点）

1.插入

红黑树的插入情况是比较多的，最开始创建一个红黑树，它的根节点一定是黑，插入的第二个节点为了满足黑色节点数目相同的性质，肯定是红的，以此类推，当节点较多时我们可以将插入情况分为以下几类：

第一种：祖父节点是黑的，父亲和叔叔节点是红的，现在我们插入一个cur红节点（方框节点可存在，可不存在）

分析：这个时候，这棵红黑树已经不满足性质“不存在连续红节点”，所以这个时候需要对树进行调整。这种情况我们可以直接将父亲和叔叔节点的颜色进行改变为黑色，改变后又满足了红黑树的性质。

第二种：祖父节点是黑的，父亲节点是红的，叔叔节点不存在或者是黑色的，此时cur红节点（方框节点可存在，可不存在）

分析：同理，这种情况也不满足黑色节点数量相同这一性质。这个时候简单的改变颜色肯定不能解决问题，在这种情况下往往是因为cur子节点的调整，引起上面节点也需要调整。所以这个时候，我们需要对这棵树进行旋转。

第三种：祖父节点是黑的，父亲节点是红的，叔叔节点不存在或者是黑色的，此时cur红节点是父亲的右孩子（方框节点可存在，可不存在）

分析：现在对树做调整，可能情况会比较复杂，如果我们把cur节点变成父亲的左孩子，那剩下的问题就和第二种情况一样了。所以我们对父亲子树进行右旋即可。

    pair<Node*, bool> Insert(const K& key, const V& value)
    {
        if (_root == NULL)
        {
            _root = new Node(key, value);
            _root->_color = BLACK;
            return make_pair(_root, true);

        }

        Node* parent = NULL;
        Node* cur = _root;
        while (cur)
        {
            if (cur->_key < key)
            {
                parent = cur;
                cur = cur->_right;
            }

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

            else
                return make_pair(cur,false);

        }

        cur = new Node(key, value);
        if (parent->_key > key)
            parent->_left = cur;
        else
            parent->_right = cur;
        cur->_parent = parent;

        while (parent && parent->_color == RED)
        {
            Node* grandfather = parent->_parent;      //1.判断父亲和叔叔的关系
            if (parent == grandfather->_left)       //父亲在左，叔叔在右
            {
                Node* uncle = grandfather->_right;    //2.判断叔叔的情况
                if (uncle != NULL && uncle->_color == RED)    //a.叔叔存在且为红 -> 变色
                {
                    parent->_color = BLACK;
                    uncle->_color = BLACK;
                    grandfather->_color = RED;
                    cur = grandfather;
                    parent = cur->_parent;
                }

                else   //b.叔叔不存在或者叔叔为黑
                {
                    if (cur == parent->_right)  
                    {
                        RotateL(parent);
                        swap(cur, parent);
                    }

                    RotateR(grandfather);
                    parent->_color = BLACK;
                    grandfather->_color = RED;
                    break;
                }
            }


            else       //叔叔在左，父亲在右
            {
                Node* uncle = grandfather->_left;
                if (uncle && uncle->_color == RED)    //叔叔存在且为红 ，变色
                {
                    parent->_color = BLACK;
                    uncle->_color = BLACK;
                    grandfather->_color = RED;
                    cur = grandfather;
                    parent = cur->_parent;
                }

                else    //叔叔不存在或为黑
                {
                    if (cur == parent->_left)
                    {
                        RotateR(parent);
                        swap(cur, parent);
                    }

                    RotateL(grandfather);
                    parent->_color = BLACK;
                    grandfather->_color = RED;
                    break;
                }
            }

        }
        _root->_color = BLACK;
        return make_pair(_root, true);
    }

总结：关于红黑树的插入，我们是从插入的节点开始，依次向上调整，直到这棵树的节点符合红黑树的性质。

2.红黑树的左右旋

对于左右旋这个概念，其实在学习查找树这一个系列的时候并不陌生，很多时候树的插入问题，我们都会用到这个方法来使它达到一种平衡。
对红黑树也是如此。首先，我们借助一个动画来看看右旋是怎么个旋法。

根据这个动画再去实现，就比较容易了。代码实现如下。

void RotateR(Node* parent)    //右旋
    {
        assert(parent);
        Node* child = parent->_left;
        Node* grandfather = parent->_parent;
        Node* Rchild = child->_right;

        if (Rchild)
            Rchild->_parent =parent ;
        parent->_left = Rchild;
        parent->_parent = child;
        child->_right = parent;

        if (grandfather == NULL)
        {
            child->_parent = NULL;
            _root = child;
        }

        else
        {
            if (grandfather->_left == parent)
                grandfather->_left = child;

            else
                grandfather->_right = child;

            child->_parent = grandfather;
        }
    }

同理，左旋的实现也可以借助动画来理解。

void RotateL(Node* parent)   //左旋
    {
        assert(parent);
        Node* child = parent->_right;
        Node* Lchild = child->_left;
        Node* grandfather = parent->_parent;
        if (Lchild)
            Lchild->_parent = parent;
        parent->_right = Lchild;
        parent->_parent = child;
        child->_left = parent;

        if (grandfather == NULL)
        {
            _root = child;
            child->_parent = NULL;
        }

        else
        {
            if (parent == grandfather->_left)
                grandfather->_left = child;
            else
                grandfather->_right = child;

            child->_parent = grandfather;
        }
    }

总结：在查找树中，合理的使用左右旋会使整个问题化繁为简。

3.如何判断当前的红黑树是红黑树

在我们完成插入算法后，这个时候就有了一个新问题，我们如何判断一棵树是不是没有问题的红黑树？要解决这个问题，就得从红黑树的性质入手了。

1. 如果根节点是红的，肯定不是红黑树；
2. 如果有连续的红节点，肯定不是红黑树；
3. 如果黑色节点的路径长度不一样，肯定不是红黑树。

这三条性质就够我们去判断一个树是不是红黑树了。第一二条性质比好判断，如何实现第三个？这时候我们就需要去任意路径count一次黑色节点的路径长度，然后再用这个长度和每一条路径的长度进行比较，只要有一条路径不一样，那就可以直接得出这不是一颗红黑树了。直到判断到每一条路径的叶子节点后，它都相等，那么此时这个性质就满足了。

bool IsBalance()
    {
        if (_root == NULL) return true;
        if (_root->_color == RED) return false;

        int BlackNum = 0;    //统计一条路径的黑色节点数量
        Node* left = _root;
        while (left)
        {
            if (left->_color == BLACK)
                BlackNum++;
            left = left->_left;
        }

        int count = 0;
        return _IsBalance(_root,BlackNum,count);
    }
bool _IsBalance(Node* root, const int BlackNum, int count)
    {
        if (root == NULL)  return true;
        if (root->_color == RED && root->_parent->_color == RED)
        {
            cout << "存在连续红节点" << endl;
            return false;
        }

        if (root->_color == BLACK)
            ++count;

        if (root->_left == NULL && root->_right == NULL)
        {
            if (count != BlackNum)
            {
                cout << "黑节点数目不同" << endl;
                return false;
            }

            else
                return true;
        }
        return _IsBalance(root->_left, BlackNum, count) && _IsBalance(root->_right, BlackNum, count);
    }

其实，相对比其他查找树，红黑树的查找时间复杂度一直控制在 O(lgn)，这就要求它一直处于近似平衡状态。也正是因为这一点，红黑树是一种非常高效的平衡查找树，所以在很多语言的内部都会或多或少使用它来作为底层实现。