红黑树

最新推荐文章于 2022-03-26 18:15:01 发布
最新推荐文章于 2022-03-26 18:15:01 发布
阅读量335 收藏
点赞数
分类专栏： 树结构 个人总结
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wsnbb123456789/article/details/77895174
版权

参考博文：http://www.cnblogs.com/skywang12345/p/3245399.html

红黑树的5个特性：

(1) 每个节点或者是黑色，或者是红色。
(2) 根节点是黑色。
(3) 每个叶子节点是黑色。
(4) 如果一个节点是红色的，则它的子节点必须是黑色的。
(5) 从一个节点到该节点的子孙节点的所有路径上包含相同数目的黑节点。

此处性质(1)、(2)都比较好理解,(3)所说的叶子节点实际上是空节点,将空接待你看成黑色的。

性质(4)则表示如果一个节点只有一个孩子节点且此节点是红色的，那么他的孩子节点必然只有一个红色节点，

否则会不满足性质(5)，性质5是红黑树最重要的一点，也是保证复杂度平衡的关键，所以每次旋转时都要

保证性质(5)满足。

参考博文中插入和删除都只考虑一边子树的情况，在这里将需要旋转的情况列出：

关于旋转操作请参考：http://blog.csdn.net/wsnbb123456789/article/details/53192406

这里只是列出一部分情况，并不是全部，详细可以看参考博wen。

notice：再次提醒在进行旋转时一定要保证性质(5)是满足的，在删除调整时，删除的是黑节点，

所以要记得所在的子树少了一个黑节点了，已经违反了性质(5)，所以调整考虑这点就可以了。

插入调整(父节点为红色,祖父节点为黑色)：
1、叔叔节点为红色
将父节点和叔叔节点变为黑色,祖父节点变成红色,更改调整节点为祖父节点
2、叔叔节点为黑色
将父节点变成黑色,祖父节点变成红色
(1)、当前节点为父节点的右节点,当前节点变为父节点,对父节点进行左旋
(2)、将父节点变为黑色,祖父节点变为红色,当前节点不变
    当前节点为父节点的左节点,根据父节点是祖父节点左孩子还是右孩子
    进行旋转,如果左孩子向右,右孩子就向左旋转
notice：实际上第2种情况最终会将当前节点和父节点都变成各自父亲的左孩子,
        在进行一次右旋就调整成符合红黑树的结构了


删除调整：
将当前节点看成两种颜色"黑+黑",删除的节点颜色是红色就不需要调整
如果是黑色,则此子树的黑节点少1,所以加到当前节点然后再做相应的调整
设当前节点的兄弟节点为B,父节点为F,则分成以下几种情况：
1、B为红色,F肯定为黑色,将B变为黑色,F变为红色,将B旋转为子树的根节点
    (下面所有情况没有特意讲当前节点变化就是不变的),变成情况2 3
2、B为黑色,如果B的两个儿子节点都为黑色,则直接将B变成红色,当前节点变成F
3、B为黑色,如果B的两个儿子节点不都为黑色,分成两种情况：
    (1)当前节点为F的左节点,在分成以下两种情况：
        1.1 B的左节点为红色,右节点为黑色,则将左节点变成黑色
            B变成红色,然后将左节点旋转为根(即右旋),变成1.2的情况
        1.2 B的右节点为红色,则将右节点变成黑色,B和F的颜色交换,对F进行左旋
            调整结束
    (2)当前节点为F的右节点,在分成以下两种情况：
        2.1 B的左节点为黑色,右节点为红色,将右节点变成黑色
            B变成红色,然后对B进行左旋,变成2.2情况
        2.2 B的左节点为红色,则将左节点变成黑色,B和F颜色交换,对F进行右旋
            调整结束


由于红黑树相对来说代码比较长，容易出错，所以写完最好自己产生随机数据，用set验证正确性，

也可以用http://poj.org/problem?id=3481验证

#include <cstdio>
#include <queue>
using namespace std;
#define RED 0
#define BLACK 1
#define DBUG printf ( "###\n" )
struct RB
{
    int x, color, id;
    struct RB * ch[2], * parent;
};
struct RB * null, * rt;
/*
插入调整(父节点为红色,祖父节点为黑色)：
1、叔叔节点为红色
将父节点和叔叔节点变为黑色,祖父节点变成红色,更改调整节点为祖父节点
2、叔叔节点为黑色
将父节点变成黑色,祖父节点变成红色
(1)、当前节点为父节点的右节点,当前节点变为父节点,对父节点进行左旋
(2)、将父节点变为黑色,祖父节点变为红色,当前节点不变
    当前节点为父节点的左节点,根据父节点是祖父节点左孩子还是右孩子
    进行旋转,如果左孩子向右,右孩子就向左旋转
notice：实际上第2种情况最终会将当前节点和父节点都变成各自父亲的左孩子,
        在进行一次右旋就调整成符合红黑树的结构了
*/
RB * sibling ( RB * T, RB * s )
{
    return T->ch[0] == s ? T->ch[1] : T->ch[0];
}
//0：左旋    1：右旋
void Rotate ( RB * &T, int k )
{
    RB * o = T->ch[k^1];
    o->parent = T->parent;
    if ( T->parent != NULL )
        T->parent->ch[ T->parent->ch[1] == T ] = o;
    T->parent = o;
    if ( o->ch[k] != null )
        o->ch[k]->parent = T;
    T->ch[k^1] = o->ch[k];
    o->ch[k] = T;
    T = o;
    if ( T->parent == NULL )
        rt = T;
}
void insertAdjust ( RB * &tmp )
{
    RB * T = tmp;
    while ( T->parent != NULL && T->parent->color == RED )
    {
        RB * p = sibling ( T->parent->parent, T->parent );
        if ( p->color == RED )
        {
            T->parent->color = p->color = BLACK;
            T->parent->parent->color = RED;
            T = T->parent->parent;
        }
        else
        {
            if ( T == T->parent->ch[1] )
            {
                T = T->parent;
                Rotate ( T, 0 );
                T = T->ch[0];
            }
            else
            {
                T->parent->color = BLACK;
                T->parent->parent->color = RED;
                RB * save = T, * s = T->parent;
                T = T->parent->parent;
                if ( T->ch[0] == s )
                {
                    Rotate ( T, 1 );    //end
                    break ;
                }
                else
                {
                    Rotate ( T, 0 );
                    T = save;           //continue
                }
            }
        }
    }
}
void insert ( RB * &T, int x, int id )
{
    RB * p = T, * q = NULL;
    while ( p != null )
    {
        q = p;
        if ( p->x == x )
            return ;
        if ( p->x > x )
            p = p->ch[0];
        else
            p = p->ch[1];
    }
    RB * o = new RB ( );
    o->x = x;
    o->id = id;
    o->color = RED;
    o->parent = q;
    o->ch[0] = o->ch[1] = null;
    if ( q != NULL )
        q->ch[ q->x <= x ] = o;
    if ( q == NULL )
    {
        T = o;
        return ;
    }
    if ( q->color == BLACK )
        return ;
    insertAdjust ( o );
}
RB * find_del ( RB * &T )
{
    RB * p = T->ch[0];
    while ( p->ch[1] != null )
    {
        p = p->ch[1];
    }
    T->x = p->x;
    return p;
}
/*
删除调整：
将当前节点看成两种颜色"黑+黑",删除的节点颜色是红色就不需要调整
如果是黑色,则此子树的黑节点少1,所以加到当前节点然后再做相应的调整
设当前节点的兄弟节点为B,父节点为F,则分成以下几种情况：
1、B为红色,F肯定为黑色,将B变为黑色,F变为红色,将B旋转为子树的根节点
    (下面所有情况没有特意讲当前节点变化就是不变的),变成情况2 3
2、B为黑色,如果B的两个儿子节点都为黑色,则直接将B变成红色,当前节点变成F
3、B为黑色,如果B的两个儿子节点不都为黑色,分成两种情况：
    (1)当前节点为F的左节点,在分成以下两种情况：
        1.1 B的左节点为红色,右节点为黑色,则将左节点变成黑色
            B变成红色,然后将左节点旋转为根(即右旋),变成1.2的情况
        1.2 B的右节点为红色,则将右节点变成黑色,B和F的颜色交换,对F进行左旋
            调整结束
    (2)当前节点为F的右节点,在分成以下两种情况：
        2.1 B的左节点为黑色,右节点为红色,将右节点变成黑色
            B变成红色,然后对B进行左旋,变成2.2情况
        2.2 B的左节点为红色,则将左节点变成黑色,B和F颜色交换,对F进行右旋
            调整结束
*/
void removeAdjust ( RB * &tmp )
{
    RB * T = tmp;
    while ( T->parent != NULL && T->color != RED )
    {
        RB * B = sibling ( T->parent, T );
        RB * F = T->parent;
        if ( B->color == RED )
        {
            B->color = BLACK;
            F->color = RED;
            RB * save = T;
            T = T->parent;
            Rotate ( T, T->ch[0] == B );
            T = save;
        }
        else
        {
            if ( B->ch[0]->color == BLACK && B->ch[1]->color == BLACK )
            {
                B->color = RED;
                T = T->parent;
            }
            else if ( F->ch[0] == T )
            {
                if ( B->ch[0]->color == RED && B->ch[1]->color == BLACK )
                {
                    B->ch[0]->color = BLACK;
                    B->color = RED;
                    Rotate ( B, 1 );
                }
                else if ( B->ch[1]->color == RED )
                {
                    B->color = F->color;
                    F->color = BLACK;
                    B->ch[1]->color = BLACK;
                    Rotate ( F, 0 );
                    return ;
                }
            }
            else if ( F->ch[1] == T )
            {
                if ( B->ch[0]->color == BLACK && B->ch[1]->color == RED )
                {
                    B->ch[1]->color = BLACK;
                    B->color = RED;
                    Rotate ( B, 0 );
                }
                else if ( B->ch[0]->color == RED )
                {
                    B->color = F->color;
                    F->color = BLACK;
                    B->ch[0]->color = BLACK;
                    Rotate ( F, 1 );
                    return ;
                }
            }
        }
    }
    T->color = BLACK;
}
void remove ( RB * &tmp, int x )
{
    RB * T = tmp;
    while ( T != null )
    {
        if ( T->x == x )
            break ;
        if ( T->x > x )
            T = T->ch[0];
        else
            T = T->ch[1];
    }
    if ( T == null )
        return ;
    RB * p, * q = T->parent;
    if ( T->ch[0] == null && T->ch[1] == null )
    {
        if ( q == NULL )
        {
            rt = null;
            delete T;
            return ;
        }
        else
        {
            p = T;
        }
    }
    else if ( T->ch[0] == null )
    {
        if ( q == NULL )
        {
            rt = T->ch[1];
            T->ch[1]->parent = NULL;
            delete T;
            return ;
        }
        else
        {
            q->ch[ q->ch[1] == T ] = T->ch[1];
            T->ch[1]->parent = q;
            T->ch[1]->color = BLACK;
            delete T;
            return ;
        }
    }
    else if ( T->ch[1] == null )
    {
        if ( q == NULL )
        {
            rt = T->ch[0];
            T->ch[0]->parent = NULL;
            delete T;
            return ;
        }
        else
        {
            q->ch[ q->ch[1] == T ] = T->ch[0];
            T->ch[0]->parent = q;
            T->ch[0]->color = BLACK;
            delete T;
            return ;
        }
    }
    else
    {
        p = find_del ( T );
    }
    RB * F = p->parent;
    if ( p->ch[0] != null && p->ch[0]->color == RED ||
        p->ch[1] != null && p->ch[1]->color == RED )
    {
        if ( p->ch[0] != null )
        {
            p->ch[0]->color = BLACK;
            F->ch[ F->ch[1] == p ] = p->ch[0];
            p->ch[0]->parent = F;
        }
        else if ( p->ch[1] != null )
        {
            p->ch[1]->color = BLACK;
            F->ch[ F->ch[1] == p ] = p->ch[1];
            p->ch[1]->parent = F;
        }
        else
        {
            F->ch[ F->ch[1] == p ] = null;
        }
        delete p;
        return ;
    }
    removeAdjust ( p );
    if ( p->ch[0] != null )
    {
        F->ch[ F->ch[1] == p ] = p->ch[0];
        p->ch[0]->parent = F;
    }
    else if ( p->ch[1] != null )
    {
        F->ch[ F->ch[1] == p ] = p->ch[1];
        p->ch[1]->parent = F;
    }
    else
    {
        F->ch[ F->ch[1] == p ] = null;
    }
    delete p;
}
void print ( RB * T )
{
    queue < RB * > q;
    q.push ( T );
    while ( ! q.empty ( ) )
    {
        RB * p = q.front ( );
        q.pop ( );
        printf ( "%d %s\n", p->x, p->color ? "BLACK" : "RED" );
        if ( p != null )
        {
            q.push ( p->ch[0] );
            q.push ( p->ch[1] );
        }
    }
}
void dfs ( RB * T )
{
    if ( T != null )
    {
        dfs ( T->ch[0] );
        printf ( "%d\n", T->x );
        dfs ( T->ch[1] );
    }
}
void solve ( )
{
    //freopen ( "1.txt", "r", stdin );
    //freopen ( "3.txt", "w", stdout );
    null = new RB ( );
    null->color = BLACK;
    null->x = -1;
    null->parent = NULL;
    null->ch[0] = null->ch[1] = null;
    rt = null;
    int x, id, op, n;
    while ( ~ scanf ( "%d", &op ), op )
    {
        if ( op == 1 )
        {
            scanf ( "%d%d", &id, &x );
            insert ( rt, x, id );
        }
        else if ( op == 2 )
        {
            if ( rt == null )
                printf ( "0\n" );
            else
            {
                RB * p = rt;
                while ( p->ch[1] != null )
                    p = p->ch[1];
                printf ( "%d\n", p->id );
                remove ( rt, p->x );
            }
        }
        else
        {
            if ( rt == null )
                printf ( "0\n" );
            else
            {
                RB * p = rt;
                while ( p->ch[0] != null )
                    p = p->ch[0];
                printf ( "%d\n", p->id );
                remove ( rt, p->x );
            }
        }
        rt->color = BLACK;
        //print ( rt );
    }
}
int main ( )
{
    solve ( );
    return 0;
}

此处实现并不一定正确，可能有些步骤没验证到，请谨慎使用。

随机数据代码（只测试最后结果是否正确）：

#include <bits/stdc++.h>
using namespace std;
const int maxn = 1005;
int a[maxn];
set < int > v;
void solve ( )
{
    //freopen ( "1.txt", "w", stdout );
    srand ( time ( NULL ) );
    int n, pos = 0;
    n = 100005;
    printf ( "%d\n", n );
    while ( n -- )
    {
        //1：表示插入   2：表示删除
        printf ( "%d %d\n", rand ( )%2+1, rand ( )%10005 );
    }
}
int main ( )
{
    solve ( );
    return 0;
}

使用set验证是否正确 

#include <bits/stdc++.h>
using namespace std;
set < int > vis;
int main ( )
{
    int n, op, x;
    //freopen ( "1.txt", "r", stdin );
    //freopen ( "2.txt", "w", stdout );
    scanf ( "%d", &n );
    for ( int i = 0; i < n; i ++ )
    {
        scanf ( "%d%d", &op, &x );
        if ( op == 1 )
        {
            if ( vis.count ( x ) == 0 )
                vis.insert ( x );
        }
        else
        {
            if ( vis.count ( x ) )
                vis.erase ( x );
        }
    }
    for ( set < int > :: iterator it = vis.begin ( ); it != vis.end ( ); it ++ )
        printf ( "%d\n", *it );
    return 0;
}

在此推荐使用WinMerge软件，判断两个输出文件的结果是否相等，那样比较方便的验证自己代码的正确性了。



RookieZQF
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
红黑树详解
09-02
红黑树详解（带目录源码） 本文适合那些有对二叉树有一定的基础，并且熟悉C语言的读者。本文最主要的参考资料是《Introduction to Algorithms 3rd Edition》。
C++复习知识点
Wshichuan的博客
09-07 252
intialization list(初始化列表)-----&gt;只能一次性赋值：当类中含有const、reference成员变量时；有参构造时；基类的构造函数都需要初始化表。 assignment(分配)-----&gt;分配 c语言中的全局变量,分为初始化的（int abc=100），和未初始化的(int abcd). 初始化的全局变量，在程序加载的时候，会从程序文件中，映射（大部分操...
【数据结构】史上最好理解的红黑树讲解，让你彻底搞懂红黑树
热门推荐
小七的博客
01-18 16万+
狂肝半个月的学习笔记，最通俗易懂的红黑树讲解。带你快速掌握红黑树~
C++红黑树
~
03-26 6368
C++红黑树零、前言一、红黑树的概念及性质二、红黑树结点的定义三、红黑树的插入操作1、变色处理2、单旋+变色3、双旋+变色4、插入实现四、红黑树的验证五、红黑树的删除六、红黑树与**AVL**树的比较 零、前言 本章继AVL树后继续讲解学习C++中另一个二叉搜索树–红黑树 一、红黑树的概念及性质 概念： 红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长
红黑树代码
03-30
红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树...
C语言实现红黑树的实例代码
12-25
因为看内核的时候感觉红黑树挺有意思的，所以利用周末的时间来实现一下玩玩。红黑树的操作主要是插入和删除，而删除的时候需要考虑的情况更多一些。具体的操作就不在这里罗嗦了，百度文库里面有一个比较有好的文章，...
红黑树demo python代码
07-12
该资源是一个红黑树的demo程序，包含了红黑树的插入和红黑树的删除过程，实现方式相对比较简单明了，适合于刚刚接触红黑树的入门者阅读。
红黑树生成删除
07-04
红黑树在线生成的一个工具，从网上找的，我这样应该得不到分。大哭https://www.cnblogs.com/bbvi/p/5576201.html 删除可能存在问题，替换节点的兄弟节点为黑色节点时有问题，其他部分是没有问题的，凑合着看看
红黑树java操作代码 红黑树是java里面遍历性能最好数据结构
10-17
经典的红黑树java操作代码。红黑树几乎是java里面遍历性能最好的数据结构了，传上来供大家使用
红黑树原理详解
06-07
红黑树性质: 1. 每个结点或红或黑。 2. 根结点为黑色。 3. 每个叶结点(实际上就是NULL指针)都是黑色的。 4. 如果一个结点是红色的,那么它的周边3个节点都是黑色的。 5. 对于每个结点,从该结点到其所有子孙叶结点的...
红黑树源码
10-12
里面提供了红黑树算法的插入、删除等算法，还有内部的变色，左旋和右旋等算法。另外，里面还提供了冒泡排序、选择排序、插入排序、快速排序等排序算法
红黑树的使用详解
09-05
本篇文章是对红黑树的使用详解。需要的朋友参考下
红黑树添加1111111
09-29
红黑树添加
红黑树算法C语言实现
03-02
实验1：实现红黑树的基本算法， 对n的取值分别为 12、24、36、48、60，随机生成n 个互异的正整数（K1, K2, K3, ……, Kn）作为节点的关键字，向一棵初始空的红黑树中依次插入这n 个节点，统计算法运行所需时间 ，画...
红黑树Java实现
06-25
红黑树java实现，代码能实现，详细。
红黑树简单实现
07-06
主要实现有普通树的生成、查询方法，与继承于普通树的二叉树、红黑树的实现。
解析红黑树（ppt文档）.ppt
03-01
解析红黑树（ppt文档）.ppt
红黑树 delphi
最新发布
12-19
红黑树是一种自平衡二叉查找树，它能够保持在插入或删除操作后依然保持相对平衡的状态，因此在很多情况下能够保证较低的时间复杂度。在 Delphi 中，我们可以通过使用现有的红黑树实现来实现相关的功能。 在 Delphi ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值