透彻了解红黑树之三

最新推荐文章于 2022-05-26 09:41:55 发布
最新推荐文章于 2022-05-26 09:41:55 发布
阅读量2.2k 收藏
点赞数
分类专栏： 数据结构 文章标签： search insert null 代码分析 测试 工作
  
//一、左旋代码分析   
/*----------------------------------------------------------- 
|   node           right 
|   / /    ==>     / / 
|   a  right     node  y 
|       / /       / /     
|       b  y     a   b    //左旋 
-----------------------------------------------------------*/  
static rb_node_t* rb_rotate_left(rb_node_t* node, rb_node_t* root)  
{  
    rb_node_t* right = node->right;    //指定指针指向 right<--node->right   
   
    if ((node->right = right->left))    
    {  
        right->left->parent = node;  //好比上面的注释图，node成为b的父母   
    }  
    right->left = node;   //node成为right的左孩子   
   
    if ((right->parent = node->parent))  
    {  
        if (node == node->parent->right)  
        {  
            node->parent->right = right;  
        }  
        else  
        {  
            node->parent->left = right;  
        }  
    }  
    else  
    {  
        root = right;  
    }  
    node->parent = right;  //right成为node的父母   
   
    return root;  
}  
  
  
//二、右旋   
/*----------------------------------------------------------- 
|       node            left 
|       / /             / / 
|    left  y   ==>    a    node 
|   / /                    / / 
|  a   b                  b   y  //右旋与左旋差不多，分析略过 
-----------------------------------------------------------*/  
static rb_node_t* rb_rotate_right(rb_node_t* node, rb_node_t* root)  
{  
    rb_node_t* left = node->left;  
   
    if ((node->left = left->right))  
    {  
        left->right->parent = node;  
    }  
    left->right = node;  
   
    if ((left->parent = node->parent))  
    {  
        if (node == node->parent->right)  
        {  
            node->parent->right = left;  
        }  
        else  
        {  
            node->parent->left = left;  
        }  
    }  
    else  
    {  
        root = left;  
    }  
    node->parent = left;  
   
    return root;  
}  
  
  
//三、红黑树查找结点   
//----------------------------------------------------   
//rb_search_auxiliary：查找   
//rb_node_t* rb_search：返回找到的结点   
//----------------------------------------------------   
static rb_node_t* rb_search_auxiliary(key_t key, rb_node_t* root, rb_node_t** save)  
{  
    rb_node_t *node = root, *parent = NULL;  
    int ret;  
   
    while (node)  
    {  
        parent = node;  
        ret = node->key - key;  
        if (0 < ret)  
        {  
            node = node->left;  
        }  
        else if (0 > ret)  
        {  
            node = node->right;  
        }  
        else  
        {  
            return node;  
        }  
    }  
   
    if (save)  
    {  
        *save = parent;  
    }  
   
    return NULL;  
}  
  
//返回上述rb_search_auxiliary查找结果   
rb_node_t* rb_search(key_t key, rb_node_t* root)  
{  
    return rb_search_auxiliary(key, root, NULL);  
}  
  
  
//四、红黑树的插入   
//---------------------------------------------------------   
//红黑树的插入结点   
rb_node_t* rb_insert(key_t key, data_t data, rb_node_t* root)  
{  
    rb_node_t *parent = NULL, *node;  
   
    parent = NULL;  
    if ((node = rb_search_auxiliary(key, root, &parent)))  //调用rb_search_auxiliary找到插入结   
  
点的地方  
    {  
        return root;  
    }  
   
    node = rb_new_node(key, data);  //分配结点   
    node->parent = parent;     
    node->left = node->right = NULL;  
    node->color = RED;  
   
    if (parent)  
    {  
        if (parent->key > key)  
        {  
            parent->left = node;  
        }  
        else  
        {  
            parent->right = node;  
        }  
    }  
    else  
    {  
        root = node;  
    }  
   
    return rb_insert_rebalance(node, root);   //插入结点后，调用rb_insert_rebalance修复红黑树   
  
的性质  
}  
  
  
//五、红黑树的3种插入情况   
//接下来，咱们重点分析针对红黑树插入的3种情况，而进行的修复工作。   
//--------------------------------------------------------------   
//红黑树修复插入的3种情况   
//为了在下面的注释中表示方便，也为了让下述代码与我的倆篇文章相对应，   
//用z表示当前结点，p[z]表示父母、p[p[z]]表示祖父、y表示叔叔。   
//--------------------------------------------------------------   
static rb_node_t* rb_insert_rebalance(rb_node_t *node, rb_node_t *root)  
{  
    rb_node_t *parent, *gparent, *uncle, *tmp;  //父母p[z]、祖父p[p[z]]、叔叔y、临时结点*tmp   
   
    while ((parent = node->parent) && parent->color == RED)  
    {     //parent 为node的父母，且当父母的颜色为红时   
        gparent = parent->parent;   //gparent为祖父   
    
        if (parent == gparent->left)  //当祖父的左孩子即为父母时。   
                                 //其实上述几行语句，无非就是理顺孩子、父母、祖父的关系。:D。   
        {  
            uncle = gparent->right;  //定义叔叔的概念，叔叔y就是父母的右孩子。   
  
            if (uncle && uncle->color == RED) //情况1：z的叔叔y是红色的   
            {  
                uncle->color = BLACK;   //将叔叔结点y着为黑色   
                parent->color = BLACK;  //z的父母p[z]也着为黑色。解决z，p[z]都是红色的问题。   
                gparent->color = RED;    
                node = gparent;     //将祖父当做新增结点z，指针z上移俩层，且着为红色。   
    //上述情况1中，只考虑了z作为父母的右孩子的情况。   
            }  
            else                     //情况2：z的叔叔y是黑色的，   
            {     
                if (parent->right == node)  //且z为右孩子   
                {  
                    root = rb_rotate_left(parent, root); //左旋[结点z，与父母结点]   
                    tmp = parent;  
                    parent = node;  
                    node = tmp;     //parent与node 互换角色   
                }  
                             //情况3：z的叔叔y是黑色的，此时z成为了左孩子。   
                                    //注意，1：情况3是由上述情况2变化而来的。   
                                    //......2：z的叔叔总是黑色的，否则就是情况1了。   
                parent->color = BLACK;   //z的父母p[z]着为黑色   
                gparent->color = RED;    //原祖父结点着为红色   
                root = rb_rotate_right(gparent, root); //右旋[结点z，与祖父结点]   
            }  
        }   
   
        else   
        {       
   //这部分是特别为情况1中，z作为左孩子情况，而写的。   
            uncle = gparent->left;  //祖父的左孩子作为叔叔结点。[原理还是与上部分一样的]   
            if (uncle && uncle->color == RED)  //情况1：z的叔叔y是红色的   
            {  
                uncle->color = BLACK;  
                parent->color = BLACK;  
                gparent->color = RED;  
                node = gparent;           //同上。   
            }  
            else                               //情况2：z的叔叔y是黑色的，   
            {  
                if (parent->left == node)  //且z为左孩子   
                {  
                    root = rb_rotate_right(parent, root);  //以结点parent、root右旋   
                    tmp = parent;  
                    parent = node;  
                    node = tmp;       //parent与node 互换角色   
                }   
                  //经过情况2的变化，成为了情况3.   
                parent->color = BLACK;  
                gparent->color = RED;  
                root = rb_rotate_left(gparent, root);   //以结点gparent和root左旋   
            }  
        }  
    }  
   
    root->color = BLACK; //根结点，不论怎样，都得置为黑色。   
    return root;      //返回根结点。   
}  
  
  
//六、红黑树的删除   
//------------------------------------------------------------   
//红黑树的删除结点   
rb_node_t* rb_erase(key_t key, rb_node_t *root)  
{  
    rb_node_t *child, *parent, *old, *left, *node;  
    color_t color;  
   
    if (!(node = rb_search_auxiliary(key, root, NULL)))  //调用rb_search_auxiliary查找要删除的   
  
结点  
    {  
        printf("key %d is not exist!/n");  
        return root;  
    }  
   
    old = node;  
   
    if (node->left && node->right)  
    {  
        node = node->right;  
        while ((left = node->left) != NULL)  
        {  
            node = left;  
        }  
        child = node->right;  
        parent = node->parent;  
        color = node->color;  
    
        if (child)  
        {  
            child->parent = parent;  
        }  
        if (parent)  
        {  
            if (parent->left == node)  
            {  
                parent->left = child;  
            }  
            else  
            {  
                parent->right = child;  
            }  
        }  
        else  
        {  
            root = child;  
        }  
    
        if (node->parent == old)  
        {  
            parent = node;  
        }  
    
        node->parent = old->parent;  
        node->color = old->color;  
        node->right = old->right;  
        node->left = old->left;  
    
        if (old->parent)  
        {  
            if (old->parent->left == old)  
            {  
                old->parent->left = node;  
            }  
            else  
            {  
                old->parent->right = node;  
            }  
        }   
        else  
        {  
            root = node;  
        }  
    
        old->left->parent = node;  
        if (old->right)  
        {  
            old->right->parent = node;  
        }  
    }  
    else  
    {  
        if (!node->left)  
        {  
            child = node->right;  
        }  
        else if (!node->right)  
        {  
            child = node->left;  
        }  
        parent = node->parent;  
        color = node->color;  
    
        if (child)  
        {  
            child->parent = parent;  
        }  
        if (parent)  
        {  
            if (parent->left == node)  
            {  
                parent->left = child;  
            }  
            else  
            {  
                parent->right = child;  
            }  
        }  
        else  
        {  
            root = child;  
        }  
    }  
   
    free(old);  
   
    if (color == BLACK)  
    {  
        root = rb_erase_rebalance(child, parent, root); //调用rb_erase_rebalance来恢复红黑树性   
  
质  
    }  
   
    return root;  
}  
  
  
//七、红黑树的4种删除情况   
//----------------------------------------------------------------   
//红黑树修复删除的4种情况   
//为了表示下述注释的方便，也为了让下述代码与我的倆篇文章相对应，   
//x表示要删除的结点，*other、w表示兄弟结点，   
//----------------------------------------------------------------   
static rb_node_t* rb_erase_rebalance(rb_node_t *node, rb_node_t *parent, rb_node_t *root)  
{  
    rb_node_t *other, *o_left, *o_right;   //x的兄弟*other，兄弟左孩子*o_left,*o_right   
   
    while ((!node || node->color == BLACK) && node != root)   
    {  
        if (parent->left == node)  
        {  
            other = parent->right;  
            if (other->color == RED)   //情况1：x的兄弟w是红色的   
            {  
                other->color = BLACK;    
                parent->color = RED;   //上俩行，改变颜色，w->黑、p[x]->红。   
                root = rb_rotate_left(parent, root);  //再对p[x]做一次左旋   
                other = parent->right;  //x的新兄弟new w 是旋转之前w的某个孩子。其实就是左旋后   
  
的效果。  
            }  
            if ((!other->left || other->left->color == BLACK) &&  
                (!other->right || other->right->color == BLACK))    
                          //情况2：x的兄弟w是黑色，且w的俩个孩子也   
  
都是黑色的  
  
            {                         //由于w和w的俩个孩子都是黑色的，则在x和w上得去掉一黑色，   
                other->color = RED;   //于是，兄弟w变为红色。   
                node = parent;    //p[x]为新结点x   
                parent = node->parent;  //x<-p[x]   
            }  
            else                       //情况3：x的兄弟w是黑色的，   
            {                          //且，w的左孩子是红色，右孩子为黑色。   
                if (!other->right || other->right->color == BLACK)  
                {  
                    if ((o_left = other->left))   //w和其左孩子left[w]，颜色交换。   
                    {  
                        o_left->color = BLACK;    //w的左孩子变为由黑->红色   
                    }   
                    other->color = RED;           //w由黑->红   
                    root = rb_rotate_right(other, root);  //再对w进行右旋，从而红黑性质恢复。   
                    other = parent->right;        //变化后的，父结点的右孩子，作为新的兄弟结点   
  
w。  
                }  
                            //情况4：x的兄弟w是黑色的   
      
                other->color = parent->color;  //把兄弟节点染成当前节点父节点的颜色。   
                parent->color = BLACK;  //把当前节点父节点染成黑色   
                if (other->right)      //且w的右孩子是红   
                {  
                    other->right->color = BLACK;  //兄弟节点w右孩子染成黑色   
                }  
                root = rb_rotate_left(parent, root);  //并再做一次左旋   
                node = root;   //并把x置为根。   
                break;  
            }  
        }  
  //下述情况与上述情况，原理一致。分析略。   
        else  
        {  
            other = parent->left;  
            if (other->color == RED)  
            {  
                other->color = BLACK;  
                parent->color = RED;  
                root = rb_rotate_right(parent, root);  
                other = parent->left;  
            }  
            if ((!other->left || other->left->color == BLACK) &&  
                (!other->right || other->right->color == BLACK))  
            {  
                other->color = RED;  
                node = parent;  
                parent = node->parent;  
            }  
            else  
            {  
                if (!other->left || other->left->color == BLACK)  
                {  
                    if ((o_right = other->right))  
                    {  
                        o_right->color = BLACK;  
                    }  
                    other->color = RED;  
                    root = rb_rotate_left(other, root);  
                    other = parent->left;  
                }  
                other->color = parent->color;  
                parent->color = BLACK;  
                if (other->left)  
                {  
                    other->left->color = BLACK;  
                }  
                root = rb_rotate_right(parent, root);  
                node = root;  
                break;  
            }  
        }  
    }  
   
    if (node)  
    {  
        node->color = BLACK;  //最后将node[上述步骤置为了根结点]，改为黑色。   
    }    
    return root;  //返回root   
}  
  
  
//八、测试用例   
//主函数   
int main()  
{  
    int i, count = 100;  
    key_t key;  
    rb_node_t* root = NULL, *node = NULL;  
      
    srand(time(NULL));  
    for (i = 1; i < count; ++i)  
    {  
        key = rand() % count;  
        if ((root = rb_insert(key, i, root)))  
        {  
            printf("[i = %d] insert key %d success!/n", i, key);  
        }  
        else  
        {  
            printf("[i = %d] insert key %d error!/n", i, key);  
            exit(-1);  
        }  
    
        if ((node = rb_search(key, root)))  
        {  
            printf("[i = %d] search key %d success!/n", i, key);  
        }  
        else  
        {  
            printf("[i = %d] search key %d error!/n", i, key);  
            exit(-1);  
        }  
        if (!(i % 10))  
        {  
            if ((root = rb_erase(key, root)))  
            {  
                printf("[i = %d] erase key %d success/n", i, key);  
            }  
            else  
            {  
                printf("[i = %d] erase key %d error/n", i, key);  
            }  
        }  
    }  
   
    return 0;  
}

liuzhanchen1987
关注
专栏目录
《STL源码剖析》之RB-tree
iFuMI的博客
07-25 752
AVL树之外，另一个被广泛运用的平衡二叉搜索树是RB-tree。所谓红黑树，不仅是一个二叉搜索树，它还满足以下性质： 性质1. 每个节点是红色或黑色； 性质2. 根是黑色； 性质3. 每个红色节点的两个子节点都是黑色。(从每个叶子到根的所有路径上不能有两个连续的红色节点) 性质4. 从任一节点到NULL（树尾端）的任何路径都包含相同数目的黑色节点。
STL源码剖析---红黑树原理详解上
tempsitegoogle
07-12 596
一、红黑树概述 红黑树和我们以前学过的AVL树类似，都是在进行插入和删除操作时通过特定操作保持二叉查找树的平衡，从而获得较高的查找性能。不过自从红黑树出来后，AVL树就被放到了博物馆里，据说是红黑树有更好的效率，更高的统计性能。这一点在我们了解了红黑树的实现原理后，就会有更加深切的体会。 红黑树和AVL树的区别在于它使用颜色来标识结点的高度，它所追求的是局部平衡而不是AVL树中的非常严格的...
STL源码剖析---红黑树原理详解下
tempsitegoogle
07-18 398
算法导论书上给出的红黑树的性质如下，跟STL源码剖析书上面的4条性质大同小异。 1、每个结点或是红色的，或是黑色的 2、根节点是黑色的 3、每个叶结点（NIL）是黑色的 4、如果一个节点是红色的，则它的两个儿子都是黑色的。 5、对于每个结点，从该结点到其子孙结点的所有路径上包含相同数目的黑色结点。 从红黑树上删除一个节点，可以先用普通二叉搜索树的方法，将节点从红黑树上删除掉，...
STL源码剖析 关联式容器 红黑树
CHYabc123456hh的博客
11-24 1096
概念 红黑树不仅仅是一个二叉树，必须满足如下条件 1，每个节点不是红色就是黑色 (深色底纹为黑色，浅色底纹为红色) 2，根节点是黑色的 3，如果节点为红，其子节点必须为黑色的 4，任一节点至NULL(树的尾端)的任何路径，所含的黑节点的数量必须相同 插入节点 分别插入 3 8 35 75 ，他们均破坏了红黑树的规则，需要调整树形，两种方式(修改颜色 或 旋转) 产生不平衡的状态，即高度相差1以上。这没关系，因为RB-Tree是一种弱平衡性，他是按照颜色进行高度的限定，保证在弱平衡..
STL源码分析之红黑树
sydney__的博客
01-08 173
主要分析一下STL里的红黑树，红黑树相对来说是一种较为复杂的数据结构，具体的学习方法建议看那种带有很多图解的博客，先理解其原理流程，再自己写下代码，其实就能理解了。STL里红黑树的实现有几个特点，一个它设置了一个空头结点header，它的左节点指向树最小元素，有节点指向树最大元素，实际带有有意义值的头结点为root,root的父节点为header.这使在一些插入删除操作时要讨论下特殊情况，附上代码...
杨过-教你透彻了解红黑树1
08-03
红黑树的插入操作类似于二叉查找树，但插入后需要根据红黑树的性质进行调整，可能涉及旋转和重新着色。首先，我们按照二叉查找树的方式找到插入位置，然后插入新节点并检查是否违反红黑树的性质。如果违反，通过旋转...
面试之必掌握知识点：红黑树（一）
weixin_44465920的博客
01-28 2782
面试之必掌握知识点：红黑树（一） 现如今，国内大厂的面试是卷之又卷，像红黑树这种高级平衡树算法也经常会在面试中被问起，很多同学对红黑树一直保持一知半解的状态，为了能在面试中脱颖而出，今天我们一起来梳理一遍红黑树的完整知识链，相信读完这篇文章，你一定可以更加透彻的了解红黑树的“前世今生”！ 1. 二叉查找树 在开始聊红黑树之前,我想先聊一聊二叉查找树(Binary Search Tree)。它是红黑树演变的基础，二叉树的定义也非常简单： 二叉查找树（英語：Binary Search Tree），也称为二叉查
红黑树的c实现源码与教程
01-03
教你透彻了解红黑树： http://blog.csdn.net/v_JULY_v/archive/2010/12/29/6105630.aspx 红黑树算法的层层剖析与逐步实现 http://blog.csdn.net/v_JULY_v/archive/2010/12/31/6109153.aspx Ok，君自看。 ----------...
《算法导论》实验六：红黑树插入算法（C++）——控制台树型显示
allin_allin的恋爱小屋
12-15 3471
我们知道一颗高度为h的二叉搜索树，可以支持任何一种基本动态集合操作，且其时间复杂度均为O(h)。因此，二叉搜索树的性能与树的高度密切相关，如果树的高度较高时，这些集合操作可能并不比在链表上执行得快。所以让树中的元素尽量地平衡在树的两侧，使得树的高度尽量地低，便可提高二叉搜索树的性能。而红黑树（red-black- tree）是许多“平衡的”查找树中的一种，可以保证在最坏情况下基本动态集合。
STL源码剖析
06-22
侯捷 STL源码剖析：一本剖析下面内容的书籍：vector、list、heap、deque、red black tree、hash table、set、map等等
STL源码剖析之红黑树【2013.12.05】
木心[ mx1024 ] 欢迎
12-05 1230
STL源码剖析之红黑树【2013.12.04】 欢迎加入我们的QQ群，无论你是否工作，学生，只要有c / vc / c++ 编程经验，就来吧！158427611  【红黑树】 红黑树是一种受限制的搜索树，其限制如下： .
C++ STL源码剖析之红黑树
希望我的博客，能帮上你解决学习中工作中所遇到的问题
05-26 474
C++ STL源码剖析之红黑树导语红黑树节点基类红黑树节点红黑树迭代器红黑树操作红黑树插入旋转过程插入总结使用 导语 在STL源码中有两段话，简单翻译后如下： STL中Red-black tree（红黑树）class,用来当做SLT关系式容器（如set,multiset,map, multimap）.里面所用的insertion和deletion方法以 《Introduction to Algorithms》一书为基础,但是有以下两点不同: (1)header不仅指向root,也指向红黑树的最左节点,以便用
STL源码之红黑树
学习AI算法，请关注微信公众号：机器学习算法全栈工程师……
12-16 1005
1. 基本概念       红黑树是平衡二叉搜索树的一种，其通过特定的操作来保持二叉查找树的平衡。首先，我们来复习一下二叉查找树的知识，建议如果对二叉查找树不理解的先去搜一下相关博客来了解一下。二叉搜索树是指一个空树或者具有以下性质的二叉树： 任意节点的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 任意节点的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 任意节点的左、右子树也
STL源码—红黑树
xietingcandice的专栏
11-17 583
红黑树的性质： 每个节点或是红色的，或是黑色的。根节点是黑色的。每个叶节点（NULL）是黑色的。如果一个节点是红色的，则它的两个孩子节点都是黑色的。对每个节点，从该节点到其所有后代叶节点的简单路径上，均包含相同数目的黑色节点。
STL源码剖析 之 红黑树 - 1
rsy56640的博客
03-22 176
做了一点微小的工作。 github链接： https://github.com/rsy56640/rsy_little_lib/tree/master/library_for_algorithm/RB_Tree/RB_Tree_1 本来想按照自己的风格写的，但是还是学习一下type_traits，Alloc等玩意吧。。 感觉就是把SGI-STL-2.91.57临摹了一遍， 不过有个地方很...
STL源码剖析-RBTree
weixin_37549298的博客
05-05 295
关联式容器 根据“数据在容器中的排列”特性，容器可分为序列式和关联式容器两种。标准的STL关联式容器可分为set(集合)和map(映射表）。这些容器的底层机制均以RB-tree完成，RB-tree也是一个独立容器，但并不对外开放。 此外,SGI STL还提供了一个不在标准规格之列的关联式容器：hash table(散列表)以及hash table为底层机制完成的hash_set（散列集合）、has...
stl源码剖析_C++ STL源码剖析之红黑树
weixin_39777163的博客
11-28 214
C++ STL源码剖析之红黑树0.导语大家好我是光城，欢迎关注公众号：guangcity。在STL源码中有两段话，简单翻译后如下：STL中Red-black tree（红黑树）class,用来当做SLT关系式容器（如set,multiset,map, multimap）.里面所用的insertion和deletion方法以 《Introduction to Algorithms》一书为基础,但是有...
教你透彻了解红黑树
prochsh的专栏
12-17 486
教你透彻了解红黑树   作者：July、saturnman   2010年12月29日 本文参考：Google、算法导论、STL源码剖析、计算机程序设计艺术。 推荐阅读：Left-Leaning Red-Black Trees, Dagstuhl Workshop on Data Structures, Wadern, Germany, February,
深入解析红黑树数据结构
"教你透彻了解红黑树" 红黑树是一种自平衡的二叉查找树，它的设计目标是在保持查找效率的同时，通过特定的规则保证树的平衡，从而优化插入和删除操作的时间复杂度。红黑树的名字来源于其节点颜色属性，每个节点可以...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值