红黑树的介绍以及代码实现(C++)

最新推荐文章于 2026-05-25 06:00:00 发布
原创 最新推荐文章于 2026-05-25 06:00:00 发布 · 2.7k 阅读 · 4 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
收录于
Algorithm

当前文章被收录于：

Algorithm
2 篇文章 0 人学习
订阅专栏 查看详情
C++

当前文章被收录于：

C++
1 篇文章 0 人学习
订阅专栏 查看详情
本文详细介绍了红黑树的性质、基本操作（插入、删除、查找）以及如何通过左旋、右旋和翻转节点颜色来维持红黑树的平衡特性。红黑树在保证高效查找的同时，通过红边和黑边的特殊规则实现了动态平衡，使其在Linux内核、构造关联数组等领域广泛应用。

红黑树简单介绍

红黑树是一种满足：

  • 根是黑色的
  • 红色边必须为左子树，且不能有两条连续红边
  • 不存在一个节点有2条红边
  • 根节点到空节点的黑边相等

红黑树是一种大致平衡的二叉树，所以在插入、删除和查找操作时能保证在最坏的情况下时间复杂度为O(lgn)。
二叉搜索树在最坏情形下(当插入的元素是递增的时候)，时间复杂度为O(n)。
所以红黑树在linux内核、构造关联数组等被大量使用。

查找

这个没什么好说，和二叉搜索树类似。主要说下面的插入和删除。

插入

由于插入的节点是红色节点，则可能出现插入之后不满足红黑树的性质。所以需要用红黑树的两个基本操作 左旋 和 右旋 来维持红黑树的性质。
平衡被破坏的情况：

  • 在红色节点上
    左边插入：右旋得到左右两个红色节点，然后翻转节点颜色
    右边插入：左旋得到两条连续红边，再右旋转得到两个红色节点之后翻转节点颜色
  • 在黑色节点上
    右边插入：左旋将红色节点旋转到左边

删除

首先我们来考虑如何删除最小节点

由于直接删除也会破坏红黑树的性质，所以我们需要向上层借红色节点来保证被删除的节点是红色节点。当删除的是最底层的红色节点时，树的根节点到所有空节点的黑高不变，所以不会破坏平衡。

同时这里需要介绍一个重要的操作是翻转节点颜色的逆操作（reverseFlipNode），即将当前节点的颜色设置成黑色，把节点两个孩子的颜色设置成红色。这样就能把红色节点迁移到下层去并且不改变树的高度（根节点除外）。正是由于有这一性质我们才能向上层借节点到下层。

下面来讨论借节点的情况（从树根开始）：
情况1：节点的颜色是红色，左子树是黑色，左子树的左子树也是黑色。
这个说明我们下面可能没有节点的颜色是红色的，也就是没有节点能借。所以我们使用reverseFlipNode操作可以将本层的红色节点向下传递到两个孩子上，这样就能保证下面一层一定有红色节点可用。
但是这里可能出现的情况是：做完reverseFlipNode操作后，节点的右子树的左子树是红色，这种情况在我们最后恢复红色节点位置的时候会出现问题（右旋操作会将这个左子树的颜色直接变成黑色），所以我们需要执行fixNode操作，将这个节点的右子树右旋，然后再将该节点左旋来保证之后能正常恢复。
情况2：节点的左子树是红色 或 节点的左子树的左子树是红色。
这说明我们下面已经有红色节点可以用了，所以我们不需要做使用reverseFlipNode操作。

具体实现步骤（递归）：
递归出口：节点的左子树为空，删除节点并返回空。
如果根节点的孩子都是黑色则设置根节点颜色为红色。
执行上述两种情况来将红边传递到下层保证最左节点可以向上层借到节点。
递归左子树。
如果节点左右子树都是红色，则翻转节点颜色。
如果节点左子树是黑色，右子树是红色，则左旋。

再考虑删除最大节点
删除最大节点与删除最小节点类似，只是我们是删除最右边的节点，这里也要分几种情况：
情况1：节点是红色，左子树不是红色，右子树的左子树不是红色。
这里利用reverseFlipNode操作将红色节点传递给下一层。
情况2：节点是红色，左子树不是红色，右子树的左子树是红色。
下层有红色节点所以这里不做任何操作。
情况3：节点的左子树是红色，右子树的左子树不是红色。
这里利用左旋操作将红色节点旋转到左边保证右子树有红色节点可以借。
情况4：节点的左子树是红色，右子树的左子树也是红色。
这里不做任何操作。

具体实现步骤（递归）：
递归出口：节点的右子树为空，如果节点左子树也为空则删除节点返回空，否则右旋。
如果根节点的孩子都是黑色则设置根节点颜色为红色。
执行上述几种情况保证右子树有节点可借。
如果节点左右子树都是红色，则翻转节点颜色。
如果节点左子树是黑色，右子树是红色，则左旋。

删除节点
在我们有了删除最小节点和删除最大节点的思路后，删除节点就是沿用上面两个方法的思路实现。
具体实现步骤（递归）：
若 key > node->key，执行删除最大节点的情况保证下层有红色节点，递归右子树
若 key < node->key，执行删除最小节点的情况保证下层有红色节点，递归左子树
若 key = node->key，则：
　　当node是红色且左子树为空时，直接删除节点并返回NULL
　　当node是红色且左子树不为空且右子树为空时，删除节点并将node赋值成左子树且颜色和左子树相同
　　当node是红色且左子树不为空且右子树不为空时，执行reverseFlipNode操作并将右子树最小值min复制到node，同时删除node
　　当node是黑色时，这说明node的左子树是红色，所以右旋并递归右子树
如果节点左右子树都是红色，则翻转节点颜色。
如果节点左子树是黑色，右子树是红色，则左旋。

代码实现



#ifndef RBT_H
#define RBT_H
#include <iostream>

enum Color
{
    RED,
    BLACK
};

template<typename K, typename V>
struct Node
{
    K key;
    V val;
    int N;
    Color color;
    Node<K,V>* lNode;
    Node<K,V>* rNode;

    Node()
    {
        this->lNode = NULL;
        this->rNode = NULL;
    }

    Node(K key, V val)
    {
        this->key = key;
        this->val = val;
        this->N = 1;
        this->color = RED;
        this->lNode = NULL;
        this->rNode = NULL;
    }
};

template<typename K, typename V>
class RBT
{
public:
    RBT();
    ~RBT();
    V get(const K& key) const;
    void put(const K& key, const V& val);
    void del(const K& key);
    bool contain(const K& key) const;
    int size() const;
    void clean();
    void print() const;

    K minKey() const;
    void delMin();
    void delMax();
    int countLevel() const;
protected:
    Node<K,V>* root;

    Node<K,V>* rotateLeft(Node<K,V>* node);
    Node<K,V>* rotateRight(Node<K,V>* node);
    void filpNode(Node<K,V>* node);
    void reverseFlipNode(Node<K,V>* node);
    Node<K,V>* fixNode(Node<K,V>* node);
    Node<K,V>* put(Node<K,V>* node, const K& key, const V& val);
    V get(Node<K,V>* node, const K& key) const;
    bool contain(Node<K,V>* node, const K& key) const;
    Node<K,V>* del(Node<K,V>* node, const K& key);
    void clean(Node<K,V>* node);
    int size(Node<K,V>* node) const;
    void print(Node<K,V>* node) const;
    K minKey(Node<K,V>* node) const;
    Node<K,V>* delMin(Node<K,V>* node);
    Node<K,V>* delMax(Node<K,V>* node);
    bool isRed(Node<K,V>* node);
    int countLevel(Node<K,V>* node) const;
};

//构造 析构函数
template<typename K, typename V>
RBT<K,V>::RBT()
{
    this->root = NULL;
}

template<typename K, typename V>
RBT<K,V>::~RBT()
{
    clean(this->root);
}


/******************************************************************** 
函数名称:  isRed
函数参数： @node 节点指针
函数说明:  判断节点的颜色
返回值:    成功返回true 失败返回false
*********************************************************************/
template<typename K, typename V>
bool RBT<K,V>::isRed(Node<K,V>* node)
{
    if (node == NULL || node->color == BLACK)
        return false;
    else
        return true;
}
/******************************************************************** 
函数名称:   put
函数说明:   放入键值对<key,value> 若存在则将原有的value替换成新的value
返回值:     无
*********************************************************************/
template<typename K, typename V>
void RBT<K,V>::put(const K& key, const V& val)
{
    this->root = put(this->root, key, val);
}
template<typename K, typename V>
Node<K,V>* RBT<K,V>::put(Node<K,V>* node, const K& key, const V& val)
{
    if (node == NULL)
        return new Node<K,V>(key, val);
    if (key > node->key)
        node->rNode = put(node->rNode, key, val);
    else if (key < node->key)
        node->lNode = put(node->lNode, key, val);
    else
        node->val = val;

    if (isRed(node->rNode) && !isRed(node->lNode))
        node = rotateLeft(node);
    if (node->lNode != NULL && isRed(node->lNode) && isRed(node->lNode->lNode))
        node = rotateRight(node);
    if (isRed(node->lNode) && isRed(node->rNode))
        filpNode(node);

    node->N = size(node->lNode) + size(node->rNode) + 1;
    return node;
}
/******************************************************************** 
函数名称:   get
函数说明:   获取指定key的value
返回值:     value
*********************************************************************/
template<typename K, typename V>
V RBT<K,V>::get(const K& key) const
{
    return get(this->root, key);
}
template<typename K, typename V>
V RBT<K,V>::get(Node<K,V>* node, const K& key) const
{
    if (node == NULL)
        return NULL;
    if (key > node->key)
        return get(node->rNode, key);
    else if (key < node->key)
        return get(node->lNode, key);
    else
        return node->val;
}
/******************************************************************** 
函数名称:   clean
函数说明:   清空表
返回值:    无 
*********************************************************************/
template<typename K, typename V>
void RBT<K,V>::clean()
{
    clean(this->root);
    this->root = NULL;
}
template<typename K, typename V>
void RBT<K,V>::clean(Node<K,V>* node)
{
    if (node == NULL)
        return ;
    clean(node->lNode);
    clean(node->rNode);
    delete node;
}
/******************************************************************** 
函数名称:   size
函数说明:   无
返回值:     表的大小
*********************************************************************/
template<typename K, typename V>
int RBT<K,V>::size() const
{
    return size(this->root);
}
template<typename K, typename V>
int RBT<K,V>::size(Node<K,V>* node) const
{
    if (node == NULL)
        return 0;
    return size(node->rNode) + size(node->lNode) + 1;
}
/******************************************************************** 
函数名称:   del
函数说明:   删除某个key
返回值:     无
*********************************************************************/
template<typename K ,typename V>
void RBT<K,V>::del(const K& key)
{
    this->root = del(this->root, key);
}
template<typename K, typename V>
Node<K,V>* RBT<K,V>::del(Node<K,V>* node, const K& key)
{
    if (node == NULL)
        return NULL;
    if (!isRed(this->root->lNode) && !isRed(this->root->rNode))
            this->root = RED;
    if (key > node->key)
    {
        if (isRed(node->lNode))
            node = rotateRight(node);
        if (node->rNode != NULL && isRed(node) && !isRed(node->rNode) && !isRed(node->rNode->lNode))
            reverseFlipNode(node);
        node->rNode = del(node->rNode, key);
    }
    else if (key < node->key)
    {
        if (node->lNode != NULL && isRed(node) && !isRed(node->lNode) && !isRed(node->lNode->lNode))
            reverseFlipNode(node);
        if (node->rNode != NULL && isRed(node->rNode) && isRed(node->rNode->lNode))
            node = fixNode(node);
        node->lNode = del(node->lNode, key);
    }
    else
    {
        if (isRed(node))
        {
            if (node->lNode == NULL)
            {
                delete node;
                return NULL;
            }
            else
            {
                node->key = minKey(node->rNode);
                node->val = get(node->key);
                node->rNode = delMin(node->rNode);
            }
        }
        else
        {
            node = rotateRight(node);
            node->rNode = del(node->rNode, key);
        }

    }
    if (isRed(node->rNode) && !isRed(node->lNode))
        node = rotateLeft(node);
    if (isRed(node->lNode) && isRed(node->rNode))
        filpNode(node);

    node->N = size(node->rNode) + size(node->lNode) + 1;
    return node;
}
/******************************************************************** 
函数名称:   print
函数说明:   打印表中内容
返回值:     无
*********************************************************************/
template<typename K, typename V>
void RBT<K,V>::print() const
{
    print(this->root);
}
template<typename K, typename V>
void RBT<K,V>::print(Node<K,V>* node) const
{
    if (node == NULL)
        return ;
    print(node->lNode);
    std::cout << node->key << " : " << node->val << "  :  " << node->N << "  :  " << node->color << std::endl;
    print(node->rNode);
}
/******************************************************************** 
函数名称:   contain
函数说明:   是否包含key
返回值:     包含返回true 不包含返回false
*********************************************************************/
template<typename K, typename V>
bool RBT<K,V>::contain(const K& key) const
{
    return contain(this->root, key);
}
template<typename K, typename V>
bool RBT<K,V>::contain(Node<K,V>* node, const K& key) const
{
    if (node == NULL)
        return false;
    if (key > node->key)
        get(node->rNode, key);
    else if (key < node->key)
        get(node->lNode, key);
    else
        return true;
}
/******************************************************************** 
函数名称:  rotateLeft
函数参数： 需要旋转的节点指针
函数说明:  将右节点旋转到左边并设置为红色
返回值:    旋转后的树根指针
*********************************************************************/
template<typename K, typename V>
Node<K,V>* RBT<K,V>::rotateLeft(Node<K,V>* node)
{
    Node<K,V>* rNode = node->rNode;
    node->rNode = rNode->lNode;
    rNode->lNode = node;
    rNode->color = node->color;
    node->color = RED;
    node->N = size(node->lNode) + size(node->rNode) + 1;
    rNode->N = size(rNode->lNode) + size(rNode->rNode) + 1;
    return rNode;
}

/******************************************************************** 
函数名称:  rotateRight
函数参数： 需要旋转的节点指针
函数说明:  将左节点旋转到右边并设置为红色
返回值:    旋转后的树根指针
*********************************************************************/
template<typename K, typename V>
Node<K,V>* RBT<K,V>::rotateRight(Node<K,V>* node)
{
    Node<K,V>* lNode = node->lNode;
    node->lNode = lNode->rNode;
    lNode->rNode = node;
    lNode->color = node->color;
    node->color = RED;
    node->N = size(node->lNode) + size(node->rNode) + 1;
    lNode->N = size(lNode->lNode) + size(lNode->rNode) + 1;
    return lNode;
}

/******************************************************************** 
函数名称:  flipNode
函数参数： 节点指针
函数说明:  将节点的左右子树的颜色变成黑色 同时节点颜色变成红色
返回值:    无
*********************************************************************/
template<typename K, typename V>
void RBT<K,V>::filpNode(Node<K,V>* node)
{
    node->color = RED;
    node->lNode->color = BLACK;
    node->rNode->color = BLACK;
}

/******************************************************************** 
函数名称:  reverseFlipNode
函数参数： @node 节点指针
函数说明:  反向翻转节点和子节点的颜色 将节点颜色变成黑色 子节点红色
返回值:    无
*********************************************************************/
template<typename K, typename V>
void RBT<K,V>::reverseFlipNode(Node<K,V>* node)
{
    node->color = BLACK;
    node->lNode->color = RED;
    node->rNode->color = RED;
}

/******************************************************************** 
函数名称:  fixRedNode
函数参数： @node 节点指针
函数说明:  修复反向反转后节点 node->rNode->lNode 为红色的情况
返回值:    
*********************************************************************/
template<typename K, typename V>
Node<K,V>* RBT<K,V>::fixNode(Node<K,V>* node)
{
    node->rNode = rotateRight(node->rNode);
    node = rotateLeft(node);
    return node;
}

/******************************************************************** 
函数名称:  minKey
函数参数： 无
函数说明:  返回表中最小的key
返回值:    key
*********************************************************************/
template<typename K, typename V>
K RBT<K,V>::minKey() const
{
    return minKey(this->root);
}
template<typename K, typename V>
K RBT<K,V>::minKey(Node<K,V>* node) const
{
    if (node->lNode == NULL)
        return node->key;
    else
        minKey(node->lNode);
}
/******************************************************************** 
函数名称:  delMin
函数参数： 无
函数说明:  删除表中最小key 需要保证节点的颜色是红色
返回值:    无
*********************************************************************/
template<typename K, typename V>
void RBT<K,V>::delMin()
{
    this->root = delMin(this->root);
}
template<typename K, typename V>
Node<K,V>* RBT<K,V>::delMin(Node<K,V>* node)
{
    if (node == NULL)
        return NULL;
    if (node->lNode == NULL)
    {
        delete node;
        return NULL;
    }
    if (!isRed(this->root->lNode) && !isRed(this->root->rNode))
            this->root = RED;
    if (isRed(node) && !isRed(node->lNode) && !isRed(node->lNode->lNode))
        reverseFlipNode(node);
    if (node->rNode != NULL && isRed(node->rNode) && isRed(node->rNode->lNode))
        node = fixNode(node);

    node->lNode = delMin(node->lNode);

    //恢复红黑树的性质
    if (isRed(node->lNode) && isRed(node->rNode))
        filpNode(node);
    if (!isRed(node->lNode) && isRed(node->rNode))
        node = rotateLeft(node);

    node->N = size(node->lNode) + size(node->rNode) + 1;
    return node;
}

/******************************************************************** 
函数名称:  delMax
函数参数： 无
函数说明:  删除树中最大key 需要保证节点的颜色是红色
返回值:    无
*********************************************************************/
template<typename K, typename V>
void RBT<K,V>::delMax()
{
    this->root = delMax(this->root);
}

template<typename K, typename V>
Node<K,V>* RBT<K,V>::delMax(Node<K,V>* node)
{
    if (node == NULL)
        return NULL;
    if (node->rNode == NULL)
    {
        if (isRed(node->lNode))
            node = rotateRight(node);
        else
        {
                delete node;
                return NULL;
        }
    }
    if (!isRed(this->root->lNode) && !isRed(this->root->rNode))
        this->root = RED;
    if (isRed(node->lNode) && !isRed(node->rNode->lNode))
        node = rotateRight(node);
    if (isRed(node) && !isRed(node->lNode) && !isRed(node->rNode->lNode))
        reverseFlipNode(node);

    node->rNode = delMax(node->rNode);

    if (isRed(node->lNode) && isRed(node->rNode))
        filpNode(node);
    if (isRed(node->rNode) && !isRed(node->lNode))
        node = rotateLeft(node);

    node->N = size(node->lNode) + size(node->rNode) + 1;
    return node;
}
template<typename K, typename V>
int RBT<K,V>::countLevel() const
{
    return countLevel(this->root);
}
#endif
标签
#红黑树 #C++ #二叉树 #搜索
红黑树（附完整C代码）
热门推荐
weewqrer的博客
07-09 2万+
版权声明：原创不易，转载请注明转自weewqrer 红黑树红黑树简介首先红黑树是一棵二叉搜索树，它在每个结点上增加了一个存储位来表示结点的颜色，可以是RED或者BLACK。通过对一条从根节点到NIL叶节点（指空结点或者下面说的哨兵）的简单路径上各个结点在颜色进行约束，红黑树确保没有一条路径会比其他路径长出2倍，因而是近似平衡的。 用途红黑树和AVL树一样都对插入时间、删除时间和查找时间提供了最好可
【C语言】红黑树详解以及C语言模拟
qq_40205510的博客
04-22 1685
红黑树是一种自平衡二叉查找树，它能够保持树的平衡，从而保证查找、插入和删除的最坏情况时间复杂度为O(log n)。红黑树通过旋转操作和颜色变更来维护树的性质，适用于需要维护有序数据集合的场景。在Java和C++的STL中，红黑树得到了广泛的应用。
红黑树（图文详解+C语言200行代码实现）
zhao_Tao_WA的博客
07-04 4807
本文以图文形式详细介绍了红黑树的性质以及各种调整策略，包括插入调整和删除调整，最后以200行精简的C语言代码实现了红黑树
高缺失率时空数据插补实战：从随机森林到扩散模型的性能对比
weixin_30363285的博客
05-23 505
数据缺失是数据分析与机器学习建模中普遍面临的挑战，尤其在时空数据领域，传感器故障、传输中断等问题常导致数据不完整。数据插补技术旨在基于已知数据的模式和关联性，合理估算缺失值，为后续分析提供可靠基础。其核心原理在于利用数据的时空相关性（如时间周期性、空间邻近性）及与外部驱动因素（如交通、气象）的关联构建预测模型。这项技术的价值在于能将不完整的数据集转化为可用于高质量分析和预测的可用资产，广泛应用于环境监测、交通流量预测、金融风控等领域。本文聚焦于一个极具挑战性的场景——PM2.5监测数据缺失率高达82%，通过
红黑树定义及其代码实现
公众号：风景邮递Yuan的博客
06-16 1108
红黑树是一种自平衡二叉查找树，它在每个节点上增加了一个存储位来表示节点的颜色，可以是红色或黑色。通过对任何一条从根到叶子节点的路径上各个节点的颜色进行约束，红黑树确保没有一条路径会比其他路径长出两倍，因此，红黑树是近似平衡的。5. 对于每个节点，从该节点到其所有后代叶子节点的简单路径上，均包含相同数目的黑色节点。4. 如果一个节点是红色的，则它的两个子节点都是黑色的。3. 每个叶子节点（NIL节点，空节点）是黑色的。1. 每个节点要么是红色，要么是黑色。2. 根节点是黑色的。
【C++进阶】红黑树：平衡规则原理、三大调整场景与完整代码实现
最新发布
Z2382430464的博客
05-25 391
红黑树是一棵二叉搜索树，它的每个结点增加一个存储位来表示结点的颜色，可以是红色或黑色。通过对任何一条从根到叶子的路径上各个结点的颜色进行约束，红黑树确保没有一条路径会比其他路径长出 2 倍，因而是接近平衡的。
红黑树原理详解及代码实现
CodePanda@GPF的博客
05-23 3109
红黑树原理及代码实践
红黑树的原理及代码实现
qq_52093121的博客
06-28 1379
红黑树的原理这篇博文讲解的很详细了，不熟悉红黑树的定义可以看看：红黑树的详细原理讲解咱们直接进入代码实现讲解：创建一棵红黑树，先从创建红黑树的节点开始： 1.红黑树首先是一个二叉树，所以需要一个左儿子节点的指针，右儿子节点的指针 2.红黑树是有BALCK和RED两种颜色的，所以每个节点应该有颜色 3.红黑树是Key-Value存储的 4.因为之后要进行旋转等调整，所以还需要一个父节点的信息 所以红黑树节点定义如下： 2.创建红黑树整体结构 红黑树有五个性质： 为了方便整棵红黑树的维护，我们默认叶子节点是空
红黑树实现代码+详细注释
ltrbless的博客
05-19 1804
简介 因为网上太多红黑树原理的讲解了，不需要再去讲解原理，所以在这就提供一些将原理不错的博客，然后主要是给红黑树代码的实现，用的c++语言模板实现红黑树，并附带详细注释。（目前只实现了红黑树的插入与查询操作，并可视化打印红黑树）。 红黑树插入操作的流程图：（参考：红黑树总结 - lukazan - 博客园 (cnblogs.com)，该博客用图详细解释了红黑树插入操作的事件，然后我用红色对其事件进行了编号，以便于和代码注释相对应） 红黑树的本质其实就是2-3树，在上面推荐的博客中也有提到。 代码
平衡搜索树之红黑树
Salmon_lee的博客
08-15 245
五种平衡搜索树 • AVL trees • 2-3 trees • 2-3-4 trees • B-trees• Red-black trees 红黑树的性质 1. 每个结点都是红/黑的 2. 根结点和叶结点是黑色的 3. 红色结点的parent是黑色的 4. 简单路径的黑色结点个数相同（黑高bk） 红黑树的树高 将红色结点都合并到黑色结点中（2,3,4-tree），则由性质3...
红黑树的详细实现(C++)
code_peak
10-08 9449
红黑树概念(concept) 树型结构主要用于搜索，一直是科学领域的重要演算法，当中探讨了树可能遇到的问题：树的成长可能偏向于一边，也就是不平衡现象。 二叉树是常见且广泛使用的一种树，面临其可能退化成链表的潜藏缺点，在使用上难免让人担心其效率。此外，在一些应用上，可能不希望这样的不平衡的可能性发生。所以具有自动平衡左右数量分布效果的演算算法早在 1962 年被提出，称为 AVL 树。这种平衡成长的二叉搜索树被称为自平衡二叉搜索树。 接下来，介绍同为自平衡二叉搜索树的红黑树对平衡性的要求比 AVL 树还要宽松
红黑树（C++）
mmz123_的博客
02-27 4057
文章目录红黑树红黑树的概念红黑树的性质红黑树结点的定义红黑树的插入操作情况一情况二情况三红黑树的验证用红黑树封装map、set红黑树的迭代器封装map封装set 红黑树 红黑树的概念 红黑树的概念 红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的。 红黑树和AVL树都是高效的平衡二叉树，增删改查的时间复杂度都是O()，红黑树不追求绝对平衡，
红黑树（C语言实现）
qq_49723651的博客
06-29 6000
红黑树c语言实现
红黑树的简单实现（C++）
学习日记
07-16 1016
红黑树是一种二叉搜索树，但是在每个结点上增加一个表示该点颜色的存储位，可以是Red或者Black,通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出两倍，相对于AVL树来说，红黑树是平衡。
数据结构：红黑树的插入实现(C++)
li209779的博客
11-19 974
以上就是我对于红黑树插入实现的总结。！！
红黑树C语言代码实现
北街lhy的博客
07-23 1638
通过对红黑树的左旋、右旋、变色操作，以及前驱节点和后继节点的查找，我们能够维护红黑树的平衡性，确保其高效的查找、插入和删除操作。本文详细介绍了这些辅助操作的实现代码，为深入理解红黑树提供了基础。红黑树通过在插入和删除节点后进行必要的旋转和变色操作，确保树的高度始终保持平衡，从而保证高效的查找、插入和删除操作。本文详细讲解了红黑树的插入操作及其调整机制，通过具体代码展示了实现过程。理解红黑树的这些基本操作对于掌握高级数据结构和算法具有重要意义。红黑树的删除操作比插入操作复杂得多，需要考虑多种情况。
红黑树(c++)实现
m0_70657810的博客
11-24 1085
我们这里直接实现K V模型的红黑树,为了方便后序的旋转操作,将红黑树的结点定义为三叉链结构,除此之外还新加入了一个成员变量,用于表示结点的颜色.RED,BLACK,_kv(kv),_col(RED){}为什么构造结点时,默认将结点的颜色设置为红色?当我们向红黑树插入结点时,若我们插入的是黑色结点,那么插入路径上黑色结点的数目就比其他路径上黑色结点数目多了一个,即破坏了红黑树的性质四,此时我们就需要对红黑树进行调整.
数据结构初阶——红黑树的实现（C++）
2301_80065652的博客
09-17 2012
红黑树是一种近似平衡的二叉搜索树，通过红黑节点和特定规则维持平衡。其核心性质包括：根节点为黑色、红色节点的子节点必须为黑色、从任一节点到叶节点的路径包含相同数量黑色节点。实现时默认新节点为红色，插入后通过变色和旋转（单旋或双旋）调整平衡。与严格平衡的AVL树相比，红黑树牺牲部分平衡性换取更高效的插入删除操作，实际应用更广泛。验证红黑树需检查二叉搜索树性质及红黑特性。红黑树整体实现包含节点定义、插入、旋转、查找等操作，复杂度为O(logN)。
红黑树详解及代码实现(C++)
m0_59074850的博客
12-15 741
红黑树的简介和代码实现 包括旋转变色画图讲解
理解红黑树及代码实现
qq_38412637的博客
01-19 8199
1.红黑树定义 红黑树是一颗 红-黑的平衡二叉树,它具有二叉树的所有特性,是一颗自平衡的排序二叉树.(树中任何节点值都大于左子节点的值，而且都小于右子节点的值),其检索效率高，它是一颗空树或它的左右两个子树高度差的绝对值不超过1，并且左右子树都是平衡二叉树. 最坏的情况下 是一边倒的情况 在这种情况下，如果我们要在树中查找g节点，就需要顺着根节点往下找,时间复杂度约为O(n)常数级。那么红黑...
OpenClaw界面操作手册：命令行与交互模式的正确打开方式
gaoxiang_120的专栏
03-16 3106
"test": {"description": "运行项目的测试套件","prompt": "请执行项目的测试命令，并分析测试结果。如果有失败的测试，请提供修复建议。},"lint": {"description": "运行代码检查","prompt": "请运行代码检查工具，分析所有警告和错误，并提供修复建议。},"doc": {"description": "为当前文件生成文档","prompt": "请为当前打开的文件生成完整的API文档，包括函数说明、参数描述、返回值类型和使用示例。
自己修改安卓刷机包ROM教程.pdf
自己修改安卓刷机包ROM教程.pdf
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值