stl map底层之红黑树插入步骤详解与代码实现

最新推荐文章于 2024-03-06 16:08:27 发布
最新推荐文章于 2024-03-06 16:08:27 发布
阅读量587 收藏
点赞数 1
分类专栏： 算法及数据结构

转载注明出处：http://blog.csdn.net/mxway/article/details/29216199

本篇文章并没有详细的讲解红黑树各方面的知识，只是以图形的方式对红黑树插入节点需要进行调整的过程进行的解释。

最近在看stl源码剖析，看到map底层红黑树的实现。为了加深对于红黑树的理解就自己动手写了红黑树插入的实现。关于红黑树插入节点后破坏红黑树性质的几种情况，可以在网上搜到很多相关的信息。下面用图说明插入新节点时红黑树所做的调整。插入的序列分别是30，40，50，20，35，10，11。

首先是插入30，由于现在红黑树是一棵空，所以直接将30作为根节点，并将根节点颜色染成黑色即可。

一、插入40，如下图所示。由于此时并没有破坏红黑树的性质，所以此时插入成功。

图1：插入40

二、插入50,插入节点50后，50及其父节点都为红色，由于此时40没有兄弟节点。此时将父节点变黑，祖父节点变红，以祖父节点为根进行左旋。调整后如图2-2所示

                           图2-1：插入节点50                                                                  图2-2：插入节点50调整后

三、插入20，插入节点20后，其父节点30及叔节点50都是红色节点。解决方法是将父节点及叔节点变黑，祖父节点变红。祖父节点变成新的当前节点重新进行算法。由于40是根节点，所以将根节点变黑。调整后如图3-2所示,此时满足红黑树的全部性质。

                                       图3-1：插入节点20                                                                 图3-2：插入节点20调整后

四、插入节点35，如图4所示，由于此时并未破坏红黑树的任何性质。不需要进行调整算法。

                                图4：插入节点35

五、插入节点10，此时10的父节点20及其叔节点35都是红色。将20及35节点变黑，祖父节点30变红。30作为新的当前节点。由于30的父节点40是黑色。所以调整算法结束。调整后如图5-2所示


                                                                                                                      图5-1:插入节点10 

  图5-2：插入节点10调整后

六、插入节点11，如图6-1所示，由于11的父节点10是红色节点，并且11是10的右子节点。所以首先以10节点为根节点进行左旋，旋转后其的红黑树如图6-2所示。此时节点10的父节点11为红色，并且10是11节点的左子节点；此时将父节点11变黑，祖父节点20变红,以祖父节点20为根节点进行右旋。旋转后如图6-3所示。

                                                                                                                   图6-1：插入节点11  

                          

                                                                                            图6-2：10为根节点进行左旋后


图6-3：插入节点调整后的红黑树


下面附上只实现了插入功能的红黑树源码

#include <iostream>
#include <queue>
using namespace std;

static int _rb_black_node = 0;
static int _rb_red_node   = 1;
template<typename T>
struct RBNode
{
    RBNode():left(NULL),right(NULL),parent(NULL),val(T()),color(_rb_red_node){}
    RBNode(const T &v1):left(NULL),right(NULL),parent(NULL),val(v1),color(_rb_red_node){}
    RBNode  *left;
    RBNode  *right;
    RBNode  *parent;
    int     color;
    T       val;
};

template<typename T>
class RBTree
{
public:
    RBTree():root(NULL){}
    ~RBTree()
    {
        if(root)
        {
            Destroy(root);
        }
    }
    void    print();
    void    Search(const T &v1, RBNode<T> *&node);
    bool    InsertUnique(const T &v1);
    void    DeleteValue(const T &v1);
    void    Destroy(RBNode<T> *p);
    void    InsertReBalance(RBNode<T> *node);
    RBNode<T>*    _rbtree_rotate_left(RBNode<T> *node);
    RBNode<T>*  _rbtree_rotate_right(RBNode<T> *node);
private:
    RBNode<T> *root;
};

/*
*
* 打印红黑树的节点信息
*
*/
template<typename T>
void RBTree<T>::print()
{
    RBNode<T> *p;
    queue<RBNode<T> *> Q;
    Q.push(root);
    while(!Q.empty())
    {
        p = Q.front();
        Q.pop();
        cout<<"节点: "<<p->val<<" ";
        if(p->left)
        {
            cout<<"left:"<<p->left->val<<"->color:"<<p->left->color<<" ";
            Q.push(p->left);
        }
        if(p->right)
        {
            cout<<"right:"<<p->right->val<<"->color:"<<p->right->color<<" ";
            Q.push(p->right);
        }
        cout<<endl<<endl;
    }
}

/*
*
* 搜索v1在红黑树中出现的位置，如果v1在红黑树中则node节点为
* 值为v1所在红黑树中的节点。
* 否则node节点为如果将v1插入到红黑树中的父节点
*
*/
template<typename T>
void RBTree<T>::Search(const T &v1,RBNode<T> *&node)
{
    RBNode<T> *p = root;
    node = NULL;
    while(p)
    {
        if(p->val == v1)
        {
            node = p;
            break;
        }
        else if(p->val < v1)
        {
            node = p;
            p = p->right;
        }
        else
        {
            node = p;
            p = p->left;
        }
    }
}


template<typename T>
bool RBTree<T>::InsertUnique(const T &v1)
{
    RBNode<T> *parent = NULL;
    RBNode<T> *newNode = new RBNode<T>(v1);
    Search(v1, parent);
    if(parent == NULL)
    {//红黑树为空，当前插入的节点为根节点。插入后将根颜色变为黑
        root = newNode;
        root->color = _rb_black_node;
        return true;
    }
    if(parent->val == v1)//v1已经存在红黑树中。不再插入
        return false;

    if(v1 < parent->val)
    {
        parent->left = newNode;
    }
    else
    {
        parent->right = newNode;
    }
    newNode->parent = parent;
    InsertReBalance(newNode);
    return true;
}

/*
*
* 插入节点后进行调整，
* 使所有节点满足红黑树的性质
*
*/
template<typename T>
void RBTree<T>::InsertReBalance(RBNode<T> *node)
{
    RBNode<T> *parent = node->parent;
    RBNode<T> *grandParent = NULL;
    while(parent && parent->color==_rb_red_node)
    {
        grandParent = parent->parent;
        if(parent == grandParent->left)
        {//父节点为祖父节点的左儿子
            RBNode<T> *uncle = grandParent->right;
            if(uncle && uncle->color == _rb_red_node)
            {//情形1 父节点与叔节点都为红
                //解决方法父与叔变黑，祖父变黑。祖父变为新的当前节点重新进入算法
                parent->color = _rb_black_node;
                uncle->color  = _rb_black_node;
                grandParent->color = _rb_red_node;
                node = grandParent;
                parent = grandParent->parent;
            }
            else
            {
                if(node == parent->right)
                {//情形2，叔为黑，当前节点为其父节点的右子节点
                    //解决方法：以父节点为根进行左旋
                    //操作后将转换为情形3
                    node = _rbtree_rotate_left(parent);
                    parent = node->parent;
                    grandParent = parent->parent;
                }
                //情形3父为红，当前节点为父节点的左子节点
                //解决方法：父节点变黑，祖父节点变红，以
                //祖父节点为根节点进行右旋
                parent->color = _rb_black_node;
                grandParent->color = _rb_red_node;
                _rbtree_rotate_right(grandParent);
            }
        }
        else
        {//父节点为祖父节点的右子节点，情况与上面相同
            RBNode<T> *uncle = grandParent->left;
            if(uncle && uncle->color == _rb_red_node)
            {
                uncle->color = _rb_black_node;
                parent->color = _rb_black_node;
                grandParent->color = _rb_red_node;
                node = grandParent;
                parent = node->parent;
            }
            else
            {
                if(node == parent->left)
                {
                    node = _rbtree_rotate_right(parent);
                    parent = node->parent;
                    grandParent = parent->parent;
                }
                parent->color = _rb_black_node;
                grandParent->color = _rb_red_node;
                _rbtree_rotate_left(grandParent);
            }
        }
    }
    root->color = _rb_black_node;
}

/*
*
* 左旋
*
*/
template<typename T>
RBNode<T> *RBTree<T>::_rbtree_rotate_left(RBNode<T> *x)
{
    RBNode<T> *y = x->right;
    if(y == NULL)
    {
        return x;
    }
    //x的右节点为y的左节点
    x->right = y->left;
    if(y->left)//如果y的左节点存在，其父节点为y
        y->left->parent = x;
    if(root == x)
    {//x为root，旋转后y为新的root根节点
        root = y;
    }
    else
    {
        if(x == x->parent->left)
        {//如果x为其父节点的左子节点。
            //x的父节点的新左子节点为y
            x->parent->left = y;
        }
        else
        {
            x->parent->right = y;
        }
        //y的父节点为x的父节点
        y->parent = x->parent;
    }
    //y的左子节点为x
    y->left = x;
    //x的父节点为y
    x->parent = y;
    return x;
}

/*
*
* 右旋
* 分析其逻辑与左旋代码类似
*
*/
template<typename T>
RBNode<T>* RBTree<T>::_rbtree_rotate_right(RBNode<T> *x)
{
    RBNode<T> *y = x->left;
    if(y == NULL)
    {
        return x;
    }
    x->left = y->right;
    if(y->right)
        y->right->parent = x;
    if(root == x)
    {
        root = y;
    }
    else
    {
        if(x == x->parent->left)
        {
            x->parent->left = y;
        }
        else
        {
            x->parent->right = y;
        }
        y->parent = x->parent;
    }
    y->right = x;
    x->parent = y;
    return x;
}

/*
*
* 销毁整棵红黑树
*
*/
template<typename T>
void RBTree<T>::Destroy(RBNode<T> *p)
{
    if(p->left)
    {
        Destroy(p->left);
    }
    if(p->right)
    {
        Destroy(p->right);
    }
    delete p;
}

int main()
{
    RBTree<int> obj;
    obj.InsertUnique(30);
    obj.InsertUnique(40);
    obj.InsertUnique(50);
    obj.InsertUnique(20);
    obj.InsertUnique(35);
    obj.InsertUnique(10);
    obj.InsertUnique(11);
    obj.print();
    return 0;
}

小坏蛋_千千
关注
专栏目录
【C++】红黑树详解并封装实现map和set
love_guanghui的博客
03-18 3162
红黑树详解
红黑树模拟实现STL中的map与set（附详细代码）
zhao_leilei的博客
01-26 707
文章目录1.红黑树的迭代器2.改造红黑树3.map的模拟实现4.set的模拟实现 1.红黑树的迭代器 迭代器的好处是可以方便遍历，使数据结构的底层实现与用户透明。如果想要给红黑树增加迭代器，需要考虑以下问题： begin()与end() STL明确规定，begin()与end()代表的是一段前闭后开的区间，而对红黑树进行中序遍历后，可以得到一个有序的序列，因此：begin()可以放在红黑树中最小节点(即最左侧节点)的位置，end()放在最大节点(最右侧节点)的下一个位置，关键是最大节点的下一个位置在哪块？能
用红黑树实现Map
Eriksen的博客
08-26 239
红黑树实现Map
STL容器之map和set的补充——红黑树
最新发布
qq_33093885的博客
03-06 1088
c++红黑树的学习和模拟实现
hashmap中为什么使用红黑树？
qq_25106373的博客
03-11 4087
在回答这个问题之前，我们先了解一下有关二叉树的基本内容。 ①二叉排序树(又称二叉查找树)： 1)若左子树不为空，则左子树上所有结点的值均小于根结点的值。 2)若右子树不为空，则右子树上所有结点的值均大于根节点的值。 3)左右子树也为二叉排序树。 ②平衡二叉树(AVL树)： 是一种二叉查找树，当且仅当两个子树的高度差不超过1时，这个树是平衡二叉树。 ③红黑树： 是许多二叉查找树中的一种，不严格的平衡二叉树，即不像AVL那样要求节点的 |balFact| <= 1，它只要求部分达到平衡，但是提出了为节点增
c语言map的实现-使用内核红黑树
热门推荐
staticnetwind的专栏
09-27 2万+
一、前言 内核数据结构中，上次讲了一次内核链表的使用《c语言双向循环链表实现-使用内核链表》，这次再接着讲一下内核中常用的&lt;key,value&gt;结构，红黑树（rbtree）。 二、相关知识 2.1 红黑树特点 红黑树为自平衡二叉查找树，具备了以下几种特征[1]： 节点是红色或黑色。 根是黑色。 所有叶子都是黑色（叶子是NIL节点）。 每个红色节点必须有两个黑色的子节点...
数据结构之红黑树详解
12-31
在C++ STL中，很多部分(目前包括set, multiset, map, multimap)应用了红黑树的变体(SGI STL中的红黑树有一些变化，这些修改提供了更好的性能，以及对set操作的支持)。它是复杂的，但它的操作有着良好的最坏情况运行...
STL中的map用法详解.rar
12-08
`map`是一个有序的键值对集合，其内部实现通常基于红黑树。这保证了插入、查找和删除等操作的时间复杂度为O(log n)。每个键在`map`中都是唯一的，不允许重复。 2. **初始化与插入** 初始化一个空`map`可以使用`...
浅谈c++中的stl中的map用法详解
12-31
这里说下map内部数据的组织，map内部自建一颗红黑树(一种非严格意义上的平衡二叉树)，这颗树具有对数据自动排序的功能，所以在map内部所有的数据都是有序的，后边我们会见识到有序的好处。 下面举例说明什么是一对一...
Java提高篇（二七）-----TreeMap
weixin_30580943的博客
05-23 2039
原文出自：http://cmsblogs.com/?p=1013。尊重作者的成果，转载请注明出处！ 个人站点：http://cmsblogs.com------------------------------------------------------------------------------------------------------------...
红黑树实现——STL中的map
zhongjie的专栏
11-04 7814
红黑树实现——STL中的map [ 2009-07-24 13:55:31 | 作者: dklkt ] 字号: 大 | 中 | 小 [转载]STL中map实现技术 来源：http://blog.csdn.net/Fandywang_jlu/archive/2008/03/23/2208363.aspx 红黑树是一种自平衡二叉查找树，是在计算机科学中用到的一种数据结构，
BST,AVL树,红黑树，B树，B+树，B*树(从map的底层实现到mysql索引原理)
写代码的柯长的博客
03-24 2355
本文不会对具体细节过多的探究，力求得到这几种树的联系以及区别，实际运用。 BST(二叉检索树)： 二叉检索树也是我们最熟悉的一个索引方式了，它保证所有节点的左子树都小于该节点，所有节点的右子树都大于该节点。就可以通过大小比较关系来进行快速的检索，在一棵满二叉平衡树的情况下，检索的效率可以达到logn(类似二分检索)，然后插入和删除的效率也是稳定的logn。 还是上一张图吧： BST可以...
STL中map实现原理
知行合一 止于行善
03-15 5488
一、vector vector的数据安排以及操作方式，与array非常类似，两者唯一的区别是空间运用的灵活性，array是静态空间，一旦配置了就不能改变，如果你想要大一点的空间，就必须首先配置一块新空间，然后将原来的元素一一复制进来，再把原来的空间释放给系统。但是vector是动态空间，随着元素的增加，它的内部机制会自行扩充空间以容纳新元素，因此vector的运用对于内存的合理利用与运用的灵
hashmap底层实现(红黑树)简单了解
weixin_44675503的博客
03-27 3728
**以下是具体的put过程（JDK1.8版）1、对Key求Hash值，然后再计算下标** 2、如果没有碰撞，直接放入桶中（碰撞的意思是计算得到的Hash值相同，需要放到同一个bucket中） 3、如果碰撞了，以链表的方式链接到后面 4、如果链表长度超过阀值( TREEIFY THRESHOLD==8)，就把链表转成红黑树，链表长度低于6，就把红黑树转回链表 5、如果节点已经存在就替换旧值...
请你回答一下map底层为什么用红黑树实现
WangY.H
07-01 5864
参考回答： 1、红黑树： 红黑树是一种二叉查找树，但在每个节点增加一个存储位表示节点的颜色，可以是红或黑（非红即黑）。 通过对任何一条从根到叶子的路径上各个节点着色的方式的限制，红黑树确保没有一条路径会比其它路 径长出两倍，因此，红黑树是一种弱平衡二叉树，相对于要求严格的AVL树来说，它的旋转次数少，所 以对于搜索，插入，删除操作较多的情况下，通常使用红黑树。 性质： 1. 每个节点非红即黑 ...
STL MAP使用注意事项
佰大于的小仓库
08-08 442
Hat’s Words   A hat’s word is a word in the dictionary that is the concatenation of exactly two other words in the dictionary.  You are to find all the hat’s words in a dictionary.  InputSta
【C++】-- STL之用红黑树模拟实现map和set
局部变量和全局变量
09-08 1067
用红黑树同时封装出set和map时，set传给value的是一个value，map传给value的是一个pair，set和map传给红黑树的value决定了这棵树里面存的节点值类型。上层容器不同，底层红黑树的Key和T也不同。
详解红黑树：插入与删除策略
"彻底明白红黑树" 红黑树是一种自平衡的二叉查找树，它在保持查找效率的同时，通过特定的规则和调整策略来确保树的平衡，从而保证了插入、...在实际编程中，红黑树常用于实现高效的数据结构，如STL中的map和set容器。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值