RB-tree 红黑树

除AVL树外，还有RBtree也是经常用到的平衡二叉搜索树
RBtree必须满足以下四条规则：
1.每个节点不是红色就是黑色
2.根节点为黑色
3.如果一个节点是红色，则它的 子节点是黑色的（即没有连续的红节点）
4.任一节点至NULL（树尾端）的任何路径，所含黑节点数必须相同
那AVL和RBtree有什么区别
AVltree 是严格平衡的二叉搜索树，其复杂度接近lgN，旋转多，维护起来麻烦，但是更加直观
RBree 是近似平衡的二叉搜索树，其复杂度一定小于2*（LgN）,但是曾有人做过大量试验证明，红黑树的效率仍能达到lgN,旋转则较少，维护起来简单，今后项目什么的一定会优先RBtree，其比较抽象
插入操作
注意：cur为当前节点 P为父节点 g为祖父节点 u为父亲的兄弟节点即叔叔节点
状况1：该树为空树，直接插入根结点的位置，违反性质1，把节点颜色有红改为黑即可。
状况2：插入节点N的父节点P为黑色，不违反任何性质，无需做任何修改。
接下来是真正需要调整的状况了
状况3：当cur为红，P为红，g为黑，u存在且为红
先将p，u变为黑色，g改成红，然后把cur给g，继续向上搜索

状况4： cur为红，P为红，g为黑，u不存在/u为黑（cur为p的左节点）

状态5：cur为红，P为红，g为黑，u不存在/u为黑（cur为p的右节点）
p为g的左孩子，cur为p的右孩子，则针对p做左单旋转；相反，p为g的右孩子，cur为p的左孩子，则针对p做右单旋转，则转换成了情况2

删除操作
状况1：cur的兄弟b是红色的。

情况2：cur的兄弟b是黑色的，且cur的俩个孩子都是黑色的。
b变为红色后经过b节点的路径的黑节点数目也减少了1，那个从P出发到其叶子节点到所有路径所包含的黑节点数目相等了。但是这个数目比之前少了1，因为左右子树中的黑节点数目都减少了。P是他父节点g的一个孩子，那么由g到其叶子节点的黑节点数目就不相等了，所以说没有结束，需把P当做新的起始点开始向上检索。

情形3：P为红（S一定为黑），S的孩子们都为黑。

情形4：P任意色，b为黑，cur是P的左孩子，b的右孩子bR为红，b的左孩子任意（或者是cur是P的右孩子，b的左孩子为红，b的右孩子任意）。
P、b旋转有变色，等于给cur这边加了一个黑节点，P位置（是位置而不是P）的颜色不变，b这边少了一个黑节点；bR有红变黑，b这边又增加了一个黑节点；这样一来又恢复了平衡

情形5：P任意色，b为黑，cur是P的左孩子，b的左孩子bL为红，b的右孩子bR为黑（或者cur是P的右孩子，b的右孩子为红，b的左孩子为黑）。
这如果你按情形4的操作的话，由于bR本来就是黑色，无法弥补由于P、b的变换（旋转）给b这边造成的损失！所以没先对b、SL进行变换之后就变为情形4的情况了

#pragma once
#include<stdio.h>
#include<iostream>

using namespace std;
enum Color
{
    RED,
    BLACK,
};

template<class K, class V>
struct RBTreeNode
{
    RBTreeNode<K, V>* _left;
    RBTreeNode<K, V>* _right;
    RBTreeNode<K, V>* _parent;

    K _key;
    V _value;
    Color _col;

    RBTreeNode(const K& key, const V& value)
        :_left(NULL)
        , _right(NULL)
        , _parent(NULL)
        , _key(key)
        , _value(value)
        , _col(RED)
    {}
};

template<class K,class V>
class RBTree
{
    typedef RBTreeNode<K,V> Node;
public:
    RBTree()
        :_root(NULL)
    {}

    bool Insert(const K& key,const V& value)
    {
        if (_root == NULL)
        {
            _root = new Node(key,value);
            _root->_col = BLACK;

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

            }
            else
            {
                return false;
            }
        }
        //找到插入位置
        cur = new Node(key, value);
        if (parent->_key < key)
        {
            parent->_right = cur;
            cur->_parent = parent;
        }
        else
        {
            parent->_left = cur;
            cur->_parent = parent;
        }
        while (parent&&parent->_col == RED)
        {
            Node* grandparent = parent->_parent;
            if (parent == grandparent->_left)
            {
                Node* uncle = grandparent->_right;
                if (uncle&&uncle->_col == RED)
                {
                    parent->_col = BLACK;
                    uncle->_col = BLACK;
                    grandparent->_col = RED;
                    cur = grandparent;
                    parent = cur->_parent;
                }
                else //uncle不存在，或uncle为黑色
                {
                    if (cur == parent->_right)
                    {
                        RotateL(parent);
                        swap(parent,cur);
                    }

                    RotateR(grandparent);
                    parent->_col = BLACK;
                    grandparent->_col = RED;

                    break;
                }
            }
            else//parent == grandparent->_right
            {
                Node* uncle = grandparent->_left;
                if (uncle&&uncle->_col == RED)
                {
                    parent->_col = BLACK;
                    uncle->_col = BLACK;
                    grandparent->_col = RED;

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

                    RotateL(grandparent);
                    parent->_col = BLACK;
                    grandparent->_col = RED;

                    break;
                }

            }
        }

        _root->_col = BLACK;

        return true;
    }

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

        parent->_right = subRL;

        if (subRL)
        {
            subRL->_parent = parent;

        }
        subR->_left = parent;
        Node* parentparent = parent->_parent;
        parent->_parent = subR;
        if (parentparent==NULL)
        {
            _root = subR;
        }
        else
        {
            if (parent == parentparent->_left)
            {
                parentparent->_left = subR;
                subR->_parent = parentparent;
            }
            else
            {
                parentparent->_right = subR;
                subR->_parent = parentparent;
            }
        }

    }
    void RotateR(Node* parent)
    {
        Node* subL = parent->_left;
        Node* subLR = subL->_right;

        parent->_left = subLR;

        if (subLR)
        {
            subLR->_parent = parent;
        }
        subL->_right = parent;
        Node* parentparent = parent->_parent;
        parent->_parent = subL;

        if (parentparent == NULL)
        {
            _root = subL;
            _root->_parent = NULL;
        }
        else
        {
            if (parent == parentparent->_left)
            {
                parentparent->_left = subL;
                subL->_parent = parentparent;
            }
            else
            {
                parentparent->_right = subL;
                subL->_parent = parentparent;
            }
        }
    }
    void InOrder()
    {
        _InOrder(_root);
        cout << endl;
    }

    void _InOrder(Node* root)
    {
        if (root == NULL)
            return;

        _InOrder(root->_left);
        cout<<root->_key<<" ";
        _InOrder(root->_right);
    }

    bool IsBalance()
    {
        if (_root == NULL)
        {
            return true;
        }

        if (_root&&_root->_col==RED)
        {
            return false;
        }

        int BlackNum = 0;
        Node* left = _root;
        while (left)
        {
            if (left->_col == BLACK)
            {
                ++BlackNum;
            }
            left = left->_left;
        }
        int num = 0;
        return _IsBalance(_root, num, BlackNum);

    }
    bool _IsBalance(Node* root, int num, const int blackNum)
    {
        if (root == NULL)
        {
            return true;
        }
        if (root->_col == RED&&root->_parent->_col == RED)
        {
            cout<<"存在连续的红节点"<<root->_key<<endl;
            return false;
        }
        if (root->_col == BLACK)
        {
            ++num;
        }
        // num 是根节点到当前节点黑色节点的数量
        if (root->_left == NULL && root->_right == NULL)
        {
            if (num != blackNum)
            {
                //cout<<"黑色节点的数量不相等"<<root->_key<<endl;
                return false;
            }
            else
            {
                return true;
            }
        }

        return _IsBalance(root->_left, num, blackNum)
            && _IsBalance(root->_right, num, blackNum);
    }

private:
    Node* _root;
};

void TestRBTree()
{
        RBTree<int, int> t;
        int a[] = {16, 3, 7, 11, 9, 26, 18, 14, 15};
        //int a[] = {4, 2, 6, 1, 3, 5, 15, 7, 16, 14};
        for (size_t i = 0; i < sizeof(a)/sizeof(a[0]); ++i)
        {
            t.Insert(a[i], i);

        }

        t.InOrder();
        cout<<"IsBalance?"<<t.IsBalance()<<endl;
}