数据结构与算法——红黑树

红黑树与AVL树的比较：

• AVL树的时间复杂度虽然优于红黑树，但是对于现在的计算机，cpu太快，可以忽略性能差异
• 红黑树的插入删除比AVL树更便于控制操作
• 红黑树整体性能略优于AVL树（红黑树旋转情况少于AVL树）

外侧插入与内侧插入

• 1.插入节点位于X的左子节点的左子树——左左
• 2.插入节点位于X的左子节点的右子树——左右
• 3.插入节点位于X的右子节点的左子树——右左
• 4.插入节点位于X的右子节点的右子树——右右
  1、4彼此对称，称为外侧插入，可以采用单旋转操作调整解决
  2、3彼此对称，称为内侧插入，可以采用双旋转操作调整解决

红黑树的性质

红黑树是一棵二叉搜索树，它在每个节点增加了一个存储位记录节点的颜色，可以是RED,也可以是BLACK；
具体性质如下：

• 每个节点颜色不是黑色，就是红色
• 根节点是黑色的
• 如果一个节点是红色，那么它的两个子节点就是黑色的（没有连续的两红节点）
• 对于每个节点，从该节点到其后代叶节点的简单路径上，均包含相同数目的黑色节点（插入新节点必须为红，如果为黑调节成本太大了）

一颗红黑树的最长路径是红黑节点相间的路径；最短路径是只有黑节点的路径，红黑树又满足每个节点到其后叶子节点的路径上包含的黑节点数相同。顾红黑树保证最长路径不超过最短路径的二倍，因而近似平衡。

插入节点

• 如果插入节点的父亲为黑那么直接插入后返回不需要做任何调整
• 如果插入节点的父亲为红，那么就需要调整了.具体的调整过程可以分为三个情况：

情况一：cur红，parent红，pparent黑，uncle存在为红

• 先将parent和uncle节点变黑，pParent节点变为红（保证该子树中每条路径中黑色节点相同并且没有连续的红节点）
• 再让cur等于pParent节点继续往上继续调整

if (uncle&&uncle->_col == RED)
            {
                pparent->_col = RED;
                parent->_col = uncle->_col = BLACK;
                cur = pparent;
                parent = cur->_parent;
            }

情况二：cur红，parent红，pparent黑，uncle为黑/不存在

外侧插入

parent节点为pparent节点的左孩子，cur节点为parent节点的左孩子，进行右单旋，相反进行左单旋

内侧插入

parent节点为pparent节点的左孩子，cur为parent节点的右孩子，parent节点进行左单旋，相反，parent节点做右单旋

if (uncle == NULL || uncle->_col == BLACK)
            {
                //parent在pparent的左，cur在parent的左
                if (pparent->_left == parent)
                {
                    if (parent->_left == cur)
                    {
                        Rotate_R(pparent);
                        parent->_col = BLACK;
                        /*pparent->_col = RED;*/
                    }
                    else if (parent->_right == cur)
                    {
                        Rotate_LR(pparent);
                        cur->_col = BLACK;
                        /*pparent->_col = RED;*/
                    }
                }
                else if (pparent->_right == parent)
                {
                    if (parent->_left == cur)
                    {
                        Rotate_RL(pparent);
                        cur->_col = BLACK;
                        //pparent->_col = RED;
                    }
                    else if (parent->_right == cur)
                    {
                        Rotate_L(pparent);
                        parent->_col = BLACK;
                        //pparent->_col = RED;
                    }
                }
                pparent->_col = RED;
            }
            _root->_col = BLACK;
        }
        return false;
    }

插入代码

bool Insert(const K& key, const V& value)
    {
        //根节点为空
        if (_root == NULL)
        {
            _root = new Node(key,value);
            _root->_color = BLACK;

            return 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 false;
        }
        //插入新节点
        cur = new Node(key, value);
        cur->_color = RED;
        if (parent->_key > key)
        {
            parent->_left = cur;
            cur->_parent = parent;
        }
        else//parent->_key < key
        {
            parent->_right = cur;
            cur->_parent = parent;
        }

        //插入节点后颜色的调整
        while (parent && parent->_color == RED)
        {
            Node* grandfather = parent->_parent;//grandfather颜色一定为黑色
            if (parent == grandfather->_left)
            {
                Node* uncle = grandfather->_right;

                //uncle存在且为红
                if (uncle && uncle->_color == RED)
                {
                    parent->_color = uncle->_color = BLACK;
                    grandfather->_color = RED;

                    cur = grandfather;
                    parent = cur->_parent;
                }
                else//uncle不存在/uncle存在且为黑
                {
                    if (cur == parent->_right)
                    {
                        RotateL(parent);
                        swap(parent, cur);
                    }
                    RotateR(grandfather);
                    parent->_color = BLACK;
                    grandfather->_color = RED;
                }
            }
            else//grandfather->_right==parent
            {
                Node* uncle = grandfather->_left;

                //uncle存在且为红
                if (uncle && uncle->_color == RED)
                {
                    parent->_color = 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;
                }
            }
        }//end while (parent && parent->_color == RED)

        _root->_color = BLACK;

        return true;
    }

参考：

• 红黑树原理及实现
• 浅析红黑树（RBTree）原理及实现