手撕红黑树--增删改查

最新推荐文章于 2023-01-24 16:28:26 发布
最新推荐文章于 2023-01-24 16:28:26 发布
阅读量323 收藏 2
点赞数
文章标签： 算法 数据结构 指针 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44081296/article/details/108418744
版权

手撕红黑树--增删改查


这里默认大家都知道红黑树的基本概念了，重点讲如何用代码实现（用的是c语言）
打卡机实战应用红黑树：
链接: https://github.com/furyParrot/ClockMachine_RBTree.

1节点定义

typedef struct Node
{
    int keyvalue;       //键值，一棵树中每个key都是唯一的，用来比较
    int Red1Black0;     //红黑，0黑 1红
    Content * cont;     //节点内容
    struct Node * lson; //指向左儿子的指针
    struct Node * rson; //指向右儿子的指针
    struct Node * dad;  //指向父节点的指针
} Node;

2增加节点

函数：int AddNode(Node* root, Node* newnode)
root：插入寻找的出发节点
newnode：需要插入的新节点

是
否
newnode的key大
有
无
黑色
红色
红色
黑色
是
否
newnode的key大
有
无
首个节点?
直接将newnode内容赋值给根节点
进行key比较
root是否有右子
将root->rson作为根节点递归插入newnode
root是黑色还是红色
直接插入
叔叔颜色
爸爸叔叔爷爷同时变色,爷爷作为新节点递归插入祖父
爸爸和我同向
同向旋转操作并变色-见下文
折拐旋转为同向-详见下文
root是否有左子
将root->lson作为根节点递归插入newnode

同向旋转操作并变色
1：左左：先旋转，然后root 以及 root->dad变色
在这里插入图片描述

2：右右：先旋转，然后root 以及 root->dad变色
在这里插入图片描述

不同向转为同向：
1左右–>变为同向情况并递归
在这里插入图片描述
2右左–>变为同向情况并递归
在这里插入图片描述

代码：

int AddNode(Node* root, Node* newnode) {
    //是首个节点
    if (root->keyvalue == 0) {
        //将值赋值给根节点。
        root->keyvalue = newnode->keyvalue;
        ContCpy(root->cont, newnode->cont);
        //free(newnode);
    }
    //不是
    else {
        if (newnode->keyvalue == root->keyvalue) {
            root->cont = newnode->cont;
        }
        else if (newnode->keyvalue > root->keyvalue) { //要往右边插

            if (root->rson != NULL) {//有右儿子的时候
                AddNode(root->rson, newnode);
            }
            else {//没右儿子的时候

                if (root->Red1Black0 == 0) { //爸是黑色，直接插入
                    root->rson = newnode;
                    newnode->dad = root;
                }
                else {  //爸是红色
                    int dadRight1Left0 = (root->dad->rson == NULL) ? 0 : ((root->keyvalue == root->dad->rson->keyvalue) ? 1 : 0);


                    if (((dadRight1Left0 == 1) && (root->dad->lson != NULL) && (root->dad->lson->Red1Black0 == 1)) ||
                        ((dadRight1Left0 == 0) && (root->dad->rson != NULL) && (root->dad->rson->Red1Black0 == 1))) {//叔叔是红色
                            //爸爸叔叔爷爷同时变色
                        root->Red1Black0 = 0;
                        if (dadRight1Left0 == 1) {
                            if (root->dad->lson != NULL)
                                root->dad->lson->Red1Black0 = 0;
                        }
                        else {
                            if (root->dad->rson != NULL)
                                root->dad->rson->Red1Black0 = 0;
                        }
                        root->dad->Red1Black0 = 1;
                        //将newnode插入
                        root->rson = newnode;
                        newnode->dad = root;
                        //爷爷变色，需要将爷爷插入祖父，如果没有祖父，就直接给爷爷变色
                        if (root->dad->dad == NULL) {
                            root->dad->Red1Black0 = 0;
                        }
                        else {
                            int ppRight1Left0 = (root->dad->dad->rson == NULL) ? 0 : ((root->dad->keyvalue == root->dad->dad->rson->keyvalue) ? 1 : 0);
                            if (ppRight1Left0 == 1) {
                                root->dad->dad->rson = NULL;
                                //root->dad->dad = NULL;
                            }
                            AddNode(root->dad->dad, root->dad);
                        }
                    }
                    else {//叔叔是黑色
                        if (dadRight1Left0 == 1) {//爸爸是爷爷的右儿子，和我同向：

                            Node* newpapa = CreatRBTree();
                            newpapa->keyvalue = root->dad->keyvalue;
                            ContCpy(newpapa->cont, root->dad->cont);

                            if (root->dad->lson != NULL) root->dad->lson->dad = newpapa;
                            newpapa->lson = root->dad->lson;

                            if (root->lson != NULL) root->lson->dad = newpapa;
                            newpapa->rson = root->lson;

                            root->dad->lson = newpapa;
                            newpapa->dad = root->dad;

                            root->dad->rson = newnode;
                            newnode->dad = root->dad;

                            root->dad->Red1Black0 = 0;
                            newpapa->Red1Black0 = 1;


                            root->dad->keyvalue = root->keyvalue;
                            ContCpy(root->dad->cont, root->cont);
                            //free(root);

                        }
                        else {//爸爸是爷爷的左儿子，和我反向：需要旋转操作
                            root->rson = newnode->lson;
                            if (newnode->lson != NULL) newnode->lson->dad = root;
                            newnode->lson = NULL;
                            root->dad->lson = newnode;
                            newnode->dad = root->dad;
                            root->dad = NULL;
                            AddNode(newnode, root);
                        }
                    }
                }
            }
        }
        else { //要往左边插
            if (root->lson != NULL) {//有左儿子的时候
                AddNode(root->lson, newnode);
            }
            else {//没左儿子的时候
                if (root->Red1Black0 == 0) { //爸是黑色，直接插入
                    root->lson = newnode;
                    newnode->dad = root;
                }
                else {  //爸是红色
                    int dadRight1Left0 = (root->dad->rson == NULL) ? 0 : ((root->keyvalue == root->dad->rson->keyvalue) ? 1 : 0);

                    if (((dadRight1Left0 == 1) && (root->dad->lson != NULL) && (root->dad->lson->Red1Black0 == 1)) ||
                        ((dadRight1Left0 == 0) && (root->dad->rson != NULL) && (root->dad->rson->Red1Black0 == 1))) { //叔叔是红色
                            //爸爸叔叔爷爷同时变色
                        root->Red1Black0 = 0;
                        if (dadRight1Left0 == 1) {
                            if (root->dad->lson != NULL)
                                root->dad->lson->Red1Black0 = 0;
                        }
                        else {
                            if (root->dad->rson != NULL)
                                root->dad->rson->Red1Black0 = 0;
                        }
                        root->dad->Red1Black0 = 1;
                        //将newnode插入
                        root->lson = newnode;
                        newnode->dad = root;
                        //爷爷变色，需要将爷爷插入祖父，如果没有祖父，就直接给爷爷变色
                        if (root->dad->dad == NULL) {
                            root->dad->Red1Black0 = 0;
                        }
                        else {
                            int ppRight1Left0 = (root->dad->dad->rson == NULL) ? 0 : ((root->dad->keyvalue == root->dad->dad->rson->keyvalue) ? 1 : 0);
                            if (ppRight1Left0 == 1) {
                                root->dad->dad->rson = NULL;
                                //root->dad->dad = NULL;
                            }
                            AddNode(root->dad->dad, root->dad);
                        }
                    }
                    else {//叔叔是黑色
                        if (dadRight1Left0 == 0) {//爸爸是爷爷的左儿子，和我同向：

                            Node* newpapa = CreatRBTree();
                            newpapa->keyvalue = root->dad->keyvalue;
                            ContCpy(newpapa->cont, root->dad->cont);
                            

                            if (root->dad->rson != NULL) root->dad->rson->dad = newpapa;
                            newpapa->rson = root->dad->rson;

                            if (root->rson != NULL) root->rson->dad = newpapa;
                            newpapa->lson = root->rson;

                            root->dad->rson = newpapa;
                            newpapa->dad = root->dad;

                            root->dad->lson = newnode;
                            newnode->dad = root->dad;

                            root->dad->Red1Black0 = 0;
                            newpapa->Red1Black0 = 1;

                            root->dad->keyvalue = root->keyvalue;
                            ContCpy(root->dad->cont , root->cont);
                            //free(root);
                        }
                        else {//爸爸是爷爷的右儿子，和我反向：需要旋转操作
                            root->lson = newnode->rson;
                            if (newnode->rson != NULL) newnode->rson->dad = root;
                            newnode->rson = NULL;
                            root->dad->rson = newnode;
                            newnode->dad = root->dad;
                            root->dad = NULL;
                            AddNode(newnode, root);
                        }
                    }
                }
            }
        }
    }
    return 1;
}

3删除节点

int RemoveNode(Node* node)

0
红色
黑色
1
2
node有几个子节点
node颜色
直接删除
需要删除平衡
子节点必红,直接取代node即可
用临近节点取代node,并递归删除临近节点

删除平衡操作：
void DeleteBalance(Node* n)
链接: https://www.jianshu.com/p/84416644c080.
在这里插入图片描述
代码：


void DeleteBalance(Node* n){
    //先删除,
    Node* p = n->dad;
    Node* s = (n->dad==NULL)?NULL:((n->dad->rson->keyvalue==n->keyvalue)?n->dad->lson:n->dad->rson);
    int sL1R0 = (s==NULL)?3:( (n->dad->lson->keyvalue==s->keyvalue)?1:0);
    Node* sl = (s==NULL)?NULL:(s->lson);
    Node* sr = (s==NULL)?NULL:(s->rson);
    if(n->Red1Black0==2){
        n->Red1Black0 = 0;
    }else{
        if(n->dad == NULL){
            n->keyvalue =0;
            n->cont =NULL;
        }else{
            if(sL1R0==1){
                n->dad->rson =NULL;
            }else{
                n->dad->lson =NULL;
            }
            //不知道为什么
            //free(n);
        }
    }
    //然后开始判断是否需要平衡
    if(n->dad==NULL){//n为根节点，无需平衡
        return;
    }else{
        if(s->Red1Black0!=1){//兄黑
            if(((s->rson==NULL)|| (s->rson->Red1Black0!=1  ))&&((s->lson==NULL)||(s->lson->Red1Black0!=1))){//兄子节点全黑
                if(p->Red1Black0!=1){//父黑
                    s->Red1Black0=1;
                    p->Red1Black0=2;
                    DeleteBalance(p);
                }else{//父红
                    p->Red1Black0 =0;
                    s->Red1Black0 =1;
                    //交换ps颜色，平衡结束
                }
            }else{//兄子节点不全黑
                //拐的时候，先弄直
                if((sL1R0==1) && (sr!=NULL) && (sr->Red1Black0==1 )){
                    sr->dad = p;
                    p->lson = sr;

                    s->rson = sr->lson;
                    if(sr->lson!=NULL) sr->lson->dad = s;

                    s->dad = sr;
                    sr->lson =s;

                    s->Red1Black0=1;
                    sr->Red1Black0 =0;
                }else if((sL1R0==0)&&(sl!=NULL)&&(sl->Red1Black0==1)){
                    sl->dad =p;
                    p->rson = sl;

                    s->lson = sl->rson;
                    if(sl->rson!=NULL)sl->rson->dad =s;

                    s->dad = sl;
                    sl->rson = s;

                    s->Red1Black0 =1;
                    sl->Red1Black0 =0;
                }
                //直的时候，直接处理
                if(sL1R0 ==1){//s在左边
                    Node* newP = (Node*)malloc(sizeof(Node));
                    newP->cont = (Content*)malloc(sizeof(Content));
                    newP->keyvalue = p->keyvalue;
                    ContCpy(newP->cont,p->cont);
                    p->keyvalue = s->keyvalue;
                    ContCpy(p->cont,s->cont);

                    newP->lson = sr;
                    if(sr!=NULL)sr->dad = newP;

                    newP->rson = p->rson;
                    if(p->rson!=NULL)p->rson->dad = newP;

                    sl->dad = p;
                    p->lson = sl;

                    newP->dad = p;
                    p->rson = newP;
                    sl->Red1Black0 = 0;
                }else{
                    Node* newP = (Node*)malloc(sizeof(Node));
                    newP->cont = (Content*)malloc(sizeof(Content));
                    newP->keyvalue = p->keyvalue;
                    ContCpy(newP->cont,p->cont);
                    p->keyvalue = s->keyvalue;
                    ContCpy(p->cont,s->cont);

                    newP->rson = sl;
                    if(sl!=NULL)sl->dad = newP;

                    newP->lson = p->lson;
                    if(p->lson!=NULL)p->lson->dad = newP;

                    sr->dad = p;
                    p->rson = sr;

                    newP->dad = p;
                    p->lson = newP;
                    sr->Red1Black0 = 0;
                }
            }
        }
    }
}

4查询节点

普普通通的递归查询

Node* FindNode(Node* root,int keyvalue) {
    if(root==NULL){return NULL;}
    if((root->keyvalue )== keyvalue){
        return root;
    }else{
        if(keyvalue>(root->keyvalue)){
            return FindNode(root->rson,keyvalue);
        }else{
            return FindNode(root->lson,keyvalue);
        }
    }
}

5遍历节点

普普通通的中序遍历

6以文件形式保存

函数指针形式，方便更换节点定义

int SaveRBTree(Node* root,char* filename, char* (*NodeToString)(Node* a)) {
    SomeNodes a = GetAllNodes(root, 1000);
    FILE * p = fopen(filename , "w");
    if(p==NULL){printf("file ERROR!\n"); return 0;}
    fprintf(p,"%d\n",a.num);
    for(int i=0; i < a.num ; i++){
        fprintf(p,"%s\n",NodeToString(a.datas[i]));
    }
    fclose(p);
    return a.num;
}
Node* LoadRBTree(char* filename, Node* (*StringToNode)(char* s)) {
    Node* root = CreatRBTree();
    int num;
    FILE* p=fopen(filename,"r");
    if(p==NULL){printf("file ERROR!\n"); return NULL;}
    fscanf(p,"%d",&num);
    char *one_line;
    one_line = (char*)malloc( 1000 * sizeof(char));
    for(int i=0;i<num+1;i++){
        fgets(one_line, 1000, p);
        AddNode(root,StringToNode(one_line));
    }
    printf("file Load Succeed: %d Nodes Loaded!\n",num);
    return root;
}
疯鬼鹦鹉007
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【数据结构与算法】手撕红黑树
pythonxxoo的博客
04-02 823
Python微信订餐小程序课程视频 https://edu.csdn.net/course/detail/36074 Python实战量化交易理财系统 https://edu.csdn.net/course/detail/35475 红黑树 定义 动机： 二叉查找树查找、插入、删除最坏情况时间复杂度可能退化为 O(n)。 AVL 树很好的限制了数的高度为 O(logn)，插入、删除、查找的最坏时间复杂度均为 O(logn)；但删除操作最多需要做 O(logn) 次旋转。 红黑树是具有如下特点的二
红黑树的删除—10张图学会
早就戒了的博客
12-23 1万+
如果要学红黑树，那么就必须知道二叉树，毕竟红黑树本身就是一个二叉搜索树。只不过红黑树比一般的二叉搜索树更加稳定，也就是更加平衡，但是有没有AVL树那么的稳定，这换来的是红黑树比AVL数有更好的插入和删除效率，但是查找效率并没有比AVL差很多。下文我将用RBT代替红黑树。二叉搜索树的删除介绍RBT的删除，就先要知道二叉搜索树的删除(知道的同学可以直接跳过)。删除分为四步： 1.找到删除点假设为X
红黑树的基本概念与增删改查完整实现(C++)
zorchp
01-24 921
-
【手撕红黑树 | 史上最详细注解】增删查改 原理剖析 代码实现
土味儿
09-14 212
1、基本特征 红黑树起源于2-3-4树(或2-3树)，底层是二叉查找树，除二叉树的特性外，还有5大特性： 根是黑色 节点是黑色或红色 叶子节点都是黑色 叶子节点为NIL节点，不可忽略，见下图 每个红色节点的两个子节点必须是黑色 从每个叶子到根的路径上不能有两个连续的红节点 黑色平衡 从任一节点到其所有叶子节点的简单路径上黑色节点数量相同 )] 2、内部节点类Node 双向链表：父 > 子 子 > 父 /** * 内部节点
红黑树C语言实现增删改查
12-09
用C语言写的红黑树，实现了增删改查， 程序一开始初始化了给定好的红黑树，并且用颜色形象的表示，所以分比较高。提示，需要用WINTC编译，因为用到了一个库函数上颜色，想用VC编译的童鞋，可以根据代码更改。核心算法是相通的。
机器学习实战-手撕决策树
05-18
决策树模型在鸢尾花数据集上的实现，包括完整代码和可视化以及讲解，准确率很高，亲测可用！
Java课程设计作业-连接数据库，实现增删改查功能的页面
最新发布
06-13
源码
手撕GO语言-详细注释版
12-15
【标题】"手撕GO语言-详细注释版"提供了全面深入学习Go语言的资源，适合初学者和有一定经验的开发者。这份资料包含了大量实例，旨在帮助读者快速掌握Go语言的核心概念和应用。 【描述】"学习GO语言的不二资料"表明...
行业资料-交通装置-一种手撕鳖盖配方及其制作方法.zip
08-21
行业资料-交通装置-一种手撕鳖盖配方及其制作方法.zip
行业资料-建筑装置-带手撕条离型纸的胶带制作方法.zip
08-19
行业资料-建筑装置-带手撕条离型纸的胶带制作方法.zip
红黑树算法(C#,C++实现)红黑树算法(C#,C++实现)！红黑树算法(C#,C++实现)！
02-22
红黑树算法(C#,C++实现)！
gcc红黑树修改完整版
02-25
2. (必做题） 红黑树、二叉搜索树的实现和性能比较 描述： 实现红黑树、二叉搜索树相关算法：插入（红黑树涉及树的调整：左旋、右旋等），删除，搜索（指定Key值节点）。 另外，红黑树实现计算树黑高的算法。 1).插入测试，输入 8，11，17，15，6，1，22，25，27，建立红黑树，按照 红黑树信息输出方式 输出整棵红黑树以及黑高。 2).删除测试，删除1）中红黑树中Key=15的节点，按照 红黑树信息输出方式 输出调整后的整棵红黑树以及黑高。 3).随机产生300,000个不同自然数Key值（1－300,000，每个数出现一次，出现顺序随机），建立红黑树，查找Key=15000的节点，输出查找花费时间。 用上面的数据，建立二叉搜索树，查找Key=15000的节点，输出查找花费时间。 4). 重复3－5次3）中操作，求各自平均时间。 5). 在1)－4)的红黑树算法基础上修改完成P307 14.1-4算法 OS_Key_Rank(T,k). 输入 1,2,3,4,5,6,7,8 建树， k=6, 输出OS_Key_Rank的返回值。 文档要点：总结红黑树和二叉搜索树在查找上的性能分析，描述此类算法的应用。
平衡树和二叉树的区别
riemann_的博客
09-25 3568
一、平衡二叉树（AVL树） 1、概念 AVL树是带有平衡条件的二叉查找树，一般是用平衡因子差值判断是否平衡并通过旋转来实现平衡，左右子树树高不超过1，和红黑树相比，AVL树是严格的平衡二叉树，平衡条件必须满足（所有节点的左右子树高度差不超过1）。不管我们是执行插入还是删除操作，只要不满足上面的条件，就要通过旋转来保持平衡，而旋转非常耗时的，由此我们可以知道AVL树适合用于插入与删除次数比较少，但查找多的情况。 2、局限性 由于维护这种高度平衡所付出的代价比从中获得的效率收益还大，故而实际的应用不多，更多的地
红黑树的添加删除操作
热门推荐
好好学习
07-09 2万+
<br /><br />来自: http://hi.baidu.com/coolinc/blog/item/3aa07f3e162502eb54e723b1.html<br />介绍另一种平衡二叉树：红黑树（Red Black Tree），红黑树由Rudolf Bayer于1972年发明，当时被称为平衡二叉B树（symmetric binary B-trees），1978年被Leonidas J. Guibas 和Robert Sedgewick改成一个比较摩登的名字：红黑树。<br />红黑树和之前所讲的
天天说手撕红黑树？你真的能撕的下来吗？（详细解释+代码注释）
CYK_byte的博客
12-22 1004
/新增结点，默认必须是红色}}//根节点}}注意：每次新增结点必须是红色的，因为如果某一个分支上增加一个黑色结点，根据红黑树的特点，那么其他每一个分支上也必须都增加一个黑色结点，但实际上我需要增加一个结点，而为了满足红黑树特点多增加的这些结点是没有意义的；如果添加一个红色节点，我们只需要通过调整颜色，即可满足要求；
C++手撕红黑树
分享学习的知识，记录我的技术成长道路
08-07 624
红黑树在表意上就是一棵每个节点带有颜色的二叉搜索树，并通过对节点颜色的控制，使该二叉搜索树达到尽量平衡的状态。红黑树确保没有一条路径比其他路径长两倍。和AVL树不同的是，AVL树是一棵平衡树，而红黑树可能平衡也可能不平衡(因为是尽量平衡的状态)每一次插入都对根节点置为黑操作，因为第一种情况可能导致根节点不是黑。同时对根节点置黑也并不违反三条规定。...
C语言 红黑树插入/删除/查找/遍历
HardessGod的博客
12-14 5353
1 红黑树介绍 红黑树(Red-Black Tree，简称R-B Tree)，它一种特殊的二叉查找树。 红黑树是特殊的二叉查找树，意味着它满足二叉查找树的特征：任意一个节点所包含的键值，大于等于左孩子的键值，小于等于右孩子的键值。 除了具备该特性之外，红黑树还包括许多额外的信息。 红黑树的每个节点上都有存储位表示节点的颜色，颜色是红(Red)或黑(Black)。 红黑树的特性: (1) 每个节...
C语言红黑树，增加，删除
wentzheng的博客
06-02 150
红黑树详细注释
手撕buck-boost
08-04
手撕buck-boost电路是一种常见的升降压电路，用于将输入电压转换为较高或较低的输出电压。在这个电路中，输出电压Vo是恒定的，而二极管导通时的压降为Vd。电感的右端电压为Vo+Vd，而电感的左端电压为输入电压Vi。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值