红黑树代码

最新推荐文章于 2025-07-19 22:31:43 发布
原创 最新推荐文章于 2025-07-19 22:31:43 发布 · 195 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#算法 #数据结构

这篇博客详细介绍了红黑树的实现，包括插入、删除节点以及保持平衡的修复算法。文章通过C++代码展示了红黑树节点的定义、颜色属性、旋转操作以及查找、插入、删除等基本操作。此外，还提供了获取中序遍历序号、前一个和后一个节点的方法。

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

#include<stdio.h>
//Key中的内容可能更复杂，比如字符串等。
struct Key{
    int value;
};
struct RBTNode{
    Key key;
    int lcount;
    int rcount;
    RBTNode* lchild;
    RBTNode* rchild;
    RBTNode* parent;
    bool color;
};
class RBT{
private:
    const static bool RED = true;
    const static bool BLACK = false;
    RBTNode* m_null;
    RBTNode* m_root;
    void clear() {
        RBTNode* p = m_root;
        while (p != m_null) {
            if (p->lchild != m_null) {
                p = p->lchild;
            }
            else if (p->rchild != m_null) {
                p = p->rchild;
            }
            else {
                RBTNode* temp = p;
                p = p->parent;
                if (temp == p->lchild) {
                    p->lchild = m_null;
                }
                else {
                    p->rchild = m_null;
                }
                delete temp;
            }
        }
    }
    void delFixup(RBTNode* delNode) {
        RBTNode* p = delNode;
        while (p != m_root && p->color == BLACK) {
            if (p == p->parent->lchild) {
                RBTNode* sibling = p->parent->rchild;
                if (sibling->color == RED) {
                    sibling->color = BLACK;
                    p->parent->color = RED;
                    leftRotate(p->parent);
                    sibling = p->parent->rchild;
                }
                if (sibling->lchild->color == BLACK
                    && sibling->rchild->color == BLACK
                   ) {
                    sibling->color = RED;
                    p = p->parent;
                }
                else {
                    if (sibling->rchild->color == BLACK) {
                        sibling->lchild->color = BLACK;
                        sibling->color = RED;
                        rightRotate(sibling);
                        sibling  = sibling->parent;
                    }
                    sibling->color = sibling->parent->color;
                    sibling->parent->color = BLACK;
                    sibling->rchild->color = BLACK;
                    leftRotate(sibling->parent);
                    p = m_root;
                }
            }
            else {
                RBTNode* sibling = p->parent->lchild;
                if (sibling->color == RED) {
                    sibling->color = BLACK;
                    p->parent->color = RED;
                    rightRotate(p->parent);
                    sibling = p->parent->lchild;
                }
                if (sibling->lchild->color == BLACK
                    && sibling->rchild->color == BLACK
                   ) {
                    sibling->color = RED;
                    p = p->parent;
                }
                else {
                    if (sibling->lchild->color == BLACK) {
                        sibling->rchild->color = BLACK;
                        sibling->color = RED;
                        leftRotate(sibling);
                        sibling = sibling->parent;
                    }
                    sibling->color = sibling->parent->color;
                    sibling->parent->color = BLACK;
                    sibling->lchild->color = BLACK;
                    rightRotate(sibling->parent);
                    p = m_root;
                }
            }
        }
        p->color = BLACK;
    }
    void insertFixup(RBTNode* insertNode) {
        RBTNode* p = insertNode;
        while (p->parent->color == RED) {
            if (p->parent == p->parent->parent->lchild) {
                RBTNode* parentRight = p->parent->parent->rchild;
                if (parentRight->color == RED) {
                    p->parent->color = BLACK;
                    parentRight->color = BLACK;
                    p->parent->parent->color = RED;
                    p = p->parent->parent;
                }
                else {
                    if (p == p->parent->rchild) {
                        p = p->parent;
                        leftRotate(p);
                    }
                    p->parent->color = BLACK;
                    p->parent->parent->color = RED;
                    rightRotate(p->parent->parent);
                }
            }
            else {
                RBTNode* parentLeft = p->parent->parent->lchild;
                if (parentLeft->color == RED) {
                    p->parent->color = BLACK;
                    parentLeft->color = BLACK;
                    p->parent->parent->color = RED;
                    p = p->parent->parent;
                }
                else {
                    if (p == p->parent->lchild) {
                        p = p->parent;
                        rightRotate(p);
                    }
                    p->parent->color = BLACK;
                    p->parent->parent->color = RED;
                    leftRotate(p->parent->parent);
                }
            }
        }
        m_root->color = BLACK;
    }
    //比较两个Key的大小。这里可能有更复杂的比较，如字符串比较等。
    inline int keyCmp(const Key& key1, const Key& key2) {
        return key1.value - key2.value;
    }
    //把一个节点向左下方移一格，并让他原来的右子节点代替它的位置。
    inline void leftRotate(RBTNode* node) {
        RBTNode* right = node->rchild;
        node->rchild = right->lchild;
        node->rcount = right->lcount;
        node->rchild->parent = node;
        right->parent = node->parent;
        if (right->parent == m_null) {
            m_root = right;
        }
        else if (node == node->parent->lchild) {
            node->parent->lchild = right;
        }
        else {
            node->parent->rchild = right;
        }
        right->lchild = node;
        right->lcount += node->lcount + 1;
        node->parent = right;
    }
    //把一个节点向右下方移一格，并让他原来的左子节点代替它的位置。
    inline void rightRotate(RBTNode* node) {
        RBTNode* left = node->lchild;
        node->lchild = left->rchild;
        node->lcount = left->rcount;
        node->lchild->parent = node;
        left->parent = node->parent;
        if (left->parent == m_null) {
            m_root = left;
        }
        else if (node == node->parent->lchild) {
            node->parent->lchild = left;
        }
        else {
            node->parent->rchild = left;
        }
        left->rchild = node;
        left->rcount += node->rcount + 1;
        node->parent = left;
    }
    //找到子树中最大的一个节点
    RBTNode* treeMax(RBTNode* root) {
        RBTNode* result = root;
        while (result->rchild != m_null) {
            result = result->rchild;
        }
        return result;
    }
    //找到子树中最小的一个节点
    RBTNode* treeMin(RBTNode* root) {
        RBTNode* result = root;
        while (result->lchild != m_null) {
            result = result->lchild;
        }
        return result;
    }
public:
    RBT() {
        m_null = new RBTNode;
        m_null->color = BLACK;
        m_root = m_null;
    }
    ~RBT() {
        clear();
        delete m_null;
    }
    //找到从小到大排序后下标为i的节点。i从0开始。
    RBTNode* atIndex(int i) {
        RBTNode* result = m_root;
        if (i > result->lcount + result->rcount) {
            result = NULL;
        }
        else {
            while (i != result->lcount) {
                if (i < result->lcount) {
                    result = result->lchild;
                }
                else {
                    i -= result->lcount + 1;
                    result = result->rchild;
                }
            }
        }
        return result;
    }
    //删除一个节点
    void del(RBTNode* node) {
        RBTNode* toDel = node;
        if (node->lchild != m_null && node->rchild != m_null) {
            toDel = treeNext(node);
        }
        RBTNode* temp = toDel;
        while (temp->parent != m_null) {
            if (temp == temp->parent->lchild) {
                temp->parent->lcount--;
            }
            else {
                temp->parent->rcount--;
            }
            temp = temp->parent;
        }
        RBTNode* replace = toDel->lchild != m_null? toDel->lchild: toDel->rchild;
        replace->parent = toDel->parent;
        if (replace->parent == m_null) {
            m_root = replace;
        }
        else if (toDel == toDel->parent->lchild) {
            replace->parent->lchild = replace;
        }
        else {
            replace->parent->rchild = replace;
        }
        if (toDel != node) {
            node->key = toDel->key;
        }
        if (toDel->color == BLACK) {
            //修改树，以保持平衡。
            delFixup(replace);
        }
        delete toDel;
    }
    void init() {
        clear();
        m_root = m_null;
    }
    //插入一个节点
    void insert(const Key& key) {
        RBTNode* node = new RBTNode;
        node->key = key;
        node->lcount = 0;
        node->rcount = 0;
        node->lchild = m_null;
        node->rchild = m_null;
        node->color = RED;
        RBTNode* p = m_root;
        RBTNode* leaf = m_null;
        while (p != m_null) {
            leaf = p;
            if (keyCmp(node->key, p->key) < 0) {
                p->lcount++;
                p = p->lchild;
            }
            else {
                p->rcount++;
                p = p->rchild;
            }
        }
        node->parent = leaf;
        if (leaf == m_null) {//如果是空树。
            m_root = node;
        }
        else if (keyCmp(node->key, leaf->key) < 0) {
            leaf->lchild = node;
        }
        else {
            leaf->rchild = node;
        }
        //修改树，以保持平衡。
        insertFixup(node);
    }
    int nodeCount() {
        return m_root != m_null? m_root->lcount + m_root->rcount + 1: 0;
    }
    //按照key查找一个节点。
    RBTNode* search(const Key& key) {
        RBTNode* result = m_root;
        while (result != m_null && keyCmp(key, result->key) != 0) {
            result = keyCmp(key, result->key) < 0
                     ? result->lchild: result->rchild;
        }
        return result == m_null? NULL: result;
    }

    //把树中节点的值放进一个数组。
    void toArray(int* array) {
        RBTNode* p = treeMin(m_root);
        int i = 0;
        while (p != m_null) {
            array[i] = p->key.value;
            i++;
            p = treeNext(p);
        }
    }
    //一个节点在中序遍列中的下一个节点。
    RBTNode* treeNext(RBTNode* node) {
        RBTNode* result;
        if (node->rchild != m_null) {
            result = treeMin(node->rchild);
        }
        else {
            result = node->parent;
            RBTNode* temp = node;
            while (result != m_null && temp == result->rchild) {
                temp = result;
                result = result->parent;
            }
        }
        return result;
    }
1    //一个节点在中序遍列中的前一个节点。
    RBTNode* treePre(RBTNode* node) {
        RBTNode* result;
        if (node->lchild != m_null) {
            result = treeMax(node->rchild);
        }
        else {
            result = node->parent;
            RBTNode* temp = node;
            while (result != m_null && temp == result->lchild) {
                temp = result;
                result = result->parent;
            }
        }
        return result;
    }
};
[C++]——红黑树（附源码）
麦麦的博客
10-28 4054
本文为大家进行了红黑树的讲解，关于其定义、性质以及如何插入等等
【模板】红黑树
wakawaka
12-22 549
#define BLACK 1 #define RED 0 class bst { private: struct Node { int value; bool color; Node *leftTree, *rightTree, *parent; Node() { color = RED;
从零手写红黑树（C++实现详解）
最新发布
tanyongxi66的博客
07-19 2469
学完AVL树之后对我来说，红黑树可能更容易理解，还有水了这么多篇，该认真写一篇了，哈哈哈哈。红黑树顾名思义就是得有红色和黑色的树，红黑树利用红色和黑色节点来创建二叉平衡搜索树红黑树的5条核心特点：（1）每个节点是红色或黑色（2）根节点必须是黑色（3）所有叶子节点（NIL/空节点）是黑色（NIL节点是红黑树中所有空指针的替代节点，表示树的叶子位置。（4）红色节点的子节点必须是黑色（即不能有连续的黑色节点）（5）从任意节点到其所有叶子节点的路径上，黑色节点的数量相同。
红黑树源代码
03-03
c编写的红黑书，根据算法导论编写，宏内红黑书红黑书大地啊的
红黑树的代码实现
09-19
写了一个红黑树的类，实现了插入、删除、查找功能；用了模板实现，是.h形式的头文件
红黑树代码详解，参考零声学院
11-03
零声学院的教程可能包括具体的代码实现，向初学者详细解释红黑树的性质以及如何通过编程实现红黑树。在代码实现中，开发者会注意以下几点： - 定义节点结构，包括节点颜色、键值和指向左右子节点的指针。 - 实现节点...
红黑树代码实现及分析2
02-25
在"红黑树代码实现及分析"这个主题中，你可以找到关于红黑树的具体实现细节，包括如何初始化树、插入和删除节点的步骤，以及如何进行颜色翻转和旋转等操作。通过分析这些代码，你可以更好地理解红黑树的工作原理，并...
移植linux内核的红黑树代码，并适配到windows64中，在vs2022中编译通过
08-12
本项目的目标是将Linux内核中的红黑树代码移植到Windows 64位环境中，并在Visual Studio 2022（VS2022）中完成编译。 移植工作主要包括以下几个关键步骤： 1. **理解红黑树算法**：首先，需要深入理解红黑树的基本...
红黑树(RBtree)实现代码
02-17
一个基于C++的红黑树实现, RedBlackTree, C++, 二叉树, 平衡二叉树
红黑树的代码
四夕日 月
09-20 1265
我写的红黑树代码。
每日一省之————红黑树的java实现
lhever_的博客
10-17 1588
今天本打算复习红黑树，可是红黑树的概念都记得有些模糊不清了。所以网搜复习了一下其基本概念。也因此发现了一篇介绍红黑树的好文章。这篇文章配有大量图示，甚至有动态图演示左旋和右旋操作。所以也给大家分享下： 浅谈算法和数据结构: 九 平衡查找树之红黑树至于自己的实现代码，本人还是希望像之前的几篇关于算法的文章一样，尽可能的将相关的API实现全面一些。不过，已经很晚了，改天补上。既然没有代码，还写这堆废话
红黑树代码（c++，基于struct而非class）
ybszzz的博客
10-06 1161
if ((*root)->right == nullptr || (*root)->right->nodecolor==black)//叔叔节点是黑色，做节点变换。if ((*root)->left == nullptr || (*root)->left->nodecolor == black)//叔叔节点是黑色，做节点变换。else if ((*root)->right->nodecolor == red)//叔叔节点是红色，将叔叔父亲和爷爷全部变色。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值