C++：STL学习之红黑树

最新推荐文章于 2024-08-09 23:16:07 发布
最新推荐文章于 2024-08-09 23:16:07 发布
阅读量1.9k 收藏 12
点赞数 2
分类专栏： C++ 文章标签： STL
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Cold_Sun_/article/details/100565561
版权

一、红黑树介绍

引用算法导论里面的话：

一颗红黑树是满足下面红黑性质的二叉搜索树：

1、每个结点是红色，或是黑色的

2、根结点是黑色的

3、每个叶结点NIL是黑色的

4、如果一个结点是红色的，则它的两个子结点都是黑色的

5、对于每个结点，从该结点到其所有后代叶结点的简单路径上，均包含相同数目的黑色结点

根据红黑树的这些性质，易证：一颗有n个内部结点的红黑树的高度至多为2lg(n+1)

通过这条定理我们可以知道，红黑树的动态集合操作：查找，添加，删除等时间复杂度均为O(lgn)。

 

二、旋转

在介绍红黑树的动态集和操作前，我们首先介绍二叉搜索树里的旋转操作，这是一种能保持二叉搜索树性质的搜索树局部操作，分为左旋和右旋操作，首先对左旋操作进行介绍。

左旋

 如图所示，对X结点进行左旋，左旋后X结点成为Y结点的子结点，Y结点接替X结点原来的位置，C++代码如下：

template <class T>
void RBTree<T>::leftRotate(Node<T> *&root,Node<T> *x)
{
    Node<T> *y=x->right;
    y->parent=x->parent;
    x->right=y->left;
    if (y->left!=nullptr)
        y->left->parent=x;
    if (x->parent!=nullptr)
    {
        if(x->parent->left==x)
            x->parent->left=y;
        else
            x->parent->right=y;
    }
    else
        root=y;
    x->parent=y;
    y->left=x;
}

右旋操作如下图所示

右旋

右旋后Y结点成为X结点的子结点，X结点接替Y结点原来的位置，C++代码如下：

template <class T>
void RBTree<T>::rightRotate(Node<T> *&root, Node<T> *x)
{
    Node<T> *y=x->left;
    y->parent=x->parent;
    x->left=y->right;
    if (y->right!=nullptr)
        y->right->parent=x;
    if (x->parent!=nullptr)
    {
        if(x->parent->left==x)
            x->parent->left=y;
        else
            x->parent->right=y;
    }
    else
        root=y;
    x->parent=y;
    y->right=x;
}

 

三、添加操作

介绍完左旋与右旋操作后，就可以开始介绍添加操作。

添加操作一般可以分为三步：

1、将红黑树作为一颗二叉查找树，需要插入结点的位置

2、将该结点的颜色赋为红色。

（为什么要赋为红色，根据红黑树性质5：对于每个结点，从该结点到其所有后代叶结点的简单路径上，均包含相同数目的黑色结点，将结点赋值为红色，就可以不违反性质5。但是这样又会遇到一个问题，假如加入结点的父结点也为红色，那么就会违反性质4：如果一个结点是红色的，则它的两个子结点都是黑色的。所以这时候我们就要执行步骤三）

3、对插入后的红黑树执行一系列的着色与旋转操作，使其重新成为一颗红黑树。

（这一系列操作一般我们都会定义为insertFixUp函数，将在后面讲到）

添加操作的C++实现代码如下

template <class T>
void RBTree<T>::insert(Node<T> *&root,Node<T> *node)
{
    Node<T> *y=nullptr;
    Node<T> *x=root;
    while(x!=nullptr)
    {
        y=x;
        if(node->key<x->key)
            x=x->left;
        else
            x=x->right;
    }
    node->parent=y;
    if(y!=nullptr)
    {
        if(node->key<y->key)
            y->left=node;
        else
            y->right=node;
    }
    else
        root=node;
    node->color=RED;
    insertFixUp(root,node);
}

红黑树的插入修复操作，主要目的就是要将待处理结点分支上的一个红色属性（一般就是父结点的红色属性）往上或往兄弟分支移动，从而使红黑树再次满足性质4。

我们可以将红黑树的修复操作看作是一个魔方复原的过程，对待处理结点不同的局部情况执行不同的操作以得到其他情况或是完成红黑树的修复。

一般插入操作修复分为3种情况：

case1：叔叔结点为红色（叔叔结点就是父结点的兄弟结点，父结点在插入修复时都为红色），如下图

插入修复case1

这时候我们要执行的操作就是将父结点与叔叔结点同时赋为黑色，祖父结点赋为红色，将处理结点转为祖父结点，对祖父结点继续处理。（目的就是将父结点与叔叔结点的红色属性同时上移，这样能在不破坏红黑树性质的情况下将处理结点分支的红色属性上移）如果祖父结点为根结点，将根结点赋黑色，操作结束。

case2:叔叔结点为黑色，待处理结点是近叔叔结点，如下图所示

插入修复case2

这时候我们要进行的操作就是将待处理结点转化为父结点，并对父结点左旋，这样就能把问题处理的情况转化为case3。

case3：叔叔结点为黑色，待处理结点是远叔叔结点。如下图所示

插入修复case3

这时候我们要执行的操作是将父结点转化为黑色，祖父结点转化为红色，并对祖父结点右旋（这时候相当于把处理结点分支上的一个红色属性给了兄弟分支），至此红黑树修复完成。

插入修复的代码如下

template <class T>
void RBTree<T>::insertFixUp(Node<T> *&root,Node<T> *node)
{
    Node<T> *parent,*grdparent,*uncle;
    while ((node->parent!=nullptr)&&(node->parent->color==RED))
    {
        parent=node->parent;
        grdparent=parent->parent;
        if (parent==grdparent->left)
        {
            uncle=grdparent->right;
            if(uncle!=nullptr&&uncle->color==RED)
            {
                //case1:叔叔结点为红色，这时候将父结点与叔叔结点的红色属性同时往上移到祖父结点，
                //处理结点转到祖父结点
                uncle->color=BLACK;
                parent->color=BLACK;
                grdparent->color=RED;
                node=grdparent;
                continue;
            }
            else if (parent->right==node)
            {
                //case2:叔叔结点为黑色且待处理结点靠近叔叔结点，这时候将待处理结点转化为父结点，并对父结点左旋
                //这样就能把问题处理的情况转化为case3
                node=node->parent;
                leftRotate(root,node);
            }
            else if (parent->left==node) 
            {
                //case3:叔叔结点为黑色且待处理结点远离叔叔结点，这时候将父结点转化为黑色，祖父结点转化为红色，
                //并对祖父结点右旋（这时候相当于把处理结点分支上的一个红色属性给了兄弟分支），红黑树修复完成。
                parent->color=BLACK;
                grdparent->color=RED;
                rightRotate(root,grdparent);
            }
        }
        else
        {
            uncle=grdparent->left;
            if(uncle!=nullptr&&uncle->color==RED)
            {
                uncle->color=BLACK;
                parent->color=BLACK;
                grdparent->color=RED;
                node=grdparent;
                continue;
            }
            else if (parent->left==node)
            {
                node=node->parent;
                rightRotate(root,node);
            }
            else if (parent->right==node)
            {
                parent->color=BLACK;
                grdparent->color=RED;
                leftRotate(root,grdparent);
            }
        }
    }
    root->color=BLACK;
}

 

四、删除操作

删除操作比较复杂，如果直接在找到删除结点的位置对结点进行删除会大量破坏红黑树的性质，故这里采用的办法是找到待删除结点的前驱（左结点的最大子结点）或后继（右结点的最小结点）。将其与待删除结点替换，我们对前驱或后继进行处理。

一般也分为三步：

1、找到待删除结点在红黑树中的位置

2、找到待删除结点的前驱或后继，将其与待删除结点交换，删除前驱或后继，连接删除位置的父子结点并标记，若删除的替换结点为红色，对红黑树性质没影响，操作结束，若删除的替换结点为黑色，则会破坏红黑树性质，这时候我们执行步骤三

3、通过一系列的旋转与着色，修复红黑树性质（一般这一系列操作命名为removeFixUp）

C++代码如下：

template<class T>
void RBTree<T>::remove(Node<T> *&root, Node<T> *node)
{
    Node<T> *child,*parent;
    RBTcolor color;
    if(node->left!=nullptr&&node->right!=nullptr)
    {
        Node<T> *replace=node;
        replace=replace->right;
        while(replace->left!=nullptr)
            replace=replace->left;
        node->key=replace->key;
        child=replace->right;
        parent=replace->parent;
        color=replace->color;
        if(parent->left==replace)
            parent->left=child;
        else
            parent->right=child;
        if(child)
            child->parent=parent;
        if(color==BLACK)
            removeFixUp(root,child,parent);
        delete replace;
        return;
    }
    if(node->left!=nullptr)
        child=node->left;
    else
        child=node->right;
    parent=node->parent;
    color=node->color;
    if(child)
        child->parent=parent;
    if(parent)
    {
        if(parent->left==node)
            parent->left=child;
        else
            parent->right=child;
    }
    else
        root=child;
    if(color==BLACK)
        removeFixUp(root,child,parent);
    delete node;
}

template <class T>
void RBTree<T>::remove(T key)
{
    Node<T> *node;
    if((node=search(mRoot,key))!=nullptr)
        remove(mRoot,node);
}

template <class T>
Node<T>* RBTree<T>::search(Node<T> *root,T key) const
{
    if(root==nullptr||root->key==key)
        return root;
    if (key<root->key)
        return search(root->left,key);
    else
        return search(root->right,key);
}

红黑树的删除修复操作，主要目的是使待处理结点（一般为删除结点的儿子结点）上的两个黑色属性（注意为什么两个黑色属性，删除结点的黑色属性暂时先放在待处理结点上，只有待处理结点与删除结点同为黑时需进行删除修复操作）

与添加修复操作类似，删除修复操作也可以分为4种情况

case1：待处理结点的兄弟结点为黑色，且兄弟结点具有两个黑色结点，如图所示

这种情况下执行的操作是，将处理结点与兄弟结点的一个黑色属性同时上移给父亲结点。父亲结点黑色属性加一，然后将处理结点转为父亲结点，问题转为case1,2,3,4处理

case2:兄弟结点颜色为红色时，如下图所示

这时候要执行的操作是，交换兄弟节点与父结点位置，并对父结点左旋，目的是使修正结点获得一个黑兄弟结点。这样处理后将问题转为case1，3，4处理。

case3：当兄弟结点为黑色，近侄子结点为红色时，如下图所示

删除修复case3

这时候执行的操作是，将兄弟结点设为红色，近侄子结点设为黑色。对兄弟结点进行右旋，使问题转化为case4处理

case4:当兄弟结点为黑色，远侄子结点为红色时，如下图所示

这时候要执行的操作是，将远侄子结点继承兄弟结点黑色，兄弟结点继承父结点颜色，父结点获得黑色，对父结点左旋，红黑树平衡（这一步操作就是将远侄子结点的红色属性承接了处理结点的一个黑色属性）

删除修复操作的代码如下：

template <class T>
void RBTree<T>::removeFixUp(Node<T> *&root,Node<T> *node,Node<T> *parent)//node可能是空结点，故需要parent参数来确定父结点
{
    Node<T> *brother;
    while((!node||node->color==BLACK)&&node!=root)
    {
        if(node==parent->left)
        {
            brother=parent->right;
            if(brother->color==RED)
            {
                //case1:当兄弟节点颜色为红色时，交换兄弟节点与父结点位置，并对父结点左旋，使修正结点获得一个黑兄弟结点。
                //这样处理后将问题转为case2，3，4处理
                brother->color=BLACK;
                parent->color=RED;
                leftRotate(root,parent);
                brother=parent->right;
            }
            else if((!brother->left||brother->left->color==BLACK)&&(!brother->right||brother->right->color==BLACK))
            {
                //case2:当兄弟结点为黑色，且具有2个黑色子结点时，将处理结点与兄弟结点的一个黑色属性同时上移给父亲结点。
                //父亲结点黑色属性加一，然后将处理结点转为父亲结点，问题转为case1,3,4处理
                brother->color=RED;
                node=parent;
                parent=node->parent;
            }
            else
            {
                if(!brother->right||brother->right->color==BLACK)
                {
                    //case3:当兄弟结点为黑色，近侄子结点为红色时，将兄弟结点设为红色，近侄子结点设为黑色。
                    //对兄弟结点进行右旋，使问题转化为case4处理
                    brother->left->color=BLACK;
                    brother->color=RED;
                    rightRotate(root,brother);
                    brother->parent->right;
                }
                //case4:当兄弟结点为黑色，远侄子结点为红色时，将远侄子结点继承兄弟结点黑色，兄弟结点继承父结点颜色，
                //父结点获得黑色，对父结点左旋，红黑树平衡
                brother->color=parent->color;
                parent->color=BLACK;
                brother->right->color=BLACK;
                leftRotate(root,parent);
                node=root;//脱出循环
            }
        }
        else
        {
            brother=parent->left;
            if(brother->color==RED)
            {
                brother->color=BLACK;
                parent->color=RED;
                rightRotate(root,parent);
                brother=parent->left;
            }
            else if ((!brother->left||brother->left->color==BLACK)&&(!brother->right||brother->right->color==BLACK))
            {
                brother->color=RED;
                node=parent;
                parent=node->parent;
            }
            else
            {
                if(!brother->left||brother->left->color==BLACK)
                {
                    brother->color=RED;
                    brother->right->color=BLACK;
                    leftRotate(root,brother);
                    brother=parent->left;
                }
                brother->color=parent->color;
                parent->color=BLACK;
                brother->left->color=BLACK;
                rightRotate(root,parent);
                node=root;
            }
        }
    }
    if(node!=nullptr)
        node->color=BLACK;
}

至此一个有添加删除查找基本功能的红黑树就完成，下面是我写的一个红黑树类的完整代码

#ifndef RBTREE_H
#define RBTREE_H

#include "iostream"
#include "iomanip"

using namespace std;

enum RBTcolor{RED,BLACK};

template <class  T>
class Node
{
public:
    T key;
    Node *parent;
    Node *left;
    Node *right;
    RBTcolor color;
    Node()
    {
        key=0;
        parent=nullptr;
        left=nullptr;
        right=nullptr;
        color=RED;
    }
    Node(T value,RBTcolor c,Node *p,Node *l,Node *r):
        key(value),color(c),parent(p),left(l),right(r){}
};

template<class T>
class RBTree
{
private:
    Node<T> *mRoot;
public:
    RBTree();
    ~RBTree();

    //前序遍历红黑树
    void preOrder();
    //中序遍历
    void inOrder();
    //后序遍历
    void postOrder();

    //查找红黑树某节点
    Node<T>* search(T key);

    //插入红黑树
    void insert(T key);

    //删除红黑树某节点
    void remove(T key);

    //销毁红黑树
    void destory();

    //打印红黑树
    void print();
private:
    void preOrder(Node<T> *root) const;

    void inOrder(Node<T> *root) const;

    void postOrder(Node<T> *root) const;

    Node<T>* search(Node<T> *root,T key) const;

    //左旋
    void leftRotate(Node<T> *&root,Node<T> *x);
    //右旋
    void rightRotate(Node<T> *&root,Node<T> *x);

    //插入函数
    void insert(Node<T> *&root,Node<T> *node);
    //删除函数
    void remove(Node<T> *&root,Node<T> *node);

    //插入修正函数
    void insertFixUp(Node<T> *&root,Node<T> *node);
    //删除修正函数
    void removeFixUp(Node<T> *&root,Node<T> *node,Node<T> *parent);

    //销毁红黑树
    void destory(Node<T> *&tree);

    void print(Node<T> *tree,T key,int direction);
};

template <class  T>
RBTree<T>::RBTree():mRoot(nullptr)
{
    mRoot=nullptr;
}

template <class T>
Node<T>* RBTree<T>::search(Node<T> *root,T key) const
{
    if(root==nullptr||root->key==key)
        return root;
    if (key<root->key)
        return search(root->left,key);
    else
        return search(root->right,key);
}

template <class T>
Node<T>* RBTree<T>::search(T key)
{
    search(mRoot,key);
}

template <class T>
void RBTree<T>::leftRotate(Node<T> *&root,Node<T> *x)
{
    Node<T> *y=x->right;
    y->parent=x->parent;
    x->right=y->left;
    if (y->left!=nullptr)
        y->left->parent=x;
    if (x->parent!=nullptr)
    {
        if(x->parent->left==x)
            x->parent->left=y;
        else
            x->parent->right=y;
    }
    else
        root=y;
    x->parent=y;
    y->left=x;
}

template <class T>
void RBTree<T>::rightRotate(Node<T> *&root, Node<T> *x)
{
    Node<T> *y=x->left;
    y->parent=x->parent;
    x->left=y->right;
    if (y->right!=nullptr)
        y->right->parent=x;
    if (x->parent!=nullptr)
    {
        if(x->parent->left==x)
            x->parent->left=y;
        else
            x->parent->right=y;
    }
    else
        root=y;
    x->parent=y;
    y->right=x;
}

template <class T>
void RBTree<T>::insertFixUp(Node<T> *&root,Node<T> *node)
{
    Node<T> *parent,*grdparent,*uncle;
    while ((node->parent!=nullptr)&&(node->parent->color==RED))
    {
        parent=node->parent;
        grdparent=parent->parent;
        if (parent==grdparent->left)
        {
            uncle=grdparent->right;
            if(uncle!=nullptr&&uncle->color==RED)
            {
                //case1:叔叔结点为红色，这时候将父结点与叔叔结点的红色属性同时往上移到祖父结点，
                //处理结点转到祖父结点
                uncle->color=BLACK;
                parent->color=BLACK;
                grdparent->color=RED;
                node=grdparent;
                continue;
            }
            else if (parent->right==node)
            {
                //case2:叔叔结点为黑色且待处理结点靠近叔叔结点，这时候将待处理结点转化为父结点，并对父结点左旋
                //这样就能把问题处理的情况转化为case3
                node=node->parent;
                leftRotate(root,node);
            }
            else if (parent->left==node) 
            {
                //case3:叔叔结点为黑色且待处理结点远离叔叔结点，这时候将父结点转化为黑色，祖父结点转化为红色，
                //并对祖父结点右旋（这时候相当于把处理结点分支上的一个红色属性给了兄弟分支），红黑树修复完成。
                parent->color=BLACK;
                grdparent->color=RED;
                rightRotate(root,grdparent);
            }
        }
        else
        {
            uncle=grdparent->left;
            if(uncle!=nullptr&&uncle->color==RED)
            {
                uncle->color=BLACK;
                parent->color=BLACK;
                grdparent->color=RED;
                node=grdparent;
                continue;
            }
            else if (parent->left==node)
            {
                node=node->parent;
                rightRotate(root,node);
            }
            else if (parent->right==node)
            {
                parent->color=BLACK;
                grdparent->color=RED;
                leftRotate(root,grdparent);
            }
        }
    }
    root->color=BLACK;
}

template <class T>
void RBTree<T>::insert(Node<T> *&root,Node<T> *node)
{
    Node<T> *y=nullptr;
    Node<T> *x=root;
    while(x!=nullptr)
    {
        y=x;
        if(node->key<x->key)
            x=x->left;
        else
            x=x->right;
    }
    node->parent=y;
    if(y!=nullptr)
    {
        if(node->key<y->key)
            y->left=node;
        else
            y->right=node;
    }
    else
        root=node;
    node->color=RED;
    insertFixUp(root,node);
}

template <class T>
void RBTree<T>::insert(T key)
{
    Node<T> *node=nullptr;
    if((node=new Node<T>(key,BLACK,nullptr,nullptr,nullptr))==nullptr)
        return;
    insert(mRoot,node);
}


template<class T>
void RBTree<T>::remove(Node<T> *&root, Node<T> *node)
{
    Node<T> *child,*parent;
    RBTcolor color;
    if(node->left!=nullptr&&node->right!=nullptr)
    {
        Node<T> *replace=node;
        replace=replace->right;
        while(replace->left!=nullptr)
            replace=replace->left;
        node->key=replace->key;
        child=replace->right;
        parent=replace->parent;
        color=replace->color;
        if(parent->left==replace)
            parent->left=child;
        else
            parent->right=child;
        if(child)
            child->parent=parent;
        if(color==BLACK)
            removeFixUp(root,child,parent);
        delete replace;
        return;
    }
    if(node->left!=nullptr)
        child=node->left;
    else
        child=node->right;
    parent=node->parent;
    color=node->color;
    if(child)
        child->parent=parent;
    if(parent)
    {
        if(parent->left==node)
            parent->left=child;
        else
            parent->right=child;
    }
    else
        root=child;
    if(color==BLACK)
        removeFixUp(root,child,parent);
    delete node;
}

template <class T>
void RBTree<T>::remove(T key)
{
    Node<T> *node;
    if((node=search(mRoot,key))!=nullptr)
        remove(mRoot,node);
}

template <class T>
void RBTree<T>::removeFixUp(Node<T> *&root,Node<T> *node,Node<T> *parent)//node可能是空结点，故需要parent参数来确定父结点
{
    Node<T> *brother;
    while((!node||node->color==BLACK)&&node!=root)
    {
        if(node==parent->left)
        {
            brother=parent->right;
            if(brother->color==RED)
            {
                //case1:当兄弟节点颜色为红色时，交换兄弟节点与父结点位置，并对父结点左旋，使修正结点获得一个黑兄弟结点。
                //这样处理后将问题转为case2，3，4处理
                brother->color=BLACK;
                parent->color=RED;
                leftRotate(root,parent);
                brother=parent->right;
            }
            else if((!brother->left||brother->left->color==BLACK)&&(!brother->right||brother->right->color==BLACK))
            {
                //case2:当兄弟结点为黑色，且具有2个黑色子结点时，将处理结点与兄弟结点的一个黑色属性同时上移给父亲结点。
                //父亲结点黑色属性加一，然后将处理结点转为父亲结点，问题转为case1,3,4处理
                brother->color=RED;
                node=parent;
                parent=node->parent;
            }
            else
            {
                if(!brother->right||brother->right->color==BLACK)
                {
                    //case3:当兄弟结点为黑色，近侄子结点为红色时，将兄弟结点设为红色，近侄子结点设为黑色。
                    //对兄弟结点进行右旋，使问题转化为case4处理
                    brother->left->color=BLACK;
                    brother->color=RED;
                    rightRotate(root,brother);
                    brother->parent->right;
                }
                //case4:当兄弟结点为黑色，远侄子结点为红色时，将远侄子结点继承兄弟结点黑色，兄弟结点继承父结点颜色，
                //父结点获得黑色，对父结点左旋，红黑树平衡
                brother->color=parent->color;
                parent->color=BLACK;
                brother->right->color=BLACK;
                leftRotate(root,parent);
                node=root;//脱出循环
            }
        }
        else
        {
            brother=parent->left;
            if(brother->color==RED)
            {
                brother->color=BLACK;
                parent->color=RED;
                rightRotate(root,parent);
                brother=parent->left;
            }
            else if ((!brother->left||brother->left->color==BLACK)&&(!brother->right||brother->right->color==BLACK))
            {
                brother->color=RED;
                node=parent;
                parent=node->parent;
            }
            else
            {
                if(!brother->left||brother->left->color==BLACK)
                {
                    brother->color=RED;
                    brother->right->color=BLACK;
                    leftRotate(root,brother);
                    brother=parent->left;
                }
                brother->color=parent->color;
                parent->color=BLACK;
                brother->left->color=BLACK;
                rightRotate(root,parent);
                node=root;
            }
        }
    }
    if(node!=nullptr)
        node->color=BLACK;
}

template <class T>
void RBTree<T>::print(Node<T> *tree,T key,int direction)
{
    if(tree!=nullptr)
    {
        if(direction==0)
            cout<<setw(2)<<tree->key<<"(B) is root"<<endl;
        else
            cout << setw(2) << tree->key <<  ((tree->color==RED)?"(R)":"(B)") << " is " << setw(2)
            << key << "'s "  << setw(12) << (direction==1?"right child" : "left child") << endl;
        print(tree->left, tree->key, -1);
        print(tree->right,tree->key,  1);
    }
}

template <class T>
void RBTree<T>::print()
{
    if(mRoot)
        print(mRoot,mRoot->key,0);
}

template<class T>
void RBTree<T>::destory(Node<T> *&tree)
{
    if(tree==nullptr)
        return;
    if(tree->left!=nullptr)
        return destory(tree->left);
    if(tree->right!=nullptr)
        return destory(tree->right);
    delete tree;
}

template<class T>
void RBTree<T>::destory()
{
    destory(mRoot);
    mRoot=nullptr;
}

#endif // RBTREE_H

 

Cold_Sun_
关注
专栏目录
C++ STL源码剖析之红黑树
希望我的博客，能帮上你解决学习中工作中所遇到的问题
05-26 474
C++ STL源码剖析之红黑树导语红黑树节点基类红黑树节点红黑树迭代器红黑树操作红黑树插入旋转过程插入总结使用 导语 在STL源码中有两段话，简单翻译后如下： STL中Red-black tree（红黑树）class,用来当做SLT关系式容器（如set,multiset,map, multimap）.里面所用的insertion和deletion方法以 《Introduction to Algorithms》一书为基础,但是有以下两点不同: (1)header不仅指向root,也指向红黑树的最左节点,以便用
C++进阶：STL之树形结构的关联式容器4（底层结构：红黑树）
碧瑶的博客呀
11-05 373
红黑树的概念、性质（重要）、定义、实现（重要）、插入（重要）； 红黑树的迭代器、改造红黑树、使用红黑树实现map和set（重要）
【C++】STL关联式容器之红黑树
金金金金金的博客
05-21 900
1、概念 2、实现
STL源码刨析：红黑树（RB-tree）
最新发布
weixin_67035108的博客
08-09 718
其中关于插入操作，RB-tree提供了两种插入操作：insert_unique() 和insert_equal()，前者表示插入的节点在红黑树中独一无二，后者表示插入的节点在整棵树中可以重复。在文章《STL源码刨析：树的导览》中，曾简单的对树的结构，二叉搜索树和平衡二叉搜索树进行简单的讲解。由于在对红黑树进行节点插入操作时，每一个插入节点的颜色视为红色，而对于红黑树来说其根节点必须为黑色，故。若插入节点的叔叔节点（父亲节点的兄弟节点）为红色，则将父亲节点，叔叔节点和爷爷节点的颜色反转（
[C/C++]详解STL容器7--红黑树的介绍及部分模拟实现
RMA515T的博客
12-01 7494
本文对红黑树进行了介绍，并对其核心功能进行了模拟实现。 红黑树（Red Black Tree），是在计算机科学中用到的一种数据结构，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的。
C++进阶——STL源码之红黑树（_Rb_tree）
木牛的博客
07-14 808
Rb_tree_node的实现如下，几个实现也很简单，在_Rb_tree_node中定义了结点数据域，在基类_Rb_tree_node_base中分别定义了left、right、parent，另外还有一个表示颜色的标记常量。通过获取_M_impl的构造器来完成节点的创建和销毁，这里和我们之前看到的是一致的，内存分配和构造是分开的，在_M_create_node中，先通过构造器去分配，然后通过construct来构造。_Rb_tree_impl还负责红黑树的初始化操作与内存管理。
C++ STL 红黑树简单介绍
wwxy1995的博客
07-26 1115
红黑树就是一棵高度平衡的二叉树，树中的节点被分为两类，一类是红色，一类是黑色。 C++ STL 中set和map的底层是rb_tree 主要看红黑树的数据域是什么 红黑树的使用介绍 ...
c++ SGI STL源代码学习
06-04
set和map是基于红黑树的数据结构，提供键值对的存储和查找。 2. 迭代器（Iterators）：类似于指针，但比指针更安全，提供了统一的接口来遍历容器中的元素。迭代器有五种类型：输入迭代器、输出迭代器、前向迭代器、...
C++：什么是STL？
热门推荐
Sunrise的博客
06-09 1万+
什么是STL？1. STL概论1.1. STL基本概念1.2. STL六大组件简介1.3. STL优点2. STL三大组件2.1. 容器2.2. 算法2.3. 迭代器2.3. 案例 1. STL概论   长久以来，软件界一直希望建立一种可重复利用的东西，以及一种得以制造出”可重复运用的东西”的方法,让程序员的心血不止于随时间的迁移，人事异动而烟消云散，从函数(functions)，类别(classes),函数库(function libraries),类别库(class libraries)、各种组件，从模
红黑树-基于C++实现的红黑树数据结构.zip
03-21
例如，在C++标准模板库(STL)中，`std::set`和`std::map`就是基于红黑树实现的。 在C++中实现红黑树时，通常会定义一个名为`RBTree`的类，包含私有成员变量（如根节点指针）和公共成员函数（如`insert`, `delete`, `...
STL map / set 底层机制: 红黑树完全剖析
专注游戏研发
08-21 2959
前言： 在 STL 的容器中两大阵营 (vector deque list forward_list) 顺序容器 与 关联容器 （map set unorder_map unorder_set） 。 关联容器指的是以关键字匹配指定数据的一种关联数据结构的集合， 在关联容器中通过关键字去查找对应的数据是非常块的， 下面我们会彻底地去剖析其底层实现机制 ： 红黑树。 由基础树 到 二叉搜索树 介绍红黑树之前，容许我介绍树的概念。 1. 树（tree）， 在计算机科学中，是十分基础的数据结构： .
C++ STL 数据结构 树
01-30
STL中关于树的一些知识差不多都在。 普通的二叉树，二叉树的遍历（有递归的和非递归的）； 二叉树的迭代； 线索二叉树； 堆； Huffman编码； 二叉搜索树； AVL 树。
红黑树的完整实现（C++）
06-26
红黑树的完整实现（C++）模板类；已测试使用完毕。参考《STL源码剖析》《算法导论》
c++ tree class 符合stl规范
09-16
工作中常用类似树的类，有时候自己写个，或者用stl的类库模拟一个，今天看到一个比较好的tree 类库，已经有不少地方在用，感觉还不错，特贴来共享，希望对大家有用
【C++ STL】-- 红黑树的插入实现
weixin_64609308的博客
12-10 1042
详细图解，一步步讲解红黑树C++的插入实现，上万字讲解
【C++/STL】：红黑树的应用 --- 封装map和set
2301_77900444的博客
07-27 1654
map 和 set 的底层本质上还是复用通过对红黑树的改造，再分别套上一层 map 和 set 的 “壳子”，以达到 “一树二用” 的目的。在改造红黑树的过程中，我大概归纳了以下几个需要重点解决的问题：(1) 对红黑树节点的改造。关联式容器中存储的是的键值对，K为key的类型，如果是 set 则是 K，如果是map，则为pair。如何用一个节点结构控制两种类型，使用类模板参数T。(2) 在插入操作时，如何完成数据的比较。
【C++】-- STL之用红黑树模拟实现map和set
局部变量和全局变量
09-08 1073
用红黑树同时封装出set和map时，set传给value的是一个value，map传给value的是一个pair，set和map传给红黑树的value决定了这棵树里面存的节点值类型。上层容器不同，底层红黑树的Key和T也不同。
【面经笔记】红黑树的特性与其在C++ STL中的应用
xiaxzhou的博客
07-11 3225
AVL树和红黑树适合内部存储应用，B树适合外部存储应用AVL树和红黑树都是用旋转保持平衡，AVL树对每个插入操作最多需要两次次旋转（单/双旋），对每个删除操作最多需要O（logn）次旋转；而红黑树对每个插入和删除操作，任何不平衡都会在三次旋转之内解决。查找、插入、删除的时间均为log(n)，红黑树的算法时间复杂度和AVL相同，但红黑树的统计性能要好于平衡二叉树，但极端性能略差。平衡二叉树/AVL树：
C++实现红黑树，仿STL封装
diyin9896的博客
10-20 128
C++实现红黑树，仿STL封装 1 //RB_Tree.hpp 2 //The code of red black trees 3 //2011/12/31 by Adoo 4 // The foundation :http://ww...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值