红黑树

#include "MyRBTree.h"
#include <iostream>



MyRBTree::MyRBTree()
{
    root_ = nullptr;
}


MyRBTree::~MyRBTree()
{
}


void MyRBTree::PrePrint(RBTNode *tree)
{
    if (tree == nullptr)
        return;
    PrePrint(tree->lchild);

    auto tmp = (tree->color == COLOR::RED) ? "RED" : "BLACK         ";
    std::cout << tmp << "___:" << tree->value << "\n";

    PrePrint(tree->rchild);
}

void MyRBTree::MidPrint(RBTNode *tree)
{
    if (tree == nullptr)
        return;
    auto tmp = (tree->color == COLOR::RED) ? "RED" : "BLACK         ";
    std::cout << tmp << "___:" << tree->value<<"\n";
    MidPrint(tree->lchild);
    MidPrint(tree->rchild);
}


RBTNode* MyRBTree::Search(RBTNode *tree, int value)
{
    //没有找到
    if (tree == nullptr)
        return nullptr;

    if (tree->value == value)
        return tree;

    if (tree->value >= value)
        return Search(tree->lchild, value);
    else
        return Search(tree->rchild, value);
}


RBTNode *MyRBTree::FindForwardNode(RBTNode *tree)
{
    while (tree->rchild != nullptr)
    {
        tree = tree->rchild;
    }
    return tree;
}

void MyRBTree::Del(int value)
{
    //第一步，找到节点
    auto node = Search(root_,value);
    if (node == nullptr)
        return;
    
    bool left_side_unbalance = true;//当前节点的左(右)子树缺少一个黑节点
    RBTNode *backward_node = nullptr;
    if (node->lchild != nullptr) {
        backward_node = FindForwardNode(node->lchild);//真正的前驱,没有右节点
    }
    else
        backward_node = node;//原始node，没有左节点

    //交换后继节点和当前节点value
    {
        auto tmp = node->value;
        node->value = backward_node->value;
        backward_node->value = tmp;
    }

    //开始删除后继节点，只有一个或者没有子树
    {
        bool is_red = backward_node->color == COLOR::RED;
        auto parent = backward_node->parent;

        //如果backward_node为根节点
        if (parent == nullptr)
        {
            if (backward_node->lchild != nullptr)
            {
                backward_node->lchild->parent = nullptr;
                backward_node->lchild->color = COLOR::BLACK;
                delete backward_node;
                root_ = backward_node->lchild;
            }
            else if (backward_node->rchild != nullptr)
            {
                backward_node->rchild->parent = nullptr;
                backward_node->rchild->color = COLOR::BLACK;
                delete backward_node;
                root_ = backward_node->rchild;
            }

            return;
        }

        if (parent->lchild == backward_node)        {
            left_side_unbalance = true;
        }
        else {
            left_side_unbalance = false;
        }

        //不存在两个子节点都存在的情况
        if (backward_node->lchild != nullptr)
        {
            if (left_side_unbalance) {
                parent->lchild = backward_node->lchild;
            }
            else {
                parent->rchild = backward_node->lchild;
            }
            backward_node->lchild->parent = parent;
        }
        else if (backward_node->rchild != nullptr)
        {
            if (left_side_unbalance) {
                parent->lchild = backward_node->rchild;
            }
            else {
                parent->rchild = backward_node->rchild;
            }
            backward_node->rchild->parent = parent;
        }
        else if (backward_node->lchild == nullptr
            &&
            backward_node->rchild == nullptr
            )
        {
            if (left_side_unbalance)
                parent->lchild = nullptr;
            else
                parent->rchild = nullptr;
        }

        delete backward_node;
        //后继节点重新指向
        backward_node = parent;

        //如果删除的节点为红色的，不影响红黑树属性，完成删除
        if (is_red)
            return;
    }
    
    
    DelBalance(backward_node, left_side_unbalance);

}


void MyRBTree::DelBalance(RBTNode *forward_parent, bool left_side_unbalance)
{
    auto parent = forward_parent;

    //如果backward_node为根节点
    if (parent == nullptr)
    {
        root_ = forward_parent;
        return;
    }

    //讨论backward_node的左子树少了一个黑节点的情况
    if (left_side_unbalance)
    {
        //node 节点到这里已经必须是黑色的
        auto uncle = parent->rchild;
        auto u_l = uncle->lchild;
        auto u_r = uncle->rchild;

        auto color_parent = parent->color;
        auto color_uncle_parent = uncle==nullptr? COLOR::BLACK:uncle->color;
        auto color_u_l_parent = u_l == nullptr ? COLOR::BLACK : u_l->color;
        auto color_u_r_parent = u_r == nullptr ? COLOR::BLACK : u_r->color;

        //情况1：全黑
        if (color_parent == COLOR::BLACK
            &&color_uncle_parent == COLOR::BLACK
            &&color_u_l_parent == COLOR::BLACK
            &&color_u_r_parent == COLOR::BLACK
            )
        {
            uncle->color = COLOR::BLACK;
            return DelBalance(parent);//递归parent，整颗parent树少了一个黑节点
        }

        //情况2：P红 其他黑
        if (color_parent == COLOR::RED
            &&color_uncle_parent == COLOR::BLACK
            &&color_u_l_parent == COLOR::BLACK
            &&color_u_r_parent == COLOR::BLACK
            )
        {
            uncle->color = COLOR::RED;
            parent->color = COLOR::BLACK;
            return;//搞定
        }

        //情况3：U红 其他黑
        if (color_parent == COLOR::BLACK
            &&color_uncle_parent == COLOR::RED
            &&color_u_l_parent == COLOR::BLACK
            &&color_u_r_parent == COLOR::BLACK
            )
        {
            uncle->color = COLOR::BLACK;
            parent->color = COLOR::RED;
            L_Rotate(parent);
            return DelBalance(parent,true);//递归当前节点
        }

        //情况4：UL红 P无所谓 其他黑
        if (color_uncle_parent == COLOR::BLACK
            &&color_u_l_parent == COLOR::RED
            &&color_u_r_parent == COLOR::BLACK
            ) {
            uncle->color = COLOR::RED;
            u_l->color = COLOR::BLACK;
            R_Rotate(uncle);
            return DelBalance(parent);//递归当前节点
        }

        //情况5：UR红 P\UL无所谓 U黑
        if (color_uncle_parent == COLOR::BLACK
            &&color_u_r_parent == COLOR::RED
            )
        {
            uncle->color = parent->color;
            parent->color = COLOR::BLACK;
            u_r->color = COLOR::BLACK;
            L_Rotate(parent);
            return;
        }
    }
}

void MyRBTree::Insert(int value)
{
    RBTNode *node = new RBTNode();
    node->value = value;
    //根节点 直接插入
    if (root_ == nullptr)    {
        root_ = node;
        root_->color = COLOR::BLACK;//跟节点颜色默认为黑
        return;
    }
    else {
        InsertNode(root_, root_,node);

        Balance(node);
    }


}



void MyRBTree::InsertNode(RBTNode*&tree, RBTNode*parent, RBTNode*node)
{
    do {
        if (tree == nullptr)
        {
            tree = node;
            node->parent = parent;
            break;
        }
        //插入到左子树
        if (tree->value >= node->value) {
            InsertNode(tree->lchild, tree, node);
            break;
        }
        //插入到右子树
        if (tree->value < node->value) {
            InsertNode(tree->rchild, tree,node);
            break;
        }
    } while (0);
    
}


void MyRBTree::Balance(RBTNode *&node)
{    
    auto parent = node->parent;

    if (parent == nullptr)
    {
        //说明node已经是根节点,直接黑化
        node->color = COLOR::BLACK;
        root_ = node;
        return;
    }
    if (parent->parent == nullptr)
    {
        //说明node->parent已经是根节点,直接黑化
        node->parent->color = COLOR::BLACK;
        root_ = node->parent;
        return;
    }

    //前面两步确保node含有父节点、祖父节点


    if (node->parent->color == COLOR::BLACK)
    {
        //父节点颜色为黑 无需调整
        return;
    }
    else if (node->parent->color == COLOR::RED)
    {
        //父节点为红，继续讨论
        bool node_is_L_Child = false; //当前节点是父节点的左节点
        bool parent_L_Child = false; //父节点为祖父节点的左孩子
        auto parent = node->parent;
        auto grand_pa = node->parent->parent;
        RBTNode*uncle = nullptr;
        if (parent == grand_pa->lchild) {
            uncle = grand_pa->rchild;
            parent_L_Child = true;
        }
        else {
            uncle = grand_pa->lchild;
            parent_L_Child = false;
        }             

        if (node == parent->lchild)
            node_is_L_Child = true;
        else
            node_is_L_Child = false;

        //最简单的情况
        //第0种情况:叔叔为红，那祖父肯定是黑
        if (uncle != nullptr && uncle->color == COLOR::RED)
        {
            //策略：父节点和叔节点变黑，祖父变红，祖父作为当前节点，递归此函数
            parent->color = COLOR::BLACK;
            uncle->color = COLOR::BLACK;
            grand_pa->color = COLOR::RED;
            Balance(grand_pa);
            return;
        }

        //以下情况，叔叔节点必须为黑，G点为黑，P点为红，N点也为红.

        //<型：P点作为G点的左孩子，N点作为右孩子
        //策略：以P为当前节点，左旋
        if (!node_is_L_Child && parent_L_Child)
        {
            L_Rotate(parent);
            return Balance(parent);
        }

        //>型：P点作为G点的右孩子，N点作为左孩子
        //策略：以P为当前节点，右旋
        if (node_is_L_Child && !parent_L_Child)
        {
            R_Rotate(parent);
            return Balance(parent);
        }

        //   /型：P点作为G点的左孩子，N点作为左孩子
        //策略：祖父节点为当前节点，祖父节点变红，父节点变黑. 祖父节点右旋
        if (node_is_L_Child && parent_L_Child)
        {
            parent->color = COLOR::BLACK;
            grand_pa->color = COLOR::RED;
            R_Rotate(grand_pa);
            return Balance(grand_pa);
        }

        //  \型：P点作为G点的右孩子，N点作为右孩子
        //策略：祖父节点为当前节点，祖父节点变红，父节点变黑. 祖父节点左旋
        if (!node_is_L_Child && !parent_L_Child)
        {
            parent->color = COLOR::BLACK;
            grand_pa->color = COLOR::RED;
            L_Rotate(grand_pa);

            return Balance(grand_pa);
        }
    }
    else
    {
        std::cout << "\nerror";
    }
}


RBTNode* MyRBTree::L_Rotate(RBTNode*node) {

    RBTNode* parent = node->parent;
    RBTNode * r_child = node->rchild;

    if (parent == nullptr)
    {
    }
    else if (parent->lchild == node)
    {
        parent->lchild = r_child;
    }
    else if (parent->rchild == node)
    {
        parent->rchild = r_child;
    }

    r_child->parent = parent;

    if (r_child->lchild != nullptr)
    {
        r_child->lchild->parent = node;
    }
    node->rchild = r_child->lchild;

    r_child->lchild = node;
    node->parent = r_child;

    return node;
}

//对node作右旋
RBTNode* MyRBTree::R_Rotate(RBTNode*node) {

    RBTNode* parent = node->parent;
    RBTNode * l_child = node->lchild;

    if (parent == nullptr)
    {
    }
    else if (parent->lchild == node)
    {
        parent->lchild = l_child;
    }
    else if (parent->rchild == node)
    {
        parent->rchild = l_child;
    }

    l_child->parent = parent;

    if (l_child->rchild != nullptr)
    {
        l_child->rchild->parent = node;
    }
    node->lchild = l_child->rchild;

    l_child->rchild = node;
    node->parent = l_child;

    return node;
}

 

 

首先了解红黑树特性：

1. 根节点必须为黑
2. 节点不是红就是黑
3. 叶子结点必须是黑，也就是nil，其实无所谓
4. 两个红不能互为父子节点
5. 每条从根节点到叶子结点的路径包含的黑节点数目，都是相同的（插入的算法决定的）

插入节点的步骤：

1. 插入节点首先上色为红色，因为红色好调整
2. 按二叉排序树找到插入位置后，开始调整

插入的调整：

 

情形1：

父节点与叔节点都为红，由此推断祖父必须为黑，只需要将祖父变红，父亲和叔叔变黑即可，以祖父节点为当前节点递归

 

情形2，默认父节点为红，叔节点为黑或者为nil：

2.1：当前节点作为左子树，父节点作为右子树，也就是>型

处理方法：父节点右旋，变成 \ 型

2.2：当前节点作为右子树，父节点作为左子树，也就是<型

处理方法：父节点左旋，变成 / 型

2.3：当前节点作为右子树，父节点作为右子树，也就是 \ 型

处理方法：祖父节点左旋，祖父变红，父亲变黑。

2.4：当前节点作为左子树，父节点作为左子树，也就是 / 型

处理方法：祖父节点右旋，祖父变红，父亲变黑。

 

总结：

<型和>型，都只是中间状态，将其转化成 \ /型，再对祖父节点操作，插入完毕。

红黑树与AVL的性能对比：

查找 AVL占优

插入和删除 红黑树占优

因为红黑树保证插入每次都能在三次以内完成，减少了复杂度。

而红黑树的深度，由其特性可知，两棵树的深度之差，不会太多，因为黑节点数目相同，红色节点不能相邻，因此要是该树的黑色路径长度为N，最长的路径也不会超过2N。

 

 

红黑树的删除:

步骤一：删除的节点X分两种情况

1. 删除节点只有或者没有子节点，这就是需要讨论的重点
2. 删除节点有两个子节点，这种情况与二叉平衡树的删除一样，先找到删除节点的后继或者前驱节点Y，交换X和Y的值，从而问题变成删除Y节点，转化成第一点讨论的情况
3. 如果X节点颜色为红，经过前面1.2两点，这里讨论的N节点最多只有一个子节点，只需将N节点的子节点N顶替上来，红黑树性质不变
4. 如果X节点颜色为黑，就是步骤二讨论的内容

步骤二：删除的关键在于理解下面这张图，有以下几点需要注意：

1. N节点为删除节点X的子节点，N替换了X原来的位置。由于步骤一已经将问题简化成，被删除节点只有或者没有子节点，所以X节点只有N一个子节点，如果X没有子节点，N为NIL节点，颜色默认为黑色
2. P为N的父节点，S为N的兄弟节点。经过P点的两条路径，PN&PS。PN路径由于删除了X节点这个黑节点（这里X节点经过步骤一，必须为黑），所以PN和PS两条路径已经不平衡
3. PN为少了一个黑节点的路径，称之为短路径，另外一条称之为兄弟路径。后面只讨论短路径位于左侧这种情况。（短路径位于右侧的情况，可以通过反转操作，也就是，左旋换成右旋，右旋变成左旋）

步骤三：现在情况简化为只讨论上图，讨论的范围包括P,S,SL,SR四个节点的颜色情况，需要分为几种情况

 

情况1：

P红，其他均为黑

策略1：

PS换色（P黑化，S红化）

结果1：恢复平衡

短路径增加一个黑节点，兄弟路径不变。

 

情况2：

S红，其他均为黑

策略2：

PS换色&P左旋

 结果2：

短路径依旧存在，但转化成情况1，所以再进行一次换色，问题解决

 

情况3：

全黑

策略3：

S变红

结果3：

经过P节点的两条路径现在都少了一个黑节点，所以当前节点从N转化成了P，接着继续递归分析P。

 

情况4：

SL红（因此S黑），SR黑，P无所谓

策略4：

S与SL换色，S右旋

结果4：

PN依旧为短路径，但是转化为情况5

 

情况5：

SR红（因此S黑），SL无所谓，P无所谓

策略5：

S变成P的颜色

P黑化

SR黑化

P左旋

结果5：恢复平衡

 

总结：上述情况看似不好记忆，但可以推理出来，下面是帮助记忆的方法。

重点在于五个节点：N  P  S  SL  SR，N的颜色必须为黑，因此就只有四个节点的颜色需要讨论

前面三种比较好记忆，要么全黑，要么除了P，其他全黑，要么除了S，其他全黑。

剩下的是SL或者SR为红的情况，称之为复杂情况

第一种复杂情况，SL为红，SR为黑，那么由于红黑树特性，S必须为黑。剩下P点无所谓

第二种复杂情况，SR为红，SL无所谓，S必须为黑，剩下P点无所谓

 

第一种复杂情况需要转化为第二种，因此旋转和变色的策略很好推导

第二种复杂情况，可以根据PN短路径需要增加一个黑节点，而SL和SR这两条路径需要和原来保持一致的黑色数，变色和旋转也是很好推导的

 

 

下面的图是上面几种情况的可视化总结 

 

 

 

附上参考网络

https://segmentfault.com/a/1190000012728513