C++红黑树的完整实现

最新推荐文章于 2024-07-22 17:11:23 发布
最新推荐文章于 2024-07-22 17:11:23 发布
阅读量1.2k 收藏
点赞数 1
分类专栏： 数据结构 文章标签： 红黑树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liuhuiyan_2014/article/details/45915681
版权 
#include <iostream>

using namespace std;

typedef enum Color
{
    RED,
    BLACK,
}Color;
template<typename Type>
struct RbNode
{
    Color color;
    Type data;
    RbNode<Type> *parent;
    RbNode<Type> *left;
    RbNode<Type> *right;
    RbNode(Type d=Type()):left(NULL),right(NULL),parent(NULL),data(d),color(RED){}
};

template<typename Type>
class RbTree
{
    public:
    RbTree()
    {
        Root = NULL;
        Nul  = NULL;
        Start = BuyNode();      
        Start->color = BLACK;   
    }
    void Insert(Type ar[],int n)
    {
        for(int i=0;i<n;i++)
        {
            _Insert(Root,ar[i]);
        }
    }
    private:
    bool _Insert(RbNode<Type> *p,int val)
    {
        RbNode<Type> *pr = NULL;
        while(p!=NULL)
        {
            if(p->data == val)return false;
            pr = p;
            if(p->data > val)p=p->left;
            else p=p->right;
        }
        if(pr==NULL)
            {
                Root = BuyNode(val);
                p = Root;
            }
        else
            p = BuyNode(val);
        if(pr!=NULL)
                {
                    if(pr->data>val)    
                                pr->left = p;
                    else
                            pr->right = p;
                    p->parent = pr;
                }
        Init_Set(Root,p);
        Root->color = BLACK;
    }
    RbNode<Type>* BuyNode(Type d=Type())
    {
        RbNode<Type> *s = new RbNode<Type>(d);
        return s;
    }
    bool Init_Set(RbNode<Type> *&t,RbNode<Type> *&p)
    {
        p->color = RED;
        if(p->parent!=Nul && p->parent->color == RED)
            {

                if(p->parent->parent->left==p->parent)
                {
                    if(p->parent->left==p)
                        {
                            RbNode<Type> *s = p->parent->parent->right;
                            if(s!=Nul && s->color==RED)
                            {
                                p->parent->color = BLACK;
                                s->color = BLACK;
                                p=s->parent;
                                Init_Set(Root,p);
                            }
                            else 
                            {
                            p->parent->color = BLACK;
                                    p->parent->parent->color=RED;
                                p = p->parent->parent;
                              StateR(Root,p);
                            }
                        }
                        else
                        {
                            RbNode<Type> *s = p->parent->parent->right;
                            if(s!=Nul && s->color==RED)
                            {
                                p->parent->color = BLACK;
                                s->color = BLACK;
                                p=s->parent;
                                Init_Set(Root,p);
                            }
                            else
                            {
                                p = p->parent;  
                                StateL(Root,p);
                                Init_Set(Root,p->left);
                            }                   
                        }
                }
                else
                {
                    if(p->parent->right==p)//  \ s
                    {
                        RbNode<Type> *s = p->parent->parent->left;
                        if(s!=Nul && s->color == RED)
                        {   
                            p->parent->color = BLACK;
                            s->color = BLACK;
                            p = s->parent;
                            Init_Set(Root,p);
                        }
                        else
                        {
                            p->parent->color = BLACK;
                                p->parent->parent->color=RED;       
                                p=p->parent->parent;    
                                StateL(Root,p);
                        }
                    }
                    else
                    {   
                            RbNode<Type> *s = p->parent->parent->left;
                            if(s!=Nul && s->color==RED)
                            {
                                p->parent->color = BLACK;
                                s->color = BLACK;
                                p=s->parent;
                                Init_Set(Root,p);
                            }
                            else
                            {
                                p = p->parent;  
                                StateR(Root,p);
                                Init_Set(Root,p->right);
                            }                   
                    }
                }
            }
    }
    void StateL(RbNode<Type> *&t,RbNode<Type> *&p)
    {
        int flogs = 0;

    RbNode<Type> *q = p->right;
        RbNode<Type> *save = p->parent;

   if(p==t){
            flogs++;
            }
        p->right = q->left;
        if(q->left)
            q->left->parent = p;

        q->left = p;
        p->parent = q;

        if(save)
                {
                    if(save->left==p)
                        save->left=q;
                    else
                        save->right=q;
                    q->parent=save;
                }
                p = q;
        if(flogs==1)
            {Root = p;Root->parent=Start;}
    }
    void StateR(RbNode<Type> *&t,RbNode<Type> *&p)
    {
        int flogs = 0;

        RbNode<Type> *q = p->left;
        if(t==p)
            flogs++;
        RbNode<Type> *save = p->parent;
        p->left = q->right;
        if(q->right!=NULL)
        q->right->parent = p;

        q->right = p;
        p->parent = q;

        if(save!=NULL)
            if(save->left==p)
                {
                    save->left = q;
                }
            else 
                {
                    save->right=q;
                }
        q->parent = save;
        p = q;
            if(flogs==1){Root = p;Root->parent=Start;}
    }
    public:
    void Printf()
    {
        Printf(Root);
    }
    void Remove(Type val)
    {
        Remove(Root,val);
    }
    private:
    void Remove(RbNode<Type> *t,Type val)
    {
        RbNode<Type> *p = t;
        RbNode<Type> *pr = NULL;
        while(p!=NULL)
        {
            if(p->data == val)break;
            if(p->data>val)p=p->left;
            else p=p->right;
        }
        if(p==NULL)return ;
        else
        {
    //          t = p;
            if(p->left!=NULL && p->right!=NULL)
                {
                    pr = p->right;
                    while(pr->left!=NULL)pr=pr->left;
                    t->data = pr->data;
                    p = pr;
                }
                pr = p->parent;
                if(t->left==p)
                        {
                            RbNode<Type> *s = p->right;
                            t->left = s;
                            if(s!=NULL)
                              {
                                s->parent = NULL;
                                s->parent = t;
                                }
                            if(p->color==BLACK)
                            {
                             if(s!=Nul && s->color==RED)
                                 {
                                    s->color=BLACK;
                                 }
                           else if(s!=Nul && s->color==BLACK)
                            {   
                                    Remove_Set(Root,s); 
                              }

                        }
                else
                        {
                            RbNode<Type> *s = p->right;
                            t->left = s;
                            if(s!=NULL)
                              {
                                s->parent = NULL;
                                s->parent = t;
                                }
                            if(p->color==BLACK)
                            {
                             if(s!=Nul && s->color==RED)
                                 {
                                    s->color = BLACK;
                                 }
                                else if(s!=Nul  && s->color==BLACK)
                                {
                                    Remove_Set(Root,s);
                                }
                            }
                        }
                }
        }
        Root->color = BLACK;
        delete p;p=NULL;
    }
    void Remove_Set(RbNode<Type> *&t,RbNode<Type> *p)
    {
        RbNode<Type> *s  = p->parent->right;
        while(p!=Start && p->color!=RED)
        {
            if(s!=NULL)
            {   
                if(s->color==RED)
                {
                    s->parent->color = RED;
                    s->color = BLACK;
                    s=s->parent;
                    StateL(Root,s);
                }
                else if(s->color==BLACK)
                {   
                    if(s->left!=NULL && s->right!=NULL)
                    {   
                        if(s->left->color==BLACK && s->left->right->color==BLACK)
                        {
                            s->color = RED;
                            s->parent->color = BLACK;
                            p = s->parent;
                        }
                        else if(s->right->color==BLACK && s->left->color==RED)
                        {
                            StateR(Root,s);
                        }
                        else if(s->right->color==RED && s->color==BLACK)
                        {   
                            s=s->parent;
                            StateL(Root,s);
                            p = s;
                        }
                    }
                }
            }
        }       
    }
    void Printf(RbNode<Type> *&t)
    {
        if(t==NULL)return ;
        else
        {
            Printf(t->left);
            cout<<t->data<<":"<<t->color<<"\t";
            Printf(t->right);
        }
    }
    RbNode<Type> *Start;
    RbNode<Type> *Root;
    RbNode<Type> *Nul;
};

int main()
{
    int a[]={0,2,3,1,5,10,15,7,8};
    RbTree<int> rb;
    rb.Insert(a,9);
    rb.Remove(5);
    rb.Printf();
    return 0;
}
让我们荡起双脚
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++——红黑树
蜗@牛的博客
07-10 273
一、红黑树的概念 红黑树是一种二叉搜索树，但是每个结点都有表示结点的颜色，可以是Red或Black。 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出2倍，因而是接近平衡的二叉搜索树。 二、红黑树的特性 1、每个节点要么是黑色，要么是红色。 2、根节点是黑色。 3、每个叶子节点（NIL）是黑色。 4、每个红色结点的两个子结点一定都是黑色。 5、任意一结点到每个叶子结点的路径都包含数量相同的黑结点。 三、红黑树的实现 1、红黑树的插入 （1）根节点为空，则直接插入
C++红黑树
zhao19971014的博客
11-09 586
红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的
红黑树（C++实现）
最新发布
2202_75331338的博客
07-22 1012
◉ 如果u节点存在，则其一定是黑色的，那么cur节点原来的颜色一定是黑色的，现在看到红色的原因是因为cur的子树在调整的过程中将cur节点的颜色由黑色改成红色。◉ 如果u节点不存在，则cur一定是新插入节点，因为如果cur不是新插入节点，则cur和p一定有一个节点的颜色是黑色，就不满足性质4：每条路径黑色节点个数相同。p为g的左孩子，cur为p的右孩子，则对p先进行左单旋，回到情况二 再对g进行右单旋。p为g的右孩子，cur为p的左孩子，则对p先进行右单旋，回到情况二 再对g进行左单旋。
C++【红黑树】
芊樱烛渊的博客
11-05 1018
AVLTree：要求左右高度差不超过1红黑树：AVLTree过分严格，可能会导致过分的旋转，那能不能不要那么严格呢？需要达到的目的，最长路径不超过最短路径的二倍。也就是说，我们的AVLTree是严格平衡，我们的红黑树是不严格平衡，而是近似平衡结果：相对而言，插入同样的数据，AVL树的旋转更多，红黑树的旋转次数更少假设N是100w，AVL树为logN的高度，也就是大概20左右但是我们的红黑树的话，最短的高度大概是logN也就是20左右，最深的应该为2*logN，为40次左右。
【C++】红黑树
奔赴在热爱征程上的小小孩~
05-14 752
红黑树概念与实现，使用红黑树封装 map 与 set
C++红黑树实现过程
09-15
在C++中实现红黑树，需要理解并遵循红黑树的五个性质： 1. 每个节点要么是红色，要么是黑色。 2. 根节点是黑色。 3. 所有叶子节点（NIL或空节点）是黑色。 4. 如果一个节点是红色，则它的两个子节点都是黑色。 5. ...
红黑树-基于C++实现的红黑树数据结构.zip
03-21
例如，在C++标准模板库(STL)中，`std::set`和`std::map`就是基于红黑树实现的。 在C++中实现红黑树时，通常会定义一个名为`RBTree`的类，包含私有成员变量（如根节点指针）和公共成员函数（如`insert`, `delete`, `...
基于C++红黑树与哈希表的实现
05-08
`Red_black_tree-code`可能是包含红黑树实现的源代码文件，可以参考其中的实现细节，学习如何在C++中构建和操作自定义数据结构。 总的来说，掌握红黑树和哈希表的原理和C++实现对于提升编程技能和解决复杂问题具有...
红黑树的c++实现，提供完整代码
03-21
以下是关于红黑树C++实现的一些补充说明: 1. 红黑树性质 - 每个节点都是红色或黑色 - 根节点是黑色 - 所有叶节点(NIL节点)都是黑色 - 如果一个节点是红色,那么它的两个子节点都是黑色(不存在两个连续的红节点) ...
C++之红黑树
cls的博客
05-23 2011
红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的。 4.2.2 红黑树的性质 1. 每个结点不是红色就是黑色 2. 根节点是黑色的 3. 如果一个节点是红色的，则它的两个孩子结点是黑色的，但是没有连续的红节点 4. 对于每个结点，从该结点到其所有后代叶结点的简单路径...
C++:红黑树
zhang_si_hang的博客
08-21 1731
1.红黑树的概念红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的。（最长的路径不超过最短路径的2倍，近似平衡）2.红黑树的性质1.每个结点不是红色就是黑色2.根节点是黑色的3. 如果一个节点是红色的，则它的两个孩子结点是黑色的(没有连续的红色节点)
C++ 红黑树
weixin_53946312的博客
01-28 1513
红黑树
C++红黑树实现Map
07-28
当然，我可以帮你实现一个基于红黑树的Map数据结构。下面是一个简单的C++代码示例： ```cpp #include <iostream> enum Color { RED, BLACK }; template <typename K, typename V> struct Node { K key; V value; Color color; Node* left; Node* right; Node* parent; // 构造函数 Node(const K& k, const V& v, Color c = RED) : key(k), value(v), color(c), left(nullptr), right(nullptr), parent(nullptr) {} }; template <typename K, typename V> class RBTreeMap { public: RBTreeMap() : root(nullptr) {} // 向红黑树中插入键值对 void insert(const K& key, const V& value) { Node<K, V>* node = new Node<K, V>(key, value); if (root == nullptr) { root = node; node->color = BLACK; } else { Node<K, V>* curr = root; Node<K, V>* parent = nullptr; while (curr != nullptr) { parent = curr; if (key < curr->key) curr = curr->left; else if (key > curr->key) curr = curr->right; else { curr->value = value; // 更新值 return; } } node->parent = parent; if (key < parent->key) parent->left = node; else parent->right = node; insertFixup(node); } } // 查找指定键的值 V find(const K& key) const { Node<K, V>* curr = root; while (curr != nullptr) { if (key < curr->key) curr = curr->left; else if (key > curr->key) curr = curr->right; else return curr->value; } return V(); // 未找到，返回默认值 } private: Node<K, V>* root; // 对红黑树进行修复以维持红黑树的性质 void insertFixup(Node<K, V>* node) { while (node->parent != nullptr && node->parent->color == RED) { if (node->parent == node->parent->parent->left) { Node<K, V>* uncle = node->parent->parent->right; if (uncle != nullptr && uncle->color == RED) { node->parent->color = BLACK; uncle->color = BLACK; node->parent->parent->color = RED; node = node->parent->parent; } else { if (node == node->parent->right) { node = node->parent; rotateLeft(node); } node->parent->color = BLACK; node->parent->parent->color = RED; rotateRight(node->parent->parent); } } else { Node<K, V>* uncle = node->parent->parent->left; if (uncle != nullptr && uncle->color == RED) { node->parent->color = BLACK; uncle->color = BLACK; node->parent->parent->color = RED; node = node->parent->parent; } else { if (node == node->parent->left) { node = node->parent; rotateRight(node); } node->parent->color = BLACK; node->parent->parent->color = RED; rotateLeft(node->parent->parent); } } } root->color = BLACK; } // 左旋 void rotateLeft(Node<K, V>* node) { Node<K, V>* rightChild = node->right; node->right = rightChild->left; if (rightChild->left != nullptr) rightChild->left->parent = node; rightChild->parent = node->parent; if (node->parent == nullptr) root = rightChild; else if (node == node->parent->left) node->parent->left = rightChild; else node->parent->right = rightChild; rightChild->left = node; node->parent = rightChild; } // 右旋 void rotateRight(Node<K, V>* node) { Node<K, V>* leftChild = node->left; node->left = leftChild->right; if (leftChild->right != nullptr) leftChild->right->parent = node; leftChild->parent = node->parent; if (node->parent == nullptr) root = leftChild; else if (node == node->parent->left) node->parent->left = leftChild; else node->parent->right = leftChild; leftChild->right = node; node->parent = leftChild; } }; int main() { RBTreeMap<int, std::string> map; map.insert(1, "one"); map.insert(2, "two"); map.insert(3, "three"); map.insert(4, "four"); std::cout << map.find(2) << std::endl; // 输出: two std::cout << map.find(5) << std::endl; // 输出: 空字符串（默认值） return 0; } ``` 这个示例使用红黑树实现了一个简单的Map数据结构。你可以使用`insert`方法向Map中插入键值对，使用`find`方法查找指定键的值。注意，这只是一个简单的实现，还可以根据需要进行扩展和优化。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值