手撕红黑树

最新推荐文章于 2023-11-27 15:53:13 发布
最新推荐文章于 2023-11-27 15:53:13 发布
阅读量173 收藏
点赞数 1
分类专栏： 数据结构与算法 C++ 文章标签： 数据结构 Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/supermario19/article/details/128693642
版权

一. 红黑树的定义

红黑树（Red Black Tree）是一种自平衡二叉查找树，红黑树插入，删除，查找都是O（logn）的时间复杂度。

二. 红黑树的性质

  1. 每个节点或红或黑

  1. 根结点为黑

  1. 每个叶子节点为黑

  1. 若一个节点为红，则它的孩子必须为黑

  1. 对每个节点，从该节点到其他子孙节点的所有路径上包含相同数目的黑色节点

第五条性质尤为重要，第五条性质表明红黑树不同于AVL树。红黑树平衡的是黑高，而AVL树平衡的是子树高度。

三. 红黑树的用途

  1. map, set底层采用红黑树进行存储

  1. 定时器

  1. Linux进程调度(CFS(Completely FairScheduler))

  1. Epoll的实现，内核会在内存中开辟一个空间存放epoll的红黑树，并将每个epollfd加入树中进行管理

四. 红黑树的插入

    • 红黑树节点旋转

红黑树在插入和删除过程中，由于破坏黑高，需要进行调整，而调整的过程中就会涉及到节点旋转的操作。可以说节点旋转是红黑树中非常重要的操作之一。

// 左旋操作
void RBtree::leftRotate(RBtree_node *x)
{
    RBtree_node *y = x->right;

    x->right = y->left;
    if (y->left != nil)
    {
        y->left->parent = x;
    }

    y->parent = x->parent;
    if (x->parent == nil)
    {
        root = y;
    }
    else if (x->parent->left == x)
    {
        x->parent->left = y;
    }
    else
    {
        x->parent->right = y;
    }

    y->left = x;
    x->parent = y;
}

// 右旋操作
void RBtree::rightRotate(RBtree_node *y)
{
    RBtree_node *x = y->left;

    y->left = x->right;
    if (x->right != nil)
    {
        x->right->parent = y;
    }

    x->parent = y->parent;
    if (y->parent == nil)
    {
        root = x;
    }
    else if (y->parent->left == y)
    {
        y->parent->left = x;
    }
    else
    {
        y->parent->right = x;
    }

    x->right = y;
    y->parent = x;
}

    • 红黑树插入节点

红黑树插入节点类似于二叉搜索树的插入，都是要先在树上寻找到合适的插入位置，再进行节点插入（插入叶子节点），只不过红黑树在插入结束之后要进行节点调整。所以在红黑树中插入节点有以下几个步骤：1. 寻找插入位置

2. 创建新节点

3. 插入，调整

// 节点插入
void RBtree::insert(KEY_TYPE key, VALUE_TYPE value)
{
    RBtree_node *pre = nil;
    RBtree_node *cur = root;

    // 寻找插入位置
    while (cur != nil)
    {
        pre = cur;
        if (key < cur->key)
        {
            cur = cur->left;
        }
        else if (key > cur->key)
        {
            cur = cur->right;
        }
        else
        {
            return;
        }
    }
    
    // 创建新节点
    RBtree_node *node = new RBtree_node(RED);
    node->key = key;
    node->value = value;
    node->left = nil;
    node->right = nil;
    node->parent = pre;

    // 新节点插入红黑树
    if (pre == nil)
    {
        root = node;
    }
    else
    {
        if (key < pre->key)
        {
            pre->left = node;
        }
        else
        {
            pre->right = node;
        }
    }
    
    // 插入调整
    insert_fixup(node);
}

    • 红黑树插入调整

若插入节点时，将插入节点颜色设置为黑色，插入红黑树中必定会将黑高平衡破坏，这样每次插入节点都会带来红黑树的调整。

若插入节点时，将插入节点颜色设置为红色，插入红黑树一定不会破坏黑高，但是会破坏性质4， 此时若插入节点父节点为红色节点，则需要进行调整。现在以插入节点的父节点为祖父节点的左孩子为例：

情况一：叔父节点为红色

此时将父亲节点染为黑色，叔父节点染为黑色，将祖父节点染为红色。之后从祖父节点开始继续向上迭代检查。

情况2：叔父节点为黑色，插入节点为父亲节点右孩子

此时将以插入节点父节点为轴心进行左旋，此时转化为情况3

情况3. 叔父节点为黑色，插入节点为父亲节点左孩子。

此时将父节点染为黑色，将祖父节点染为红色，以祖父节点为轴型进行右旋。

// 插入修复
void RBtree::insert_fixup(RBtree_node *x)
{
    // 迭代检查父节点是否为红色，若为红色继续调整
    while (x->parent->color == RED)
    {
        // 当父节点为祖父节点左孩子
        if (x->parent == x->parent->parent->left)
        {
            // 叔父节点
            RBtree_node *y = x->parent->parent->right;

            // 情况1
            if (y->color == RED)
            {
                x->parent->color = BLACK;
                y->color = BLACK;
                x->parent->parent->color = RED;

                x = x->parent->parent;
            }
            else
            {
                // 情况2
                if (x == x->parent->right)
                {
                    x = x->parent;
                    leftRotate(x);
                }
                // 情况3
                x->parent->color = BLACK;
                x->parent->parent->color = RED;
                rightRotate(x->parent->parent);
            }
        }
        else
        {
            RBtree_node *y = x->parent->parent->left;
            if (y->color == RED)
            {
                x->parent->color = BLACK;
                y->color = BLACK;
                x->parent->parent->color = RED;

                x = x->parent->parent;
            }
            else
            {
                if (x == x->parent->left)
                {
                    x = x->parent;
                    rightRotate(x);
                }
                x->parent->color = BLACK;
                x->parent->parent->color = RED;
                leftRotate(x->parent->parent);
            }
        }
    }
    // 保证根节点一直为黑色
    root->color = BLACK;
}

五.红黑树的删除

    • 寻找一个子树上的最小节点和最大节点

RBtree_node *RBtree::mini_node(RBtree_node *x)
{
    while (x->left != nil)
    {
        x = x->left;
    }
    return x;
}

RBtree_node *RBtree::max_node(RBtree_node *x)
{
    while (x->right != nil)
    {
        x = x->right;
    }
    return x;
}

    • 寻找一个节点的后继节点

当寻找一个节点的后继节点时，存在两种情况：

情况1：该节点存在右子树，此时后继节点为右子树的最小值节点

情况2：该节点不存在右子树，此时后继节点为父节点不断迭代向上搜索，直到当前节点为父节点的左孩子节点，此时父节点为后继节点，例如13节点的后继节点为15

RBtree_node *RBtree::successor(RBtree_node *node)
{
    // 情况1
    if (node->right != nil)
    {
        return mini_node(node->right);
    }
    // 情况2
    else
    {
        RBtree_node *pre = node->parent;
        RBtree_node *cur = node;
        while (pre != nil && cur == pre->right)
        {
            cur = pre;
            pre = pre->parent;
        }
        return pre;
    }
}

    • 红黑树删除节点

红黑树删除时分为如下几种情况：

    • 该删除节点不存在左右子树

若遇到该情况，则直接删除节点

    • 删除节点存在右左子树或右子树

若遇到该情况，将该节点直接删除并且将左子树或右子树代替被删除节点位置。

    • 删除节点存在左子树且存在右子树

若遇到该情况，则寻找插入节点z的直接后继节点y，将y节点替换z节点值，最后删除y节点，y的右孩子连接y的父节点。

// 删除节点
void RBtree::erase(KEY_TYPE key)
{
    // y节点的孩子节点
    RBtree_node *x = nil;
    // 真正删除节点
    RBtree_node *y = nil;
    // 被覆盖节点
    RBtree_node *z = search_node(key);
    if (z == nil)
    {
        return;
    }
    // 情况1, 2
    if (z->left == nil || z->right == nil)
    {
        y = z;
    }
    else
    {
        // 情况3
        y = successor(z);
    }
    
    // x为y的左或右子树
    if (y->left != nil)
    {
        x = y->left;
    }
    if (y->right != nil)
    {
        x = y->right;
    }
    
    // 将x代替y的位置
    x->parent = y->parent;
    if (y->parent == nil)
    {
        root = x;
    }
    else if (y == y->parent->left)
    {
        y->parent->left = x;
    }
    else
    {
        y->parent->right = x;
    }
    
    // 将y值覆盖z值
    if (y != z)
    {
        z->key = y->key;
        z->value = y->value;
    }

    // 若删除节点y为黑色节点，则破坏黑高，进行调整
    if (y->color == BLACK)
    {
        erase_fixup(x);
    }
}

    • 红黑树删除节点调整

接上文，已知条件，y节点为黑色

调整节点为y节点的孩子节点x，若x节点颜色为红色，则直接将x节点染为黑色即可，此时不会破坏黑高。

调整节点为y节点的孩子节点x，若x节点颜色为黑色，此时破坏黑高，需要进行调整。

此时分为四种情况（以x节点为y节点左孩子节点为例）

情况1. 兄弟节点为红色：

解决方法：将兄弟节点染为黑色，将父亲节点染为红色，进行左旋。

情况2：兄弟节点为黑色，且兄弟节点的左孩子右孩子节点都为黑色节点

解决方法：将兄弟节点染为红色

情况3. 兄弟节点为黑色，兄弟节点的左孩子为红色，右孩子为黑色

解决方法：此时将兄弟节点左孩子染为黑色，兄弟节点染为黑色，以兄弟节点为轴心进行右旋，转换为情况4

情况4.兄弟节点右孩子为红色

解决方法：将x父节点右孩子染为父节点颜色，x父节点染为黑色，兄弟节点右孩子染为黑色，以x父节点为轴心进行左旋，左旋结束之后结束循环。

void RBtree::erase_fixup(RBtree_node *x)
{
    while (x != root && x->color == BLACK)
    {
        if (x == x->parent->left)
        {
            RBtree_node *y = x->parent->right;
            // 情况1
            if (y->color == RED)
            {
                y->color = BLACK;
                x->parent->color = RED;
                leftRotate(x->parent);

                y = x->parent->right;
            }
            
            // 情况2
            if (y->left->color == BLACK && y->right->color == BLACK)
            {
                y->color = RED;
                x = x->parent;
            }
            else
            {
                // 情况3
                if (y->right->color == BLACK)
                {
                    y->color = RED;
                    y->left->color = BLACK;
                    rightRotate(y);

                    y = x->parent->right;
                }
                // 情况4
                y->color = x->parent->color;
                x->parent->color = BLACK;
                y->right->color = BLACK;
                leftRotate(x->parent);

                x = root;
            }
        }
        else
        {
            RBtree_node *y = x->parent->left;
            if (y->color == RED)
            {
                y->color = BLACK;
                x->parent->color = RED;
                rightRotate(x->parent);

                y = x->parent->left;
            }

            if (y->left->color == BLACK && y->right->color == BLACK)
            {
                y->color = RED;
                x = x->parent;
            }
            else
            {
                if (y->left->color == BLACK)
                {
                    y->color = RED;
                    y->right->color = BLACK;
                    leftRotate(y);

                    y = x->parent->left;
                }

                y->color = x->parent->color;
                x->parent->color = BLACK;
                y->left->color = BLACK;
                rightRotate(x->parent);

                x = root;
            }
        }
    }
    x->color = BLACK;
}

六. 完整代码

#ifndef RBTREE_H
#define RBTREE_H

typedef enum _COLOR
{
    BLACK = 0,
    RED = 1
} COLOR;

using KEY_TYPE = int;
using VALUE_TYPE = int;

class RBtree_node
{
public:
    KEY_TYPE key;
    VALUE_TYPE value;
    COLOR color;
    class RBtree_node *left;
    class RBtree_node *right;
    class RBtree_node *parent;

    RBtree_node(COLOR c)
        : color(c),
          key(-1),
          value(-1),
          parent(nullptr),
          left(nullptr),
          right(nullptr)
    {
    }
};

class RBtree
{
public:
    RBtree()
    {
        nil = new RBtree_node(BLACK);
        root = nil;
    }

    // 插入
    void insert(KEY_TYPE key, VALUE_TYPE value);

    // 删除
    void erase(KEY_TYPE key);

    // 寻找某个Key值是否存在
    bool find(KEY_TYPE key);

    // 层序遍历打印红黑树
    void print_level();

    // 中序遍历红黑树
    void print_middle();

private:
    // 左旋
    void leftRotate(RBtree_node *x);

    // 右旋
    void rightRotate(RBtree_node *y);

    // 插入修复
    void insert_fixup(RBtree_node *x);

    // 删除修复
    void erase_fixup(RBtree_node *x);

    // 查询某个key节点
    RBtree_node *search_node(KEY_TYPE key);

    // 寻找某个节点后继节点
    RBtree_node *successor(RBtree_node *node);

    // 寻找某颗子树上最小节点
    RBtree_node *mini_node(RBtree_node *x);

    // 寻找某颗子树上最大节点
    RBtree_node *max_node(RBtree_node *x);

private:
    RBtree_node *root;
    RBtree_node *nil;
};

#endif // RBTREE_H
#include "rbtree.h"
#include <iostream>
#include <queue>
#include <stack>

using namespace std;

void RBtree::insert(KEY_TYPE key, VALUE_TYPE value)
{
    RBtree_node *pre = nil;
    RBtree_node *cur = root;
    while (cur != nil)
    {
        pre = cur;
        if (key < cur->key)
        {
            cur = cur->left;
        }
        else if (key > cur->key)
        {
            cur = cur->right;
        }
        else
        {
            return;
        }
    }

    RBtree_node *node = new RBtree_node(RED);
    node->key = key;
    node->value = value;
    node->left = nil;
    node->right = nil;
    node->parent = pre;

    if (pre == nil)
    {
        root = node;
    }
    else
    {
        if (key < pre->key)
        {
            pre->left = node;
        }
        else
        {
            pre->right = node;
        }
    }
    insert_fixup(node);
}

void RBtree::erase(KEY_TYPE key)
{
    RBtree_node *x = nil;
    RBtree_node *y = nil;
    RBtree_node *z = search_node(key);
    if (z == nil)
    {
        return;
    }
    if (z->left == nil || z->right == nil)
    {
        y = z;
    }
    else
    {
        y = successor(z);
    }

    if (y->left != nil)
    {
        x = y->left;
    }
    if (y->right != nil)
    {
        x = y->right;
    }

    x->parent = y->parent;
    if (y->parent == nil)
    {
        root = x;
    }
    else if (y == y->parent->left)
    {
        y->parent->left = x;
    }
    else
    {
        y->parent->right = x;
    }

    if (y != z)
    {
        z->key = y->key;
        z->value = y->value;
    }

    if (y->color == BLACK)
    {
        erase_fixup(x);
    }
}

bool RBtree::find(KEY_TYPE key)
{
    RBtree_node *node = search_node(key);
    if (node != nil)
    {
        return true;
    }
    else
    {
        return false;
    }
}

void RBtree::print_level()
{
    if (root == nil)
    {
        return;
    }
    queue<RBtree_node *> q;
    RBtree_node *cur_end = root;
    RBtree_node *next_end = nullptr;
    q.push(root);
    int level = 1;

    while (!q.empty())
    {
        RBtree_node *node = q.front();
        q.pop();

        if (node != nil)
        {
            cout << "key:" << node->key << " value:" << node->value
                 << " color:" << (node->color == RED ? "RED" : "BLACK")
                 << " level:" << level << endl;
        }
        else
        {
            cout << "nil node"
                 << " level:" << level << endl;
        }

        if (node->left)
        {
            q.push(node->left);
            next_end = node->left;
        }
        if (node->right)
        {
            q.push(node->right);
            next_end = node->right;
        }

        if (node == cur_end)
        {
            if (cur_end != next_end)
            {
                level++;
            }
            cur_end = next_end;
        }
    }
}

void RBtree::print_middle()
{
    stack<RBtree_node *> s;
    RBtree_node *cur = root;
    while (cur != nil || !s.empty())
    {
        if (cur != nil)
        {
            s.push(cur);
            cur = cur->left;
        }
        else
        {
            RBtree_node *node = s.top();
            s.pop();
            cout << "key = " << node->key << "value = " << node->value << endl;
            cur = node->right;
        }
    }
}

void RBtree::leftRotate(RBtree_node *x)
{
    RBtree_node *y = x->right;

    x->right = y->left;
    if (y->left != nil)
    {
        y->left->parent = x;
    }

    y->parent = x->parent;
    if (x->parent == nil)
    {
        root = y;
    }
    else if (x->parent->left == x)
    {
        x->parent->left = y;
    }
    else
    {
        x->parent->right = y;
    }

    y->left = x;
    x->parent = y;
}

void RBtree::rightRotate(RBtree_node *y)
{
    RBtree_node *x = y->left;

    y->left = x->right;
    if (x->right != nil)
    {
        x->right->parent = y;
    }

    x->parent = y->parent;
    if (y->parent == nil)
    {
        root = x;
    }
    else if (y->parent->left == y)
    {
        y->parent->left = x;
    }
    else
    {
        y->parent->right = x;
    }

    x->right = y;
    y->parent = x;
}

void RBtree::insert_fixup(RBtree_node *x)
{
    while (x->parent->color == RED)
    {
        if (x->parent == x->parent->parent->left)
        {
            RBtree_node *y = x->parent->parent->right;
            if (y->color == RED)
            {
                x->parent->color = BLACK;
                y->color = BLACK;
                x->parent->parent->color = RED;

                x = x->parent->parent;
            }
            else
            {
                if (x == x->parent->right)
                {
                    x = x->parent;
                    leftRotate(x);
                }
                x->parent->color = BLACK;
                x->parent->parent->color = RED;
                rightRotate(x->parent->parent);
            }
        }
        else
        {
            RBtree_node *y = x->parent->parent->left;
            if (y->color == RED)
            {
                x->parent->color = BLACK;
                y->color = BLACK;
                x->parent->parent->color = RED;

                x = x->parent->parent;
            }
            else
            {
                if (x == x->parent->left)
                {
                    x = x->parent;
                    rightRotate(x);
                }
                x->parent->color = BLACK;
                x->parent->parent->color = RED;
                leftRotate(x->parent->parent);
            }
        }
    }
    root->color = BLACK;
}

void RBtree::erase_fixup(RBtree_node *x)
{
    while (x != root && x->color == BLACK)
    {
        if (x == x->parent->left)
        {
            RBtree_node *y = x->parent->right;
            if (y->color == RED)
            {
                y->color = BLACK;
                x->parent->color = RED;
                leftRotate(x->parent);

                y = x->parent->right;
            }

            if (y->left->color == BLACK && y->right->color == BLACK)
            {
                y->color = RED;
                x = x->parent;
            }
            else
            {
                if (y->right->color == BLACK)
                {
                    y->color = RED;
                    y->left->color = BLACK;
                    rightRotate(y);

                    y = x->parent->right;
                }

                y->color = x->parent->color;
                x->parent->color = BLACK;
                y->right->color = BLACK;
                leftRotate(x->parent);

                x = root;
            }
        }
        else
        {
            RBtree_node *y = x->parent->left;
            if (y->color == RED)
            {
                y->color = BLACK;
                x->parent->color = RED;
                rightRotate(x->parent);

                y = x->parent->left;
            }

            if (y->left->color == BLACK && y->right->color == BLACK)
            {
                y->color = RED;
                x = x->parent;
            }
            else
            {
                if (y->left->color == BLACK)
                {
                    y->color = RED;
                    y->right->color = BLACK;
                    leftRotate(y);

                    y = x->parent->left;
                }

                y->color = x->parent->color;
                x->parent->color = BLACK;
                y->left->color = BLACK;
                rightRotate(x->parent);

                x = root;
            }
        }
    }
    x->color = BLACK;
}

RBtree_node *RBtree::search_node(KEY_TYPE key)
{
    RBtree_node *node = root;
    while (node != nil)
    {
        if (key < node->key)
        {
            node = node->left;
        }
        else if (key > node->key)
        {
            node = node->right;
        }
        else
        {
            return node;
        }
    }
    return nil;
}

RBtree_node *RBtree::successor(RBtree_node *node)
{
    if (node->right != nil)
    {
        return mini_node(node->right);
    }
    else
    {
        RBtree_node *pre = node->parent;
        RBtree_node *cur = node;
        while (pre != nil && cur == pre->right)
        {
            cur = pre;
            pre = pre->parent;
        }
        return pre;
    }
}

RBtree_node *RBtree::mini_node(RBtree_node *x)
{
    while (x->left != nil)
    {
        x = x->left;
    }
    return x;
}

RBtree_node *RBtree::max_node(RBtree_node *x)
{
    while (x->right != nil)
    {
        x = x->right;
    }
    return x;
}

测试代码：

#include "rbtree.h"
#include <iostream>

int main()
{
    RBtree tree;
    for (int i = 0; i < 10; i++)
    {
        tree.insert(i, i);
    }
    tree.print_level();
    std::cout << "after erase" << std::endl;
    tree.erase(3);
    tree.print_level();
    tree.print_middle();
    return 0;
}

supermario19
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
28.红黑树_1.wmv（目前数据结构最好的视频,共42集，需要哪一集的知识自己下，一集3积分）
03-13
26红黑树 27红黑树_0 28红黑树_1 29红黑树_2 30红黑树_3 31红黑树_4 32红黑树_5 33红黑树_6 34堆 35堆排序 36哈希与映射的概述 37B树有什么用 38B树的概念 39图_邻接矩阵 40图_邻接表 41图_DFS 42图_BFS
机器学习实战-手撕决策树
05-18
决策树模型在鸢尾花数据集上的实现，包括完整代码和可视化以及讲解，准确率很高，亲测可用！
【数据结构】手撕红黑树
学了就忘是正常现象
02-26 8761
红黑树和AVL树一样，因其逻辑复杂，面试时现场要求手撕就是纯纯刁难面试者。但某大厂面试官曾要求某些求职者现场手撕红黑树（我赌5毛，让面试官撕，他也撕不出来，而且你家员工上班手搓红黑树啊？），随后求职遭遇被发到网上吐槽，这便有了“手撕红黑树”的梗，也让红黑树成为了知名度最高的数据结构。（话虽如此，对于红黑树的性质、插入思想等概念还是需要掌握的）
深入浅出C++ ——手撕红黑树
weixin_55051736的博客
02-22 577
/节点的值域 Colour _col;//节点的颜色 RBTreeNode < K , V > * _left;//节点的左孩子 RBTreeNode < K , V > * _right;//节点的右孩子 RBTreeNode < K , V > * _parent;//节点的双亲 };
C++手撕红黑树
分享学习的知识，记录我的技术成长道路
08-07 624
红黑树在表意上就是一棵每个节点带有颜色的二叉搜索树，并通过对节点颜色的控制，使该二叉搜索树达到尽量平衡的状态。红黑树确保没有一条路径比其他路径长两倍。和AVL树不同的是，AVL树是一棵平衡树，而红黑树可能平衡也可能不平衡(因为是尽量平衡的状态)每一次插入都对根节点置为黑操作，因为第一种情况可能导致根节点不是黑。同时对根节点置黑也并不违反三条规定。...
【高阶数据结构】手撕红黑树（超详细版本）
qq_42996461的博客
01-08 2107
但行好事，莫问前程
手撕红黑树Java_手撕红黑树(1)-预备知识
weixin_33817338的博客
02-28 93
本篇文章为红黑树的预备知识，暂且不涉及节点颜色。二叉树左旋左旋的过程是将x的右子树绕x逆时针旋转，使得x的右子树成为x的父节点，同时修改相关节点的引用。旋转之后，二叉查找树的属性仍然满足。示例：旋转前|/------3(null)-------\| |1(null) /------10(null)\| |6(null) ...
手撕红黑树代码（Java）
qq_52485934的博客
04-02 182
红黑树详细讲解，详细的源码讲解
手撕红黑树(图文并茂)
weixin_73869209的博客
11-27 140
大家好,今天带着大家手撕红黑树一 . 红黑树的概念红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。通过对任何 一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的。// 新创建的节点默认是红色RED,BLACK思考：在节点的定义中，为什么要将节点的默认颜色给成红色的？不妨来看一下如果默认值给成黑色会发生什么?
天天说手撕红黑树？你真的能撕的下来吗？（详细解释+代码注释）
CYK_byte的博客
12-22 995
/新增结点，默认必须是红色}}//根节点}}注意：每次新增结点必须是红色的，因为如果某一个分支上增加一个黑色结点，根据红黑树的特点，那么其他每一个分支上也必须都增加一个黑色结点，但实际上我需要增加一个结点，而为了满足红黑树特点多增加的这些结点是没有意义的；如果添加一个红色节点，我们只需要通过调整颜色，即可满足要求；
手撕红黑树（Red-Black Tree）
林慢慢的博客
07-06 2730
红黑树 （C++实现）
Python手撕算法Recursion
最新发布
12-25
Python手撕算法Recursion
Python手撕算法RadixSort
12-25
Python手撕算法RadixSort
Python手撕算法QuickSort
12-25
Python手撕算法QuickSort
Python手撕算法Queue
12-25
Python手撕算法Queue
Python手撕算法mysingleton
12-25
Python手撕算法mysingleton
Python手撕算法MergeSort
12-25
Python手撕算法MergeSort
Python手撕算法Lists
12-25
Python手撕算法Lists
手撕transformer
09-28
手撕Transformer是指通过自己编写代码实现一个Transformer模型，而不是直接使用现有的Transformer框架或库。手撕Transformer的过程可以帮助我们更好地理解Transformer模型的原理和细节。 要手撕Transformer，首先...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值