C++_红黑树的概念及实现

红黑树的概念

红黑树（Red Black Tree）是一种自平衡二叉搜索树，是在计算机科学中用到的一种数据结构。
红黑树在每个节点上增加一个存储位表示结点的颜色，可以是 Red 或 Black。
过对任何一条从根到叶子的路径上各个节点着色方式的限制，红黑树确保没有一条路径会比其他路径长出两倍，因而是接近平衡的。

红黑树在二叉搜索树的基础上还满足：

每个节点不是红色就是黑色；
根节点是黑色的；
如果一个节点是红色的，则它的两个孩子结点是黑色的（从每个叶子到根的所有路径上不能有两个连续的红色节点）；
对于每个节点，从该节点到其所有后代节点的简单路径上，均包含相同数目的黑色节点；
每个叶子节点都是黑色的（此处的叶子节点指的是空结点）。

红黑树的实现

红黑树的节点定义

enum Color {RED, BLACK};

template <class v>
struct RBTNode
{
    RBTNode(const v& data = v())
     : _left(nullptr)
     , _right(nullptr)
     , _parent(nullptr)
     , _data(data)
     , _color(RED)
    {}
    
    RBTNode<v>* _left; // 节点的左孩子
    RBTNode<v>* _right; // 节点的右孩子
    RBTNode<v>* _parent; // 节点的父亲
    v _data; // 节点的值
    Color _color; // 节点的颜色
};

红黑树的迭代器

template <class v>
class _RBTreeIterator
{
public:
    typedef RBTNode<v>  Node;
    typedef Node*  pNode;
    typedef _RBTreeIterator<v>  self;
   
    _RBTreeIterator(pNode node)
     :_node(node)
    {}
 
    v& operator *()
    {
        return _node->_data;
    }
 
    v* operator ->()
    {
        return &_node->_data;
    }
 
    bool operator!=(const self& it)
    {
        return _node != it._node;
    }
    
    bool operator==(const self& it)
    {
        return _node == it._node;
    }
    
    self& operator++()
    {
        pNode parent = _node->parent;
        if (_node->_right)
        {
            _node = _node->_right;
            while (_node->_left)
            {
                _node = _node->_left;
            }
        }
        else
        {
            while (_node == parent->_right)
            {
                _node = parent;
                parent = parent->parent;
            }
            if (_node->_right != parent)
                _node = parent;
        }
        return *this;
    }
 
    self& operator--()
    {
        pNode parent = _node->parent;
        if (_node->_left)
        {
            _node = _node->_left;
            while (_node->_right)
            {
                _node = _node->_right;
            }
        }
        else
        {
            while (_node != parent->_right)
            {
                _node = parent;
                parent = parent->parent;
            }
            if (_node->_left != parent)
                _node = parent;
         }
         return *this;
    }

private:
    pNode _node;
};

红黑树的结构

template <class k,class v,class kov>
class RBTree
{
public:
    typedef  RBTNode<v>  Node;
    typedef  Node* pNode;
    typedef _RBTreeIterator<v> iterator;

    iterator begin()
    {
        return iterator(_header->_left);
    }
    
    iterator end()
    {
        return iterator(_header);
    }
    
    RBTree(const v& data = v())
    {
        _header = new Node(data);
        _header->_left = _header;
        _header->_right= _header;
        _header->_parent = nullptr;
    }
    
    pair<iterator,bool> Insert(const v& data);//插入值为data的节点
    pNode LeftMost();//返回最左节点的地址
    pNode RightMost();//返回最右节点的地址
    void RotateLeft(pNode parent);//左旋
    void RotateRight(pNode parent);//右旋
    void Inorder();//中序遍历打印
    void _Inorder(pNode root);//中序遍历打印
    bool isRBTree();//验证是否为红黑树
    bool _isRBTree(pNode root,int count,int curcount);//前序遍历验证

private:
    pNode _header;//头节点
};

红黑树的插入

红黑树是在二叉搜索树的基础上加上其平衡限制条件，因此红黑树的插入可分为两步：

按照二叉搜索的树规则插入新节点
检测新节点插入后，红黑树的性质是否造到破坏

新节点的默认颜色是红色，如果其父亲节点的颜色是黑色，没有违反红黑树任何性质，则不需要调整；当新插入节点的父亲节点颜色为红色时，就违反了性质，不能有连在一起的红色节点，此
时需要对红黑树分情况来讨论：

约定:cur为当前节点，p为父节点，g为祖父节点，u为叔叔节点

情况一: cur为红，p为红，g为黑，u存在且为红
将p,u改为黑，g改为红，然后把g当成cur，继续向上调整。
情况二: cur为红，p为红，g为黑，u不存在/u为黑
p为g的左孩子，cur为p的左孩子，则进行右单旋转；
相反，p为g的右孩子，cur为p的右孩子，则进行左单旋转；
p、g变色，p变黑，g变红
情况三: cur为红，p为红，g为黑，u不存在/u为黑
p为g的左孩子，cur为p的右孩子，则针对p做左单旋转；
相反，p为g的右孩子，cur为p的左孩子，则针对p做右单旋转；
则转换成了情况2

template<class k, class v, class kov>
inline pair<typename RBTree<k, v, kov>::iterator, bool> RBTree<k, v, kov>::Insert(const v& data)
{
    if (_header->_parent == nullptr)
    {
        pNode root = new Node(data);
        root->_color = BLACK;
        root->_parent = _header;
        _header->_parent = root;
        _header->_left = root;
        _header->_right = root;
        return make_pair(iterator(root), true);    
    }
    pNode cur = _header->_parent;
    pNode parent = nullptr;
    kov kov;
    while (cur)
    {
        parent = cur;
        if (kov(data) > kov(cur->_data))
            cur = cur->_right;
        else if (kov(data) < kov(cur->_data))
            cur = cur->_left;
        else
            return make_pair(iterator(cur), false);
    }
    cur = new Node(data);
    pNode newNode = cur;
    if (kov(data) > kov(parent->_data))
        parent->_right = cur;
    else
        parent->_left = cur;
    cur->_parent = parent;
    while (cur != _header->_parent && cur->_parent->_color == RED)
    {
        pNode parent = cur->_parent;
        pNode gparent = parent->_parent;
        if (parent == gparent->_left)
        {
            pNode unclue = gparent->_right;
            if (unclue && unclue->_color == RED)
            {
                parent->_color = unclue->_color = BLACK;
                gparent->_color = RED;
                cur = gparent;
            }
            else
            {
                if (parent->_right == cur)
                {
                    RotateLeft(parent);
                    swap(parent, cur);
                }
                RotateRight(gparent);
                gparent->_color = RED;
                parent->_color = BLACK;
                break;
            }
         }
         else
         {
             pNode unclue = gparent->_left;
             if (unclue && unclue->_color == RED)
             {
                 parent->_color = unclue->_color = BLACK;
                 gparent->_color = RED;
                 cur = gparent;
             }
             else
             { 
                 if (parent->_left == cur)
                 {
                     RotateRight(parent);
                     swap(parent, cur);
                 }
                 RotateLeft(gparent);
                 gparent->_color = RED;
                 parent->_color = BLACK;
                 break;
             }
         }
     }
     _header->_parent->_color = BLACK;
     _header->_left = LeftMost();
     _header->_right = RightMost();
     return  make_pair(iterator(newNode), true);
}

红黑树的验证

红黑树的验证分为两步：

检测其是否满足二叉搜索树(中序遍历是否为有序序列)；
检测其是否满足红黑树的性质。

template<class k, class v, class kov>
bool RBTree<k, v, kov>::isRBTree()
{
    if (_header->_parent == nullptr)
        return true;
    if (_header->_parent->_color == RED)
        return false;
    int count = 0;
    pNode cur = _header->_parent;
    while (cur)
    {
        if (cur->_color == BLACK)
        ++count;
        cur = cur->_left;
    }
    return _isRBTree(_header->_parent, count, 0);
}

template<class k, class v, class kov>
bool RBTree<k, v, kov>::_isRBTree(pNode root, int count, int curcount)
{
    if (root == nullptr)
    {
        if (curcount != count)
            return false;
        return true;
    }
    if (root->_color == BLACK)
        ++curcount;
    if (root->_parent->_color == RED && root->_color == RED)
        return false;
    return _isRBTree(root->_left, count, curcount)
     && _isRBTree(root->_right, count, curcount); 
}

其他操作的实现

返回最左节点的地址

template<class k, class v, class kov>
typename RBTree<k,v,kov>::pNode RBTree<k, v, kov>::LeftMost()
{
    pNode cur = _header->_parent;
    while (cur && cur->_left)
        cur = cur->_left；
    return cur;
}

返回最右节点的地址

template<class k, class v, class kov>
typename RBTree<k, v, kov>::pNode RBTree<k, v, kov>::RightMost()
{
    pNode cur = _header->_parent;
    while (cur && cur->_right)
        cur = cur->_right;  
    return cur;
}

左旋

template<class k, class v, class kov>
void RBTree<k, v, kov>::RotateLeft(pNode parent)
{
    pNode subR = parent->_right;
    pNode subRL = subR->_left;
    subR->_left = parent;
    parent->_right = subRL;
    if (subRL)
        subRL->_parent = parent;
    if (parent != _header->_parent)
    {
        if (parent->_parent->_left == parent)
            parent->_parent->_left = subR;
        else
            parent->_parent->_right = subR;
        subR->_parent = parent->_parent;
    }
    else
    {
        _header->_parent = subR;
        subR->_parent = _header;
    }
    parent->_parent = subR;
}

右旋

template<class k, class v, class kov>
void RBTree<k, v, kov>::RotateRight(pNode parent)
{
    pNode subL = parent->_left;
    pNode subLR = subL->_right;
    subL->_right = parent;
    parent->_left = subLR;
    if (subLR)
        subLR->_parent = parent;
    if (parent != _header->_parent)
    {
        if (parent->_parent->_left == parent)       
            parent->_parent->_left = subL;        
        else     
            parent->_parent->_right = subL;        
        subL->_parent = parent->_parent;
    }
    else
    {
        _header->_parent = subL;
        subL->_parent = _header;
    }
    parent->_parent = subL;
}

中序遍历打印

template<class k, class v, class kov>
void RBTree<k, v, kov>::Inorder()
{
    _Inorder(_header->_parent);
    cout << endl;
}

template<class k, class v, class kov>
void RBTree<k, v, kov>::_Inorder(pNode root)
{
    if (root)
    {
        _Inorder(root->_left);
        cout << root->_data.first << " ";
        _Inorder(root->_right);
    }
}

红黑树性能分析

红黑树和AVL树都是高效的平衡二叉树，增删改查的时间复杂度都是O(logN)，红黑树不追求绝对平衡，其只需保证最长路径不超过最短路径的2倍，相对而言，降低了插入和旋转的次数，所以在经常进行增删的结构中性能比AVL树更优，而且红黑树实现比较简单，所以实际运用中红黑树更多。

Cassie866

发布了71 篇原创文章 · 获赞 131 · 访问量 2万+

私信关注