红黑树（RedblackTree）上--增加节点

最新推荐文章于 2025-04-23 14:24:18 发布
最新推荐文章于 2025-04-23 14:24:18 发布
阅读量437 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 数据结构 文章标签： 红黑树RBTree 红黑树算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/magiclyj/article/details/75007748
本文介绍了红黑树的基本概念，包括其作为二叉搜索树的特性，节点颜色规则等。详细阐述了新节点插入过程，并通过实例展示了插入后如何进行平衡调整。同时提供了红黑树增加节点的代码实现，探讨了代码优化策略，帮助读者深入理解红黑树的工作原理。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

一、什么事RBtree：

所谓的红黑树它需要满足一下条件：
1、该树是一颗二叉搜索树（搜索树就是按照节点值大小进行排序插入，中序就是所有节点的从小到大排序）
2、每个节点不是红色就是黑色
3、根节点为黑色
4、红节点不相连
5、任一节点至NULL（树尾）的任何途径，所含之黑节点树必须相同
为了统一，我们视NULL为黑节点。

红黑树的有点就在于它没有平衡因子，唯一需要让它调整的就是新节点的颜色，在数据插入上大大减少了调整次数。
我们来简单的看一组数据组成的个红黑树的模型：
{100,80,60,40,50,75,73,72,74}
这里写图片描述
新节点的颜色我们设为红色，我们把新的节
这里写图片描述
这里写图片描述
上图是模型红黑树调整的全过程，蓝色箭头代表的是平衡的红黑树有的是新节点的插入，红箭头代表对新插入节点导致不平衡的调整平衡过程。

二、RBTree是怎么实现的：

树的操作再前面刚开始学二叉树的时候相信你已经有所掌握，bst、avl、rbt树都一样，这三中树最重要的操作就是增加节点和删除节点，在这里我也只对节点的增加进行代码分析，在红黑树下篇会对其节点的删除代码进行分析，下面就是RBtree的增加节点代码展示：

#pragma once

template<class Type>
 class RBTree;
typedef enum{RED = 0, BLACK = 1}COLOR;
template<class Type>
class RBNode
{
    friend class RBTree<Type>;
public:
    RBNode():data(Type()),leftchild(NULL),rightchild(NULL),color(0),parent(NULL)
    {}
    RBNode(Type d = Type(), RBNode<Type>* left = NULL, RBNode<Type>* right = NULL, RBNode<Type>* pr = NULL, COLOR c = RED):data(d), parent(pr),leftchild(left),rightchild(right),color(c)
    {}
private:
    COLOR color;
    Type data;
    RBNode<Type>* parent;
    RBNode<Type>* leftchild;
    RBNode<Type>* rightchild;

};
template<class Type>
class RBTree
 {
 public:
     RBTree():root(NULL)
     {}
 public:
     bool Insert(const Type & x)
     {
         return Insert(root, x);
     }
 protected:
     bool Insert(RBNode<Type>* &t, const Type &x)
     {
         RBNode<Type>* p = t;
         RBNode<Type> *pr = NULL;
         while(p != NULL)
         {
             if(x == p->data)
                 return false;
             pr = p;
             if(x < p->data)
                 p=p->leftchild;
             else 
                 p = p->rightchild;
         }
         p = _Buynode(x);
         if(pr == NULL)
         {
             p ->color = BLACK;
             t = p;
             return true;
         }
         if( x < pr->data)
             pr->leftchild = p;
         else
             pr ->rightchild = p;
         p->parent = pr;
         _Balance_Tree(t,p);
         return true;
     }
 protected:
    //这里的调整方法比较复杂，代码最下面有优化代码，仔细阅读世界独有，走马观花竹篮打水
     void _Balance_Tree(RBNode<Type>* &t, RBNode<Type>* q)
     {
         while(q->parent != NULL && q->parent->color == RED)//p->parent != NULL 是为了保证循环条件成立不会造成程序的崩溃，提高了程序的严谨性
         {
             RBNode<Type> * s =NULL;
             if(q->parent->parent!=NULL && q->parent->parent->leftchild == q->parent)
             {
                 s = q->parent->parent->rightchild;
                 if((q == q->parent->leftchild && s==NULL) || q == q->parent->leftchild &&s!=NULL && s->color==BLACK)// /
                 {
                     q->parent ->color = BLACK;
                     q->parent->parent -> color = RED;
                     if(s != NULL)
                         s->color = RED;
                     RotateR(q->parent->parent);
                 }
                 else if((q == q->parent->rightchild && s==NULL) || q == q->parent->rightchild &&s!=NULL && s->color==BLACK)// /
                 {
                     q->parent->parent->color = RED;
                     q->color = BLACK;
                     RotateLR(q->parent->parent);
                 }
                 else if(q == q->parent->leftchild && s->color == RED)
                 {
                    q->color = BLACK;
                    RotateR(q->parent->parent);
                    if(q->parent->parent!= NULL && q->parent->parent->color == RED)
                    {
                        q = q->parent;
                        continue;
                    }

                    else
                        break;

                 }
                  else if(q == q->parent->rightchild && s->color == RED)
                 {
                     q->parent->color = BLACK;
                     RotateLR(q->parent->parent);
                     if(q->parent != NULL && q->parent->color == RED)
                     {
                         q=q->parent;
                         continue;
                     }
                     else 
                         break;
                 }
             }
             else
             {
                  s = q->parent->parent->leftchild;
                  if((q == q->parent->leftchild && s==NULL) || q == q->parent->leftchild &&s!=NULL && s->color==BLACK)// /
                 {
                     q ->color = BLACK;
                     q->parent->parent->color = RED;
                     RotateRL(q->parent->parent);

                 else if((q == q->parent->rightchild && s==NULL) || q == q->parent->rightchild &&s!=NULL && s->color==BLACK)// /
                 {
                     q->parent->parent->color = RED;
                     q->parent->color = BLACK;
                     if(s != NULL)
                         s->color = RED;
                     RotateL(q->parent->parent);
                 }
                 else if(q == q->parent->leftchild && s->color == RED)
                 {
                    q->parent->color = BLACK;
                    RotateRL(q->parent->parent);
                    if(q->parent->parent->color == BLACK)
                        break;
                    else
                    {
                        q = q->parent;
                        continue;
                    }

                 }
                  else if(q == q->parent->rightchild && s->color == RED)
                 {
                     q->parent->color = BLACK;
                     RotateL(q->parent->parent);
                     if(q->parent->color == RED)
                     {
                         q=q->parent;
                         continue;
                     }
                     else 
                         break;
                 }
             }
         }
         t->color = BLACK;
     }
 protected:
     RBNode<Type>* RotateR(RBNode<Type> *ptr)
     {
         RBNode<Type> * subR = ptr;
         ptr = subR->leftchild;
         subR->leftchild = ptr->rightchild;
         if(ptr->rightchild != NULL)
             ptr->rightchild ->parent = subR;
         ptr->rightchild = subR;
         if(subR->parent == NULL)
             root = ptr;
         else
         {
             if(subR == subR->parent->leftchild)
                 subR->parent->leftchild = ptr;
             else
                 subR->parent->rightchild = ptr;
         }
         ptr->parent = subR->parent;/////////
         subR->parent = ptr;
         return ptr;
     }
     void RotateL(RBNode<Type>* ptr)
     {
         RBNode<Type>* subL = ptr;
         ptr = subL->leftchild;
         subL->rightchild = ptr->leftchild;
         if(ptr->leftchild != NULL)
             ptr->leftchild->parent = subL;

         if(subL->parent == NULL)
             root = ptr;
         else
         {
             if(subL == subL->parent->leftchild)
                 subL->parent->leftchild = ptr;
             else
                 subL->parent->rightchild = ptr;
         }
         ptr->parent = subL->parent;
         subL->parent = ptr;
     }
     void RotateRL(RBNode<Type>* ptr)
     {
         RBNode<Type>* subR = ptr->rightchild;
         RBNode<Type>* subL = ptr;
         ptr = subR->leftchild;
         subR->leftchild = ptr->rightchild;
         if(ptr->rightchild != NULL)
             ptr->rightchild->parent = subR;
         ptr->rightchild = subR;
         subL->rightchild = ptr->leftchild;
         if(ptr->leftchild != NULL)
             ptr->leftchild->parent = subL;
         ptr->leftchild = subL;
         if(subL->parent == NULL)
             root = ptr;
         else
         {
             if(subL == subL->parent ->leftchild)
                 subL->parent ->leftchild = ptr;
             else
                 subL->parent->rightchild = ptr;
         }
         ptr->parent = subL->parent;
         subL->parent = ptr;
         subR->parent = ptr;
     }
     void RotateLR(RBNode<Type>* ptr)
     {
         RBNode<Type>* subR = ptr;
         RBNode<Type>* subL = ptr->leftchild;
         ptr = subL->rightchild;
         subL->rightchild = ptr->leftchild;
         if(ptr->leftchild != NULL)
             ptr->leftchild ->parent = subL;
         ptr->leftchild = subL;
         subR->leftchild = ptr->rightchild;
         if(ptr->rightchild != NULL)
             ptr->rightchild->parent = subR;
         ptr->rightchild = subR;
         if(subR->parent == NULL)
             root = ptr;
         else
         {
             if(subR == subR->parent->leftchild)
                 subR->parent->leftchild = ptr;
             else
                 subR->parent->rightchild = ptr;
         }
         ptr->parent = subR->parent;
         subL->parent = ptr;
         subR->parent = ptr;
     }
 private:
     RBNode<Type>* _Buynode(const Type x)
     {
         RBNode<Type>* new1 = new RBNode<Type>(x);
         return new1;
     }
 private:
     RBNode<Type>* root;
 };

三、对于平衡调整的代码优化：

对与调整的模块的优化：

/*优化说明：在节点插入的同时，我们需要考虑其伯父节点是否存在，如果存在我们看其伯父节点是否为红色，如果是只需要将伯父节点和父节点的颜色改为黑色并把祖父节点颜色调为红色，改为在树中插入祖父节点来向上调整即可，这里优化的还有我们最多只需要对节点进行两次单旋转即可达到目的*/
 void _Balance_Tree(RBNode<Type>* &t, RBNode<Type>* q)
     {
         while(q->parent->color == RED)
         {
              RBNode<Type> * s =NULL;
             if(q->parent->parent!=NULL && q->parent->parent->leftchild == q->parent)
             {
                 s = q->parent->parent->righthchild;
                 if( s != NULL && s->color = RED)
                 {
                     q->parent->color = BLACK;
                     s -> color = BLACK;
                     q->parent->parent->color = RED;
                     q = q->parent;
                     continue;
                 }
                 else if(q = q->parent->rightchild)
                 {
                     q = q->parent;///////////为下面单转做铺垫
                     RotateL(q);
                 }
                 q->parent->color = BLACK;
                 q->parent->parent = RED;
                 RotateR(q->parent->parent);
             }
             else
             {
                  if(q->parent->parent!=NULL && q->parent->parent->leftchild == q->parent)
             {
                 s = q->parent->parent->lefthchild;
                 if( s != NULL && s->color = RED)
                 {
                     q->parent->color = BLACK;
                     s -> color = BLACK;
                     q->parent->parent->color = RED;
                     q = q->parent->parent;
                     continue;
                 }
                 else if(q == q->parent->leftchild)
                 {
                      q = q->parent;
                     RotateR(q);
                 }
                  q->parent->color = BLACK;
                 q->parent->parent = RED;
                 RotateL(q->parent->parent);
             }
         }
     }

如果你认真阅读了博客，相信你已经对红黑树有了一定的了解，自己亲手编程将会让你能够掌握红黑树节点的增加。在普通调整和优化后的调整两种方法调整得到的最终红黑树的结果是不相同的，但是经过调整后的红黑树任然正确。还是那句话走马观花竹篮打水，仔细阅读世界独有。

数据结构-红黑树插入结点示例
学习记录
12-13 1008
数据结构-红黑树插入结点示例
【二叉树进阶】红黑树（Red Black Tree） - 平衡二叉搜索树
codewinter的博客
06-21 3602
红黑树，是一种平衡二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是 Red 或 Black。通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出2倍，因而是接近平衡的。AVL树和红黑树：红黑树更多是一种折中的选择，它舍弃平衡二叉树的严格平衡，换取节点插入时尽可能少的调整。因为红黑树的旋转情况少于AVL树，使得红黑树整体性能略优于AVL树，不然map和set底层怎么会用红黑树呢，包括很多语言的库里面都用了红黑树。如果发明AVL树的人是天才的话，那么发明红
红黑树插入节点
qq_55008871的博客
09-05 763
前言红黑树是一种非严格平衡的二叉搜索树，由于其查找效率很快，并且插入新节点调整比AVL树更少，所以在STL容器map和set的底层都是通过红黑树来实现的。在看这篇文章之前建议先学习其中包括的以及，在这篇文章中不再重复红黑树的概念概念，是一种，但。通过从任何一条从跟到叶子的路径上各个节点着色方式的限制。红黑树，因而是的。1.每个节点不是红色就是黑色2.根节点是黑色3.如果一个节点是红色的，则它的两个孩子节点是黑色的。
红黑树原理（增加节点、删除节点、修改节点、查询节点）
目与木鱼
12-26 2124
红黑树原理（增加节点、删除节点、修改节点、查询节点）
红黑树增加新节点
⊙-→棒棒糖ing .____`
09-20 783
只有增加新结点的！！！只有增加新结点的！！！只有增加新结点的！！！ 想做某题看了些资料。但是现在某题还是没有思路，然后就写了这个，大体布局就和AVL增加怎结点差不错的代码 l0_r1[2]的l0_r1[0]存放对应值value的左结点的编号，l0_r1[1]存放对应右结点的编号，-1代表指向null，改为指针当是差不多 收藏的某些链接http://www.cnblogs.com/fornever/archive/2011/12/02/2270692.html http://f.dataguru.cn/th
【数据结构】红黑树-新增节点
the_fool_的博客
04-27 576
红黑树 特性总结： 定义： 红黑树(Red-Black Tree，简称R-B Tree)，它一种特殊的二叉查找树。 红黑树是特殊的二叉查找树，意味着它满足二叉查找树的特征：任意一个节点所包含的键值，大于等于左孩子的键值，小于等于右孩子的键值。 除了具备该特性之外，红黑树还包括许多额外的信息。 红黑树的每个节点上都有存储位表示节点的颜色，颜色是红(Red)或黑(Black)。 五大特性: (1) 每个节点或者是黑色，或者是红色。 (2) 根节点是黑色。 (3) 每个叶子节点是黑色。...
数据结构-Java实现一个简单的红黑树RedBlackTree
09-25
红黑树是一种自平衡的二叉查找树，它通过在每个节点上增加一个存储位表示节点的颜色，可以是红色或黑色。通过对任何一条从根到叶子的路径上各个节点的颜色进行约束，红黑树确保没有一条路径会比其他路径长出两倍，...
RED-BLACK-tree-and-2-3-4tree.rar_234树到红黑树_红黑树
09-23
红黑树（Red-Black Tree）是一种自平衡二叉查找树，由IBM的研究员鲁道夫·贝尔在1972年提出。它的设计目标是在插入、删除和查找操作上保持近似最坏情况下的O(log n)时间复杂度，同时通过特定的颜色规则保证树的平衡...
red-black-tree-c.rar_red black tree_tree c语言
09-21
红黑树（Red-Black Tree）是一种自平衡二叉查找树，由Rudolf Bayer在1972年提出，它的每个节点都带有颜色属性，可以是红色或黑色。这种数据结构在计算机科学中有着广泛的应用，特别是在实现关联数组、数据库索引、...
RBT.rar_red black tree_红黑树
09-24
红黑树（Red-Black Tree）是一种自平衡二叉查找树，由计算机科学家鲁道夫·贝尔在1978年提出。它在保持二叉查找树特性的同时，通过引入颜色属性来确保树的平衡，从而提高数据操作的效率。在C++中实现红黑树，通常...
红黑树新增节点详解
CaptainCats的博客
08-12 929
而祖父节点涂红则是因为右旋后，经过叔节点的路径的黑色节点数量加一，涂红进行数量平衡，下同。需要将叔、父节点涂黑，祖父节点涂红，然后把祖父节点作为新的子节点，往上递归执行平衡操作。父节点涂黑是因为要涂为原祖父节点的黑色（往上兼容祖父节点的父节点），父节点是祖父节点的左子节点，子节点是父节点的左子节点。父节点是祖父节点的右子节点，子节点是父节点的右子节点。父节点是祖父节点的左子节点，子节点是父节点的右子节点。父节点是祖父节点的右子节点，子节点是父节点的左子节点。...
数据结构之红黑树新增节点
TreeCode的博客
08-03 466
红黑树定义 红黑树的每个节点或是红的，或是黑的 根节点是黑的 每个叶子节点是黑的 如果一个节点是红的，则它的两个子节点是黑的 对每个节点，从该节点到其子孙节点的所有路径上包含相同数目的黑节点。 补充解释： 1.对第四条的定义可以解释为不能出现连续两个红节点 2.新增节点时，节点的初始颜色应该是红色的，否则会违反定义第五条。 3.能通过变色解决的问题就别旋转 4.新增节点后整棵树必须仍然满足上面五条定义的规则。 红黑树新增节点情况图解分析   1.没有根节点，变色   2.父节点是黑色时，不用进行操作
红黑树插入节点（c++实现）
Emotion的博客
08-02 332
手写了一个红黑树插入节点 主要参考了以下两位博主的写法 #include<iostream> using namespace std; typedef enum { RED = 0, BLACK } Color; struct RBTreeNode { int key; Color color; struct RBTreeNode* left; //左孩子 struct RBTreeNode* right; //右孩子 struct RBTreeNode* parent;
java实现红黑树的插入节点
sunpy
08-05 943
1.什么是红黑树 红黑树是带有着色性质的二叉查找树。 性质如下： ① 每一个节点或者着成红色或者着成黑色。 ② 根节点为黑色。 ③ 每个叶子节点为黑色。 ④ 如果一个节点是红色的，那么它的子节点必须是黑色的。 ⑤ 从一个节点到一个NULL指针的每一条路径必须包含相同数目的黑色节点。 推论： 有n个节点的红黑树的高度最多是2log(N+1) 。
Java 实现往红黑树插入结点
小浩子的博客
02-26 1135
红黑树是平衡二叉查找树中的一种，最突出的特点是效率高。时间复杂度：O(log(n))红黑树有如下4个性质： 1).没个结点不是红色就是黑色； 2).根结点是黑色的； 3).每个红色结点的父亲是黑色的； 4).根结点到达每个叶子结点的路径中黑色结点的个数是一样的；那么，为什么红黑树的效率高呢？ 根据性质3，先把红色结点跟父亲结点整合在一块，新整合出来的树称为“2-3-4 树”，它的高度为原先
图解TreeMap的红黑树平衡操作fixAfterInsertion()，接着手撕红黑树添加节点
健身变秃，coding变强
11-21 1335
一、前言 啥也不想说，就卷、卷技术；手撕红黑树搞起。 1、红黑树简介 红黑树就是一种平衡的二叉查找树，其有五个特点： 1.每个节点要么是红⾊，要么是⿊⾊； 2. 根节点⼀定是⿊⾊的； 3. 每个叶⼦节点⼀定是⿊⾊的NULL节点； 4. 如果⼀个节点是红⾊，那么它的左右⼦节点⼀定都是⿊⾊的； 5. 从任意⼀个节点到叶⼦节点，所经过的⿊⾊节点的数量⼀样多； 2、TreeMap简介 TreeMap 继承于AbstractMap ，其是一个 有序的key-value集合，内部基于 红黑树 实现； TreeM
【数据结构-红黑树-红黑色节点插入详解】-带你快速理解红黑树
最新发布
speaktoit的博客
04-23 1070
红黑树性质介绍，及红黑树节点插入的重点实现
【数&C++】图解红黑树 — 插入节点
阿琪
06-18 385
本篇针对红黑树的插入(以父为左、叔为右)进行图解。
红黑树------插入结点
G_Super_Mouse的博客
07-08 491
红黑树的优势 首先红黑树是不符合AVL树的平衡条件的，即每个节点的左子树和右子树的高度最多差1的二叉查找树。但是提出了为节点增加颜色，红黑树是用非严格的平衡来换取增删节点时候旋转次数的降低，任何不平衡都会在三次旋转之内解决，而AVL是严格平衡树，因此在增加或者删除节点的时候，根据不同情况，旋转的次数比红黑树要多，所以红黑树的插入效率更高。 红黑树能够以O(log2 (n)) 的时间复杂度进行搜索、插入、删除操作 简单来说红黑树就是为了解决二叉查找树的缺陷，因为二叉查找树在某些情况下会退化成一个线
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值