红黑树

最新推荐文章于 2025-04-15 17:11:19 发布
最新推荐文章于 2025-04-15 17:11:19 发布
阅读量7.2k 收藏 134
点赞数 30
分类专栏： 数据结构 文章标签： 红黑树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/hc372893308/article/details/97394857
版权

红黑树

从 234 树 到 红黑树：https://blog.youkuaiyun.com/asdfsadfasdfsa/article/details/86500552

定义

2-3-4 树和红黑树是完全等价的，由于绝大多数编程语言直接实现2-3-4树会非常繁琐，所以一般是通过实现红黑树来实现替代2-3-4树，而红黑树本也同样保证在O(lgn)的时间内完成查找、插入和删除操作。

红黑树是每个节点都带有颜色属性的平衡二叉查找树 ，颜色为红色或黑色。除了二叉查找树一般要求以外，对于任何有效的红黑树我们增加了如下的额外要求:

（1） 节点是要么红色或要么是黑色。

（2） 根一定是黑色节点。

（3） 每个叶子结点都带有两个空的黑色结点（称之为NIL节点，它又被称为黑哨兵）。

（4） 每个红色节点的两个子节点都是黑色（或者说从每个叶子到根的所有路径上不能有两个连续的红色节点）。

（5） 从任一节点到它所能到达得叶子节点的所有简单路径都包含相同数目的黑色节点。

这些性质保证了根节点到任意叶子节点的路径长度，最多相差一半（因为路径上的黑色节点相等，差别只是不能相邻的红色节点个数），所以红黑树是一个基本平衡的二叉搜索树，它没有AVL树那么绝对平衡，但是同样的关键字组成的红黑树相比AVL旋转操作要少，而且删除操作也比 AVL 树效率更高，实际应用效果也比 AVL 树更出众。当然红黑树的具体实现也复杂的多。
[外链图片转存失败(img-SlZuqEMO-1564129420177)(assets/834468-20161203123711443-77296748.png)]

黑哨兵节点的作用:

红黑树的这5个性质中，第3点是比较难理解的，但它却非常有必要。我们看上面这张图，如果不使用黑哨兵，它完全满足红黑树性质，根结点5到两个叶结点1和叶结点9路径上的黑色结点数都为3个，且没有连续红色节点。

但如果加入黑哨兵后，叶结点的个数变为 8 个黑哨兵，根结点5到这8个叶结点路径上的黑高度就不一样了，所以它并不是一棵红黑树。NIL节点的存在还可以使得红黑树在代码实现方面得到简化，在具体实现过程中我们只需要 1个NIL节点即可。

为了简化代码和减少不必要的开销，在具体的实现中我们定义一个伪根节点 ROOT 且只定义一个 NIL 节点。伪根节点的左子支永远指向 NIL 节点，NIL 节点的左右子支又指向它自身。伪根节点的右子支才表示真正的红黑树。( jdk 中 treemap 的实现,貌似没有用到黑哨兵节点)
[外链图片转存失败(img-g0nLftOL-1564129420179)(assets/834468-20161217195224745-172402156.png)]
[外链图片转存失败(img-5e7HKBPW-1564129420181)(assets/834468-20161203123723990-1423307098.png)]
在这里插入图片描述

代码：

enum RBTColor{RED, BLACK};

template <class T>
class RBTNode{
    public:
        RBTColor color;    // 颜色
        T key;            // 关键字(键值)
        RBTNode *left;    // 左孩子
        RBTNode *right;    // 右孩子
        RBTNode *parent; // 父结点

        RBTNode(T value = 0, RBTColor c = BLACK, RBTNode *l = nullptr, RBTNode *r = nullptr, RBTNode *p = nullptr)
		:key(value),color(c),left(l),right(r),parent(p) {}
		
		
};

template <class T>
class RBTree {
	
    private:
        RBTNode<T> *mRoot;    // 根结点
		RBTNode<T> *NIL;
		int size;
    public:
        RBTree();
        ~RBTree();
		RBTColor getRootColor(){
			return mRoot->color;
		};
		
		int Compare(T x, T y){
			if (x > y)
				return 1;
			else if (x < y)
				return -1;
			else
				return 0;
		}		
		
        // 前序遍历"红黑树"
        void preOrder();
        // 中序遍历"红黑树"
        void inOrder();
        // 后序遍历"红黑树"
        void postOrder();

        // (递归实现)查找"红黑树"中键值为key的节点
        RBTNode<T>* search(T key);

        // 查找最小结点：返回最小结点的键值。
        T minimum();
        // 查找最大结点：返回最大结点的键值。
        T maximum();

        // 找结点(x)的后继结点。即，查找"红黑树中数据值大于该结点"的"最小结点"。
        RBTNode<T>* successor(RBTNode<T> *x);
        // 找结点(x)的前驱结点。即，查找"红黑树中数据值小于该结点"的"最大结点"。
        RBTNode<T>* predecessor(RBTNode<T> *x);

        // 将结点(key为节点键值)插入到红黑树中
        bool insert(T key);

        // 删除结点(key为节点键值)
        bool remove(T key);

        // 销毁红黑树
        void destroy();

        // 打印红黑树
        void print();
        
        // 查找最小结点：返回tree为根结点的红黑树的最小结点。
        RBTNode<T>* minimum(RBTNode<T>* tree);
        // 查找最大结点：返回tree为根结点的红黑树的最大结点。
        RBTNode<T>* maximum(RBTNode<T>* tree);
        
    private:
        // 前序遍历"红黑树"
        void preOrder(RBTNode<T>* tree) const;
        // 中序遍历"红黑树"
        void inOrder(RBTNode<T>* tree) const;
        // 后序遍历"红黑树"
        void postOrder(RBTNode<T>* tree) const;

        // 左旋
        void leftRotate(RBTNode<T>* x);
        // 右旋
        void rightRotate(RBTNode<T>* y);

        // 删除函数
        void remove(RBTNode<T>* &root, RBTNode<T> *node);

        // 销毁红黑树
        void destroy(RBTNode<T>* &tree);

        // 打印红黑树
        void print(RBTNode<T>* tree, T key, int direction);

#define rb_parent(r)   ((r)->parent)
#define rb_color(r) ((r)->color)
#define rb_is_red(r)   ((r)->color==RED)
#define rb_is_black(r)  ((r)->color==BLACK)
#define rb_set_black(r)  do { (r)->color = BLACK; } while (0)
#define rb_set_red(r)  do { (r)->color = RED; } while (0)
#define rb_set_parent(r,p)  do { (r)->parent = (p); } while (0)
#define rb_set_color(r,c)  do { (r)->color = (c); } while (0)
};


/* 
 * 构造函数
 */
template <class T>
RBTree<T>::RBTree()
{
	size = 0;
	mRoot = new RBTNode<T>;
	NIL = new RBTNode<T>(0, BLACK, nullptr, nullptr, nullptr);
	NIL->left = NIL;
	NIL->right = NIL;
	mRoot->left = NIL;
	mRoot->right = NIL;
	mRoot->parent = mRoot;    
}
234 树 和 红黑树的等价关系

如果一棵树满足红黑树，把红结点收缩到其父结点（红结点是和父结点一体的，对应于 234 树的结点），就变成了2-3-4树，所有红色节点都与其父节点构成 3 或 4 节点，其它节点为 2 节点。图中 NIL 节点未画出。
[外链图片转存失败(img-q6Amh83I-1564129420186)(assets/834468-20161203123740677-1020851879.png)]

所以红黑树的每一类型操作都与 2-3-4 树一一对应。黑色节点的个数（或者说位置）对应 2-3-4 树中的节点个数（或者说位置），这样可以很好的理解性质 3（从每个叶子到根的所有路径上不能有两个连续的红色节点）和性质5（从任一节点到它所能到达得叶子节点的所有简单路径都包含相同数目的黑色节点）以及根节点到任意叶子节点的路径长度，最多相差一半。

同时我们还需要明白的是，一颗红黑树对应唯一形态的 2-3-4 树，但是一颗 2-3-4 树可以对应多种形态的红黑树（主要是 3 节点可以对应两种不同的红黑树形态），上图中的 2-3-4 树还可以对应下图中的红黑树。我们在后面红黑树的删除操作中会利用这种情况。
[外链图片转存失败(img-5ABxSyzl-1564129420188)(assets/834468-20161203123800302-470689866.png)]

红黑树中旋转的定义

为每种书中对旋转的定义不一致，所以我们有必要在这里特此说明一下。以某一个节点为轴，它的左子枝顺时针旋转，作为新子树的根，我们称之为顺时针旋转（clockwise）或者右旋转。同理，以某一个节点为轴，它的右子枝逆针旋转，作为新子树的根，我们称之为逆时针旋转（anticlockwise）或者左旋转。

/* 
 * 对红黑树的节点(x)进行左旋转
 *
 * 左旋示意图(对节点x进行左旋)：
 *      px                              px
 *     /                               /
 *    x                               y                
 *   /  \      --(左旋)-->           / \            
 *  lx   y                          x  ry     
 *     /   \                       /  \
 *    ly   ry                     lx  ly  
 *
 *
 */
template <class T>
void RBTree<T>::leftRotate(RBTNode<T>* X)
{
        RBTNode<T> *P = X->parent;	// 得到 x 的父节点 P
        RBTNode<T> *XR = X->right;	// 得到 x 的右子树（将替换 x 的位置） XR
        if(P->left == X){	// 判断 x 在 px 的左还是右
            P->left = XR;	// x 的子树 XR 替换 X
        }else{
            P->right = XR;
        }
        XR->parent = P;		// 换 父
         
        X->right = XR->left;	// 将 XR 的左子数给 X 
        if(XR->left != NIL){
            XR->left->parent = X;	// 换 父
        }
         
        XR->left = X;	// 将 X 变成 XR 的左子树，完成旋转
        X->parent = XR;
}


/* 
 * 对红黑树的节点(y)进行右旋转
 *
 * 右旋示意图(对节点y进行左旋)：
 *            py                               py
 *           /                                /
 *          y                                x                  
 *         /  \      --(右旋)-->            /  \                     #
 *        x   ry                           lx   y  
 *       / \                                   / \                   #
 *      lx  rx                                rx  ry
 * 
 */
template <class T>
void RBTree<T>::rightRotate(RBTNode<T>* X)
{
    //顺时针旋转（右旋）,参数表示轴节点
        RBTNode<T>* P = X->parent;
        RBTNode<T>* XL = X->left;
        if(P->left == X){
            P->left = XL;
        }else{
            P->right = XL;
        }
        XL->parent = P;
         
        X->left = XL->right;
        if(XL->right != NIL){
            XL->right->parent = X;
        }
         
        XL->right = X;
        X->parent = XL;
}
红黑树的插入操作

（1）如果红黑树中已存在待插入的值，那么插入操作失败，否则一定是在叶子节点进行插入操作，执行步骤 2 。

（2）当我们插入一个新节点后，我们会把该节点涂红（涂红操作，从2-3-4树的的角度看来，向 key 结点插入，如 2 -> 3），由于插入操作可能破坏了红黑树的平衡性（已经是 4 树了，再插入需要分解），所以我们需要不断回溯，进行调整。调整过程就是颜色变换和旋转操作，而这些操作都可以从2-3-4树来理解。考虑到回溯的情况，从2-3-4树的角度，我们可以把 X 节点看成向上层进位的 key。

// insert
// 首先找到插入的点，若值存在则返回 false，否则找到它
	RBTNode<T> *P = mRoot;		// 父节点，初始为 伪父
	RBTNode<T> *X = mRoot->right;	// 得到实际的根节点
	int r = 0;
	while(X != NIL){	// 弹出则找到了位置
	    r = Compare(key, X->key);
	    P = X;			// 得到最后一个有效节点作为父
	    if(r > 0){
	        X = X->right;
	    }else
	    if(r < 0){
	        X = X->left;
	    }else{
	        return false;//元素已存在，插入失败
	    }
	}
	
    RBTNode<T> *G;	// 祖父节点
    RBTNode<T> *U;	// 叔节点
    X = new RBTNode<T>(key, RED, NIL, NIL, P);	//创建新节点，涂红
	...

插入新节点时，我们可能会遇到以下几种情况：

  1. 黑父
    [外链图片转存失败(img-fhBgttwk-1564129420192)(assets/834468-20161203123802974-1044918586.png)]
  • 插入后直接涂红，如果父亲节点是个黑色，插入结束。换成 234 树表示该点最多为 3 树，至少可以插入一个；
  • 绿色箭头表示插入的位置，上图中的虚线表示可以有该节点，也可以没有该节点，如果有，一定是红色。当然还有可能在对称的情况，即在右子支插入，操作方式都是一样的，由于不涉及到旋转操作，所以代码的实现方式也一样，不在赘述；
  • 这个操作可以从2-3-4树来理解，相当于2-3-4树中待插入的叶子节点是个 2 节点（对应黑父没有孩子节点）或者3节点（黑父有孩子节点，孩子节点的颜色一定是红色）。在回溯调整的过程中也会遇到这个情况，回溯时X 表示的是下一层向上进位的 key，到这个时候就不需要继续回溯了（可容纳，没达到 4 树无需分解）

代码：

if(P->color == BLACK)	// 最简单的插入，无需判断其他，推出即可
	break;
...
  1. 红父黑叔
    [外链图片转存失败(img-utjq68rc-1564129420194)(assets/834468-20161203123818209-9377181.png)]

这种情况还有对应的镜像情况，即 P 为 G 的右子支情况：
[外链图片转存失败(img-1pgwwj8z-1564129420197)(assets/834468-20161203123832490-949203279.png)]

  • 这种情况不会在叶子节点出现，但是会出现在回溯调整的过程中。这种情况相当于 2-3-4 树中，容纳进位的父节点为 3 节点，还有空间可以容纳 key，所以到此就不用继续回溯了。

代码：

P = X->parent;
if(P->color == RED){  //红父
    G = P->parent;	// 得到祖父

    if(P == G->left){	// 得到叔
        U = G->right;
    }else{
        U = G->left;
    }
	...
    if(U->color == BLACK){	// 黑叔
        if(G->left == P){
            if(P->left == X){
                rightRotate(G);		// 旋转
                P->color = BLACK;	// 涂色
                G->color = RED;
            }else{
                leftRotate(P);
                rightRotate(G);
                X->color = BLACK;
                G->color = RED;
            }
        }else{
            if(P->right == X){
                leftRotate(G);
                P->color = BLACK;
                G->color = RED;
            }else{
                rightRotate(P);
                leftRotate(G);
                X->color = BLACK;
                G->color = RED;
            }
        }
        break;
    }
  1. 红父红叔
    [外链图片转存失败(img-efDU7tl9-1564129420199)(assets/834468-20161203123910271-60982461.png)]

  • 这种情况相当于 2-3-4 树中，向上进位的父节点为 4 节点，所以先分裂（对应P和B的颜色变换）然后再插入 X，然后继续回溯，把 G 看成向更上一层进位的节点（即把 G 看成新的 X）；

  • 这种情况还有对应的镜像情况，即 P 为 G 的右子支情况，但在具体的代码实现过程中，因为不涉及到旋转操作，所以不用区分

代码：

while(true){
    P = X->parent;
    //红父
    if(P->color == RED){
        G = P->parent;

        if(P == G->left){
            U = G->right;
        }else{
            U = G->left;
        }

        //红叔
        if(U->color == RED){
            P->color = BLACK;
            U->color = BLACK;
            G->color = RED;
            X = G; 			// 当前结点变为祖父节点，继续向上回溯
        }
        ...
    }
    size++;		// 结点加一
    mRoot->right->color = BLACK;	//	有可能向上层进位，根节点涂黑
    return true;	
	    
}
红黑树的删除操作

删除操作可以概括为以下几个步骤：

（1）查找要删除的值所在的节点，如果不存在，删除失败，否则执行步骤2

（2）如果要删除的节点不是叶子节点，用要删除节点的后继节点替换（只进行数据替换即可，颜色不变，此时也不需要调整结构），然后删除后继节点。

代码：

bool RBTree<T>::remove(T key)
{
    RBTNode<T> *X = mRoot->right;
    X->color = RED; // 删除时，根先涂红，1.防止继续向上回溯  2.只有根节点时也方便删除
    RBTNode<T> *P;
    RBTNode<T> *B;	// 兄弟节点
    while(X != NIL){
        int r = Compare(key, X->key);
        if(r > 0){
            X = X->right;
        }else
        if(r < 0){
            X = X->left;
        }else{
            break;
        }
    }
 
    if(X == NIL){	//没有找到需要删除的节点
        mRoot->right->color = BLACK;	// 根节点变回黑色
        return false;
    }
    
    size--;		// 若为叶子节点，跳过；否则，将最小值与当前结点替换，删除最小值节点 
    if(X->left != NIL && X->right != NIL){
        RBTNode<T> *tmp = minimum(X->right);
        X->key = tmp->key;
        X = tmp;    
    }   
 
    P = X->parent;	// 得到当前结点的 父
    ...
}

那么真正需要删除的节点有以下几种可能性：

  1. 要删除的节点为红色
    [外链图片转存失败(img-ckQEqZqy-1564129420204)(assets/834468-20161203123921849-771890487.png)]
  • 该操作对应 234 数的非 2 节点，可以直接删除。
  1. 要删除的节点为黑色，且有一个孩子结点，这个孩子必为红色
    [外链图片转存失败(img-kNr1ZYfo-1564129420206)(assets/834468-20161203123929865-1403012217.png)]
  • 在 234 树中，只有一个孩子，说明 key 没有填满，因此只能是红色，即使分裂后也不会出现单子树这样不平衡的情况。

代码：

// 删除当前结点的操作，此时表示初始状态或者处理后的状态达到可以直接删除的要求
P = X->parent;
RBTNode<int> *deleteNode = X; 

// 来到这里有 后继节点 和 初始的单子树 
if(X->right != NIL){	// X 是右子树，需要嫁接 
    if(X == P->left){
        P->left = X->right;	// 嫁接 
    }else{
        P->right = X->right;
    }
    X->right->parent = P;	// 换 父 
    //        X->color = BLACK;		// X 变为黑 
    mRoot->right->color = BLACK;
    delete deleteNode;	// 删除 
    return true;
}
else if(X->left != NIL){		// X 有左子树，需要嫁接 ：是左子树 或者 后继结点 
    if(X == P->left){
        P->left = X->left;		// 嫁接 
    }else{
        P->right = X->left;
    }
    X->left->parent = P;
    //        X->color = BLACK;
    mRoot->right->color = BLACK;  
    delete deleteNode;
    return true;
}else{					// X 为叶子结点 
    if(X == P->left){	// 将 P 的待删除结点 X 设为 NIL 
        P->left = NIL;
    }else{
        P->right = NIL;
    }

    if(X->color == RED){	// 若 X 为 RED，则可直接删除 
        mRoot->right->color = BLACK;
        delete deleteNode;
        return true;
    }else{					// 若 X 为 BLACK，则需要继续处理 
        X = NIL;
    }
}
...
  1. 要删除的结点为黑色，孩子节点都为 NIL

这时，我们删除这个黑色节点后需要进行调整，在图中 X 总表示下一层的节点，一开始 X 表示 NIL 节点（回溯过程中 X 会不断向上层迭代）。需要调整的情况又可以分为以下几种。

a. 黑兄红侄（兄弟结点是多树，可上移，父节点可下移至 X 处）
[外链图片转存失败(img-daSij7zM-1564129420210)(assets/834468-20161203123950756-1166411320.png)]

  • 上述两种情况大致对应 2-3-4 树删除操作中兄弟节点为 3 节点或 4 节点，父节点 key 下移，兄弟节点 key 上移动，但不完全一致；
  • 由于 X 为黑结点，则与父节点是无关的。若删除 X，必然导致该树的叶子节点不等高。因此，需要旋转；
  • 上述的旋转的作用为：B 结点是多树，则将 P 结点修正到 X 结点处，将 B 结点的后继上移至父节点处

代码：

if(BL->color == RED || BR->color == RED){	//	存在红侄
    if(X == P->right){			// X 在 P 的右边
        if(BL->color == RED){	// 上述第一种情况
            rightRotate(P);
            BL->color = BLACK;
            B->color = P->color;
            P->color = BLACK;
        }else{					// 上述第二种情况
            leftRotate(B);
            rightRotate(P);
            BR->color = P->color;
            P->color = BLACK;
        }
    }
    ...
    break;
}

这种情况还有对应的镜像情况，即 P 为 G 的右子支情况：
[外链图片转存失败(img-xkHr9gJM-1564129420212)(assets/834468-20161203124011521-360124436.png)]

代码：

if(B->color == BLACK){	//黑兄
    RBTNode<T> *BL = B->left;	//左侄子
    RBTNode<T> *BR = B->right;	//右侄子
    if(BL->color == RED || BR->color == RED){	//	存在红侄
        if(X == P->left){		// X 在 P 的左边
            if(BR->color == RED){	// 上述第一种情况
                leftRotate(P);
                BR->color = BLACK;
                B->color = P->color;
                P->color = BLACK;
            }else{					// 上述第二种情况
                rightRotate(B);
                leftRotate(P);
                BL->color = P->color;
                P->color = BLACK;
            }
        }
    }
    ...
    break;
}

b. 黑兄黑侄红父（兄弟、父亲和自己在同一结点（234 树））
[外链图片转存失败(img-TaDt56Wb-1564129420215)(assets/834468-20161203124036709-499406412.png)]

  • 上述两种情况都对应 2-3-4 树删除操作中兄弟节点为 2 节点，父节点至少是个 3 节点，父节点 key 下移与兄弟节点合并。

代码：

if(B->color == BLACK){	//黑兄
    ...
    if(BL->color == BLACK && BR->color == BLACK){	// 只有黑侄
        if(P->color == RED){	//黑侄红父
            P->color = BLACK;
            B->color = RED;
            break;				//不需要继续向上回溯
        }
    }
    ...
}

c. 黑兄黑侄黑父（属于分裂过的情形，全为二节点）
在这里插入图片描述

  • 此时，在 234 树中，为全为 2 节点的情况。此时旋转是无用的，删除会导致叶子高度失衡，需要不断向上合并；
  • 对应 2-3-4 树删除操作中兄弟节点为 2 节点，父亲节点也为 2 节点，父节点 key 下移与兄弟节点合并，已父节点看成新的 X，继续回溯；

代码：

...
if(B->color == BLACK){	//黑兄
    ...
    if(BL->color == BLACK && BR->color == BLACK){	// 只有黑侄
        if(P->color == BLACK){	//黑侄黑父
            B->color = RED;
            X = P;
            P = X->parent;	
        }
    }
    ...
}

d. 红兄（黑侄黑父）

按照 2-3-4 树删除操作的原理，我们这里应该检测黑侄 R （第二幅图中是 L）的两个孩子节点是否存在红色节点（对应 2-3-4 树，是否是2节点），但这样做使用的局部变量也会增多，代码实现起来也会变得非常复杂。我们这里做了一个技巧性处理，以P为轴进行旋转，它原理就是前面 2-3-4 树和红黑树的等价关系中讲到的：一颗 2-3-4 对应的红黑树形态并不唯一。
在这里插入图片描述
上面的两种红兄情况，旋转后对应的还是同一颗 2-3-4 树（只是 B 和 P 组成的 3 节点在红黑树的两种不同形态而已），但此时 X 的兄弟节点和侄子节点发生变化，现在 X 的兄弟节点就变成了 R（第二幅图中是 L ），我们正需检查要 R（第二幅图中是 L）的两个孩子节点的颜色。实际上，此时我们又回到上面讨论过的了黑兄的情况。

代码：

...
if(B->color == RED) {	//红兄，变换一下红黑树的形状，继续判断
    if(B == P->right){
    leftRotate(P);
    }else{
    rightRotate(P);
    }
    B->color = BLACK;
    P->color = RED;
    //X节点的P节点没有发生变化，但兄弟节点发生变化
}

234 树中，为全为 2 节点的情况。此时旋转是无用的，删除会导致叶子高度失衡，需要不断向上合并；

  • 对应 2-3-4 树删除操作中兄弟节点为 2 节点，父亲节点也为 2 节点，父节点 key 下移与兄弟节点合并，已父节点看成新的 X，继续回溯；

代码：

...
if(B->color == BLACK){	//黑兄
    ...
    if(BL->color == BLACK && BR->color == BLACK){	// 只有黑侄
        if(P->color == BLACK){	//黑侄黑父
            B->color = RED;
            X = P;
            P = X->parent;	
        }
    }
    ...
}

d. 红兄（黑侄黑父）

按照 2-3-4 树删除操作的原理，我们这里应该检测黑侄 R （第二幅图中是 L）的两个孩子节点是否存在红色节点（对应 2-3-4 树，是否是2节点），但这样做使用的局部变量也会增多，代码实现起来也会变得非常复杂。我们这里做了一个技巧性处理，以P为轴进行旋转，它原理就是前面 2-3-4 树和红黑树的等价关系中讲到的：一颗 2-3-4 对应的红黑树形态并不唯一。

[外链图片转存中...(img-6ds1QgY4-1564129420221)]

上面的两种红兄情况，旋转后对应的还是同一颗 2-3-4 树（只是 B 和 P 组成的 3 节点在红黑树的两种不同形态而已），但此时 X 的兄弟节点和侄子节点发生变化，现在 X 的兄弟节点就变成了 R（第二幅图中是 L ），我们正需检查要 R（第二幅图中是 L）的两个孩子节点的颜色。实际上，此时我们又回到上面讨论过的了黑兄的情况。

代码：

...
if(B->color == RED) {	//红兄，变换一下红黑树的形状，继续判断
    if(B == P->right){
    leftRotate(P);
    }else{
    rightRotate(P);
    }
    B->color = BLACK;
    P->color = RED;
    //X节点的P节点没有发生变化，但兄弟节点发生变化
}
红黑树为什么要有 nil节点_字节三面：小伙子你先跟我说一说红黑树吧
weixin_29163797的博客
01-27 1112
2-3-4树定义所有的叶子节点都拥有相同的深度节点只能是2-节点,3-节点,或者4-节点2节点 包含一个元素的节点,有两个子节点3节点 包含两个元素的节点,有三个子节点4节点 包含三个元素的节点,有四个子节点所有节点都有至少两个子节点或没有子节点来解释一下性质和一些定义任意一个叶子节点(也就是没有子节点的节点)到根节点的距离一致一个节点中可能包括1,2,3个元素,有2,3,4,个子节点,具体可以看...
红黑树精通指南：面试、实战与源码分析
热门推荐
张彦峰的博客
05-12 176万+
本文深入探讨了红黑树的基本原理、实现方法及其在实际应用中的重要性。红黑树是一种自平衡的二叉搜索树，通过一系列颜色标记和旋转操作保证了查找、插入和删除操作的时间复杂度始终保持在 O(log n) 级别。文章首先介绍了红黑树的关键性质和与 AVL 树的区别，分析了红黑树在数据库索引、内存管理等领域的应用。接着，详细讲解了红黑树的插入和删除操作，以及如何通过旋转和颜色调整保持树的平衡。最后，文章通过源码分析展示了红黑树在 Java 和 Linux 内核中的实现，帮助读者更好地理解这一数据结构的实际应用和开发过程。
红黑树详解
最新发布
Simple and clear
04-15 1068
本文，从 BST二叉查找树， 到AVL 平衡二叉树， 再到 RBT 红黑树，为大家 做好清晰的场景分析， 帮助大家记忆。左子树上所有结点的值均小于或等于它的根结点的值。右子树上所有结点的值均大于或等于它的根结点的值。左、右子树也分别为二叉排序树。可见无论哪种情况的失衡，都可以通过旋转来调整。
【红黑树】
2302_79013877的博客
08-11 1103
C++红黑树
红黑树（Red-Black Tree）
xy2006860的专栏
08-22 614
红黑树（Red-Black Tree）是一种自平衡的二叉查找树（Binary Search Tree, BST），它通过在每个节点上附加一个存储位表示颜色（红色或黑色）来确保树的平衡。红黑树能够在 O(log n) 时间内执行插入、删除和查找操作，这里的 n 是树中节点的数量。
红黑树的插入详细图解，直接拿下红黑树
08-17
红黑树是一种自平衡二叉查找树，它的主要特点是在保持二叉查找树特性的同时，通过特定的颜色规则来确保树的平衡，以达到快速查找、插入和删除的目的。红黑树的每个节点都有一个颜色属性，可以是红色或黑色。在插入新...
红黑树java操作代码 红黑树是java里面遍历性能最好数据结构
10-17
红黑树（Red-Black Tree）是一种自平衡二叉查找树，它在计算机科学中扮演着重要的角色，尤其是在实现高效的数据结构和算法时。在Java中，虽然标准库并未直接提供红黑树的类，但我们可以自定义实现，如提供的`Red...
[C++]——红黑树（附源码）
麦麦的博客
10-28 3957
本文为大家进行了红黑树的讲解，关于其定义、性质以及如何插入等等
红黑树与区间树算法实现
04-08
红黑树和区间树是两种在计算机科学中广泛使用的数据结构，主要应用于高效的数据管理和查询。在本实验中，我们探讨了如何用C++来实现这两种数据结构，并提供了相关的可视化功能。 红黑树是一种自平衡二叉查找树，由...
红黑树————
西北的博客
11-01 240
入乡随俗 先摆上红黑树的五大规则 规则是在进行更改红黑树结构（左旋 右旋）所遵循的 一、红黑树四大特性 1.根节点是黑色。 2.每个叶节点（NIL节点，空节点）是黑色的。 3.每个红色节点的两个子节点都是黑色。(从每个叶子到根的所有路径上不能有两个连续的红色节点) 4.从任一节点到其每个叶子的所有路径都包含相同数目的黑色节点。 二、 红黑树的插入操作： treeMap底层的实现为红黑...
什么是红黑树？这篇讲解很全面！
Github中文社区
07-01 535
点击上方“Github中文社区”，关注看遍Github好玩的项目来自：掘金，作者：FiTeen链接：https://juejin.im/post/5e509b27f265da57455b...
红黑树为什么要有 nil节点_5分钟深入理解红黑树（图文详解）
weixin_30082367的博客
01-21 2153
红黑树是平衡树的一种，保证最坏情况下操作时间复杂度为O(lgo(n))。红黑树的应用比较广泛，比如作为C++中STL的set和map的底层数据结构，Java集合中TreeSet和TreeMap的底层数据结构等。学习红黑树，可以把二叉查找树作为参考，这样有助于加深理解。红黑树的操作主要包括节点旋转、插入、删除等操作，下面咱们就一一来看：1、红黑树性质每个节点是红色的，或者是黑色的根节点是黑色的每个叶...
红黑树中nil结点_程序员的进阶课-架构师之路（11）-最容易理解的红黑树
weixin_39630880的博客
12-09 350
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。 本文链接：https://blog.youkuaiyun.com/m0_37609579/article/details/99691569 一、红黑树的定义 【百度百科】红黑树（Red Black Tree） 是一种自平衡二叉查找树，是在计算机科学中用到的一种数据结构，典型的用途是实现关联数组。 它是在...
每个叶子节点(nil)是黑色。_红黑树03——节点的插入与删除-步骤与示例
weixin_39575170的博客
12-03 387
0. 前言我们采用nil代替null来简化操作。如果你之前学过，有一些印象，那跟随本文从上到下画一画插入与删除的全过程，也能加深你的印象与熟练程度。插入和删除的主逻辑，与前面的文章——红黑树01——前传-二叉搜索树中基本一致，只是特别处理了一下nil。最大的不同是，当插入结点和它的父结点都为红色时，违反了红黑树的属性，需要重新调整，共有3种情况（应该是6种，因为是对称的，所以只讨论一半）；删除结点...
红黑树的详细介绍一
qianligaoshan的专栏
05-04 1812
红黑树的性质     红黑树是一棵二叉搜索树，它在每个节点上增加了一个存储位来表示结点的颜色，可以是RED或者是BLACK，红黑树确保没有一条路径会比其它路径长2倍，因而是近似平衡的。     树中的每个结点包含5个属性：color、key、left、right、parent，如果一个结点没有子结点或者是父结点，则该结点相应指针属性的值为NIL。可以把NIL视为指向二叉搜索树 的也结点的指针
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值