【C++】----红黑树

最新推荐文章于 2024-08-11 12:35:26 发布
最新推荐文章于 2024-08-11 12:35:26 发布
阅读量269 收藏
点赞数
文章标签： 数据结构 c++ Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_63601181/article/details/128727875
版权

红黑树可以看作是优化过的二叉搜索树，在插入大量数据的情况下，整体效率优于AVL树。同时C++ STL库中的map和set底层结构是用红黑树实现的，这篇文章讲解红黑树的特性及原理。

一、红黑树的概念

1.1 概念

红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的。

1.2 性质

1. 每个结点不是红色就是黑色

2. 根节点是黑色的

3. 如果一个节点是红色的，则它的两个孩子结点是黑色的

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

5. 每个叶子结点都是黑色的(此处的叶子结点指的是空结点)

二、红黑树实现

2.1 红黑树的节点

红黑树节点中包含：颜色(红or黑)、数据(val)、三叉链。

定义颜色

enum Colour
{
    RED,
    BLACK
};

定义节点

// 节点
template <class K, class V>
struct RBTreeNode
{
    RBTreeNode<K, V>* _parent;
    RBTreeNode<K, V>* _left;
    RBTreeNode<K, V>* _right;

    pair<K, V> _kv;
    Colour _col;

    RBTreeNode(const pair<K, V> kv)
        : _parent(nullptr)
        , _left(nullptr)
        , _right(nullptr)
        , _kv(kv)
    {}
};

2.2 红黑树的插入

红黑树的插入分为两步：

  1. 按照搜索树的规则插入新节点

  1. 检测新节点插入后，红黑树的性质是否造到破坏

template<class ValueType>
class RBTree
{
    //……
    bool Insert(const ValueType& data)
    {
        PNode& pRoot = GetRoot();
        if (nullptr == pRoot)
        {
            pRoot = new Node(data, BLACK);
            // 根的双亲为头节点
            pRoot->_pParent = _pHead;
            _pHead->_pParent = pRoot;
        }
        else
        {
            // 1. 按照二叉搜索的树方式插入新节点
                        // 2. 检测新节点插入后，红黑树的性质是否造到破坏，
            //   若满足直接退出，否则对红黑树进行旋转着色处理
        }
        // 根节点的颜色可能被修改，将其改回黑色
        pRoot->_color = BLACK;
        _pHead->_pLeft = LeftMost();
        _pHead->_pRight = RightMost();
        return true;
    }

private:
    PNode& GetRoot() { return _pHead->_pParent; }
    // 获取红黑树中最小节点，即最左侧节点
    PNode LeftMost();
    // 获取红黑树中最大节点，即最右侧节点
    PNode RightMost();

private:
    PNode _pHead;
};

2.3 红黑树的旋转

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

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

bool Insert(const ValueType& data)
{
    // ...
    // 新节点插入后，如果其双亲节点的颜色为空色，则违反性质3：不能有连在一起的红色结点
        while (pParent && RED == pParent->_color)
        {
            // 注意：grandFather一定存在
            // 因为pParent存在，且不是黑色节点，则pParent一定不是根，则其一定有双亲
            PNode grandFather = pParent->_pParent;
            // 先讨论左侧情况
            if (pParent == grandFather->_pLeft)
            {
                PNode unclue = grandFather->_pRight;
                // 情况三：叔叔节点存在，且为红
                if (unclue && RED == unclue->_color)
                {
                    pParent->_color = BLACK;
                    unclue->_color = BLACK;
                    grandFather->_color = RED;
                    pCur = grandFather;
                    pParent = pCur->_pParent;
                }
                else
                {
                    // 情况五：叔叔节点不存在，或者叔叔节点存在且为黑
                    if (pCur == pParent->_pRight)
                    {
                        _RotateLeft(pParent);
                        swap(pParent, pCur);
                    }
                    // 情况五最后转化成情况四
                    grandFather->_color = RED;
                    pParent->_color = BLACK;
                    _RotateRight(grandFather);
                }
            }
            else
            {
                // ..........
            }
        }
    // ...
}
2.3.1 cur为红，p为红，g为黑，u存在且为红

将p,u改为黑，g改为红，然后把g当成cur，继续向上调整。

2.3.2 cur为红，p为红，g为黑，u不存在/u存在且为黑 ,cur = p->_left

u的情况有两种：

  1. u节点不存在，则cur一定是新插入的节点，因为如果cur不是新插入的节点，则cur和p一定有一个节点的颜色是黑色，就不满足性质4：每条路径包含相同的黑色节点。

  1. 如果u节点存在，则其一定是黑色的那么cur节点原来的颜色一定是黑色的，现在看到其是红色的原因是因为cur的子树在调整的过程中将cur节点的颜色由黑色改为红色。

p为g的左孩子，cur为p的左孩子，则进行右单旋转；相反，

p为g的右孩子，cur为p的右孩子，则进行左单旋转

p、g变色--p变黑，g变红

2.3.3 cur为红，p为红，g为黑，u不存在/u存在且为黑, cur = p->_right

p为g的左孩子，cur为p的右孩子，则针对p做左单旋转；相反，

p为g的右孩子，cur为p的左孩子，则针对p做右单旋转

则转换成了情况2

2.4 红黑树的验证

红黑树的检测分为两步：

1. 检测其是否满足二叉搜索树(中序遍历是否为有序序列)

2. 检测其是否满足红黑树的性质

bool IsValidRBTree()
{
    PNode pRoot = GetRoot();
    // 空树也是红黑树
    if (nullptr == pRoot)
        return true;
    // 检测根节点是否满足情况
    if (BLACK != pRoot->_color)
    {
        cout << "违反红黑树性质二：根节点必须为黑色" << endl;
        return false;
    }
    // 获取任意一条路径中黑色节点的个数
    size_t blackCount = 0;
    
    PNode pCur = pRoot;
    while (pCur)
    {
        if (BLACK == pCur->_color)
            blackCount++;
        pCur = pCur->_pLeft;
    }
    // 检测是否满足红黑树的性质，k用来记录路径中黑色节点的个数
    size_t k = 0;
    return _IsValidRBTree(pRoot, k, blackCount);
}



bool _IsValidRBTree(PNode pRoot, size_t k, const size_t blackCount)
{
    //走到null之后，判断k和black是否相等
    if (nullptr == pRoot)
    {
        if (k != blackCount)
        {
            cout << "违反性质四：每条路径中黑色节点的个数必须相同" << endl;
            return false;
        }
        return true;
    }

    // 统计黑色节点的个数
    if (BLACK == pRoot->_color)
        k++;
    // 检测当前节点与其双亲是否都为红色
    PNode pParent = pRoot->_pParent;

    if (pParent && RED == pParent->_color && RED == pRoot->_color)
    {
        cout << "违反性质三：没有连在一起的红色节点" << endl;
        return false;
    }

    return _IsValidRBTree(pRoot->_pLeft, k, blackCount) &&
        _IsValidRBTree(pRoot->_pRight, k, blackCount);
}

2.5 红黑树与AVL树的比较

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

三、完整代码

RedBlackTree.h

#pragma once

enum Colour
{
    RED,
    BLACK
};



// 节点
template <class K, class V>
struct RBTreeNode
{
    RBTreeNode<K, V>* _parent;
    RBTreeNode<K, V>* _left;
    RBTreeNode<K, V>* _right;

    pair<K, V> _kv;
    Colour _col;

    RBTreeNode(const pair<K, V> kv)
        : _parent(nullptr)
        , _left(nullptr)
        , _right(nullptr)
        , _kv(kv)
    {}
};




// 红黑树
template<class K, class V>
struct RBTree
{
    typedef RBTreeNode<K, V> Node;
public:
    bool Insert(const pair<K, V>& kv)
    {
        if (_root == nullptr)
        {
            _root = new Node(kv);
            _root->_col = BLACK;
            return true;
        }

        Node* parent = nullptr;
        Node* cur = _root;
        while (cur)
        {
            if (cur->_kv.first > kv.first)
            {
                parent = cur;
                cur = cur->_left;
            }
            else if (cur->_kv.first < kv.first)
            {
                parent = cur;
                cur = cur->_right;
            }
            else
            {
                return false;
            }
        }

        cur = new Node(kv);
        cur->_col = RED;
        
        if (parent->_kv.first < kv.first)
        {
            parent->_right = cur;
        }
        else
        {
            parent->_left = cur;
        }

        cur->_parent = parent;

        while (parent&& parent->_col == RED)
        {
            Node* grandfather = parent->_parent;
            assert(grandfather && grandfather->_col == BLACK);

            // 通过uncle分出不同情况
            if (parent == grandfather->_left)
            {
                Node* uncle = grandfather->_right;
                // 情况一 parent uncle都存在且都为红
                // 变色处理
                if (uncle && uncle->_col == RED)
                {
                    grandfather->_col = RED;
                    parent->_col = BLACK;
                    uncle->_col = BLACK;

                    cur = grandfather;
                    parent = cur->_parent;
                }
                //情况二+三 parent存在且为红，uncle存在且为黑   parent存在 unlce不存在
                else
                {
                    if (cur == parent->_left)
                    {
                        // 情况二
                        // 右单旋+变色
                        RotateR(grandfather);
                        parent->_col = BLACK;
                        grandfather->_col = RED;
                    }
                    else
                    {
                        // 情况三
                        // 左右单旋+变色
                        RotateL(parent);
                        RotateR(grandfather);
                        cur->_col = BLACK;
                        grandfather->_col = RED;
                    }

                    break;
                }

            }
            else
            {
                Node* uncle = grandfather->_right;
                // 情况一 parent uncle都存在且都为红
                // 变色处理
                if (uncle && uncle->_col == RED)
                {
                    grandfather->_col = RED;
                    parent->_col = BLACK;
                    uncle->_col = BLACK;

                    cur = grandfather;
                    parent = cur->_parent;
                }
                //情况二+三 parent存在且为红，uncle存在且为黑   parent存在 unlce不存在
                else
                {
                    if (cur == parent->_left)
                    {
                        // 情况二
                        // 左单旋+变色
                        RotateL(grandfather);
                        parent->_col = BLACK;
                        grandfather->_col = RED;
                    }
                    else
                    {
                        // 情况三
                        // 右左单旋+变色
                        RotateR(parent);
                        RotateL(grandfather);
                        cur->_col = BLACK;
                        grandfather->_col = RED;
                    }

                    break;
                }
            }

        }

        _root->_col = BLACK;
        return true;
    }

    void InOrder()
    {
        _InOrder(_root);
        cout << endl;
    }


    bool IsBalance()
    {
        if (_root == nullptr)
        {
            return true;
        }

        if (_root->_col == RED)
        {
            cout << "根节点不是黑色！！！" << endl;
            return false;
        }

        // 黑色节点基准值
        int benchmark = 0;

        return _PrevCheck(_root, 0, benchmark);
    }

private:
    // 中序遍历
    void _InOrder(const Node* root)
    {
        if (root == nullptr)
        {
            return;
        }

        _InOrder(root->_left);
        cout << root->_kv.first << " : " << root->_kv.second << endl;
        _InOrder(root->_right);
    }

    // 检查
    bool _PrevCheck(Node* root, int blacknum, int& benchmark)
    {
        if (root == nullptr)
        {
            if (benchmark == 0)
            {
                benchmark = blacknum;
                return true;
            }

            if (blacknum != benchmark) // 某条路径上黑色节点数目不一样
            {
                cout << "某条路径上黑色节点数目不一样" << endl;
                return false;
            }
            else
            {
                return true;
            }

        }

        if (root->_col = BLACK)
        {
            ++blacknum;
        }

        if (root->_col == RED && root->_parent->_col == RED)
        {
            cout << "存在连续的红色节点！！！" << endl;
            return false;
        }

        return _PrevCheck(root->_left, blacknum, benchmark)
            && _PrevCheck(root->_right, blacknum, benchmark);


    }


    // 功能函数
    //1、左单旋
    void RotateL(Node* parent)
    {
        Node* subR = parent->_right;
        Node* subRL = subR->_left;

        parent->_right = subRL;

        if (subRL)
        {
            subRL->_parent = parent;
        }

        Node* ppNode = parent->_parent;

        subR->_left = parent;
        parent->_parent = subR;

        if (_root == parent)
        {
            _root = subR;
            subR->_parent = nullptr;
        }
        else
        {
            if (ppNode->_left == parent)
            {
                ppNode->_left = subR;
            }
            else
            {
                ppNode->_right = subR;
            }

            subR->_parent = ppNode;
        }
    }


    // 2、右单旋
    void RotateR(Node* parent)
    {
        Node* subL = parent->_left;
        Node* subLR = subL->_right;

        parent->_left = subLR;

        if (subLR)
        {
            subLR->_parent = parent;
        }

        Node* ppNode = parent->_parent;

        subL->_right = parent;
        parent->_parent = subL;

        if (parent == _root)
        {
            _root = subL;
            subL->_parent = nullptr;
        }
        else
        {
            if (ppNode->_left == parent)
            {
                ppNode->_left = subL;
            }
            else
            {
                ppNode->_right = subL;
            }

            subL->_parent = ppNode;
        }
    }

    // 3、左右双旋
    void RotateLR(Node* parent)
    {
        Node* subL = parent->_left;
        Node* subLR = subL->_right;
        int bf = subLR->_bf;

        RotateL(parent->_left);
        RotateR(parent);

    }

    // 4、右左双旋
    void RotateRL(Node* parent)
    {
        Node* subR = parent->_right;
        Node* subRL = subR->_left;


        RotateR(parent->_right);
        RotateL(parent);
    }


private:
    Node* _root = nullptr;
};

test.cpp

#include <iostream>
#include <assert.h>
#include <time.h>
using namespace std;

#include "RedBlack.h"

void TestRBTree1()
{
    int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14, 0,5,30,25,20,4,13,30,28,27 };  // 测试双旋平衡因子调节
    //int a[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };
    RBTree<int, int> t1;
    for (auto e : a)
    {
        t1.Insert(make_pair(e, e));
    }

    t1.InOrder();
    cout << "IsBalance:" << t1.IsBalance() << endl;
}

int main()
{
    TestRBTree1();
    return 0;
}

以上就是本文的全部内容，欢迎大家学习交流。

Abert—
关注
C++红黑树(二)--------红黑树的单旋转
p=f/s
08-19 353
1、 红黑树的单旋转包括向左转和向右转，下图为左旋转的图,详细看下每个节点是如何移动的， 下图为左右单旋转的旋转结果状态图 2、然后我们来实现如下图的红黑树，并进行左右旋转的测试 3、代码如下（接着上篇的代码：C++红黑树(一)--------红黑树的创建和插入Node） #include <iostream> using namespace std; template < class T> class RedBlackTree; //红黑树 ...
c++——红黑树
蜗@牛的博客
07-10 278
一、红黑树的概念 红黑树是一种二叉搜索树，但是每个结点都有表示结点的颜色，可以是Red或Black。 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出2倍，因而是接近平衡的二叉搜索树。 二、红黑树的特性 1、每个节点要么是黑色，要么是红色。 2、根节点是黑色。 3、每个叶子节点（NIL）是黑色。 4、每个红色结点的两个子结点一定都是黑色。 5、任意一结点到每个叶子结点的路径都包含数量相同的黑结点。 三、红黑树的实现 1、红黑树的插入 （1）根节点为空，则直接插入
C++【红黑树】
芊樱烛渊的博客
11-05 1026
AVLTree：要求左右高度差不超过1红黑树：AVLTree过分严格，可能会导致过分的旋转，那能不能不要那么严格呢？需要达到的目的，最长路径不超过最短路径的二倍。也就是说，我们的AVLTree是严格平衡，我们的红黑树是不严格平衡，而是近似平衡结果：相对而言，插入同样的数据，AVL树的旋转更多，红黑树的旋转次数更少假设N是100w，AVL树为logN的高度，也就是大概20左右但是我们的红黑树的话，最短的高度大概是logN也就是20左右，最深的应该为2*logN，为40次左右。
C++——红黑树（图片+动图详解）
最新发布
2301_80687320的博客
08-11 827
在了解完平衡搜索二叉树的优势和应用后，我们学习了AVL树这种方案来实现它，但在前人们的不断使用和开辟，另一种更优的方案横空出世——红黑树。一、红黑树是什么？红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路 径会比其他路径长出俩倍，因而是接近平衡的。通过图片的观察，我们发红黑树有一下几个性质1、每个结点不是红色就是黑色；2、根节点是黑色；3、红色节点不能是连续两个；
【C++】红黑树
大三小白C++进阶之路
05-27 1128
红黑树的模拟实现
红黑树-基于C++实现的红黑树数据结构.zip
03-21
在C++中实现红黑树时，通常会定义一个名为`RBTree`的类，包含私有成员变量（如根节点指针）和公共成员函数（如`insert`, `delete`, `search`等）。类的构造函数初始化空树，而析构函数则负责释放所有节点。为了确保...
C++ - SGI 版本 STL源码
10-25
- **set/multiset**: 基于红黑树的关联容器，存储唯一或允许重复的元素，支持O(log n)的查找、插入和删除操作。 - **map/multimap**: 类似于set，但键值对映射到特定值。 - **unordered_set/unordered_multiset**...
提高组C++（CSP2019-senior-C++-A）.pdf
02-06
- **数据结构优化**：探索如何使用红黑树、B树等高级数据结构来改进程序性能。 综上所述，“提高组C++（CSP2019-senior-C++-A）”这份资料可能包含了许多深入探讨C++高级特性和算法优化技巧的内容，旨在帮助学习者...
C++ 数据结构学习 ---- 红黑树
qq_58240448的博客
11-16 492
学习c++数据结构---红黑树
C++ 红黑树
weixin_53946312的博客
01-28 1528
红黑树
C++红黑树
GreedySnaker的博客
02-17 267
一 红黑树概述 历史上 AVL 树流行的另一变种是红黑树（red-black tree）。对红黑树的操作能保证在最坏情况下动态几何操作的时间为 O(logN) 。之前介绍过AVL 树，该树都是在进行插入和删除操作时通过特定操作保持二叉查找树的平衡，从而获得较高的查找性能。但 RB-Tree 出来之后，便很少有应用场合用到 AVL 。(AVL，平衡二叉树，不了解，可以先行了解后，再了解红黑树事半功倍) 红黑树是二叉查找树，但在每个节点上增加了一位存储位表示该节点的颜色，具体可以是 RED 或 BLACK。通过
C++:红黑树
zhang_si_hang的博客
08-21 1790
1.红黑树的概念红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的。（最长的路径不超过最短路径的2倍，近似平衡）2.红黑树的性质1.每个结点不是红色就是黑色2.根节点是黑色的3. 如果一个节点是红色的，则它的两个孩子结点是黑色的(没有连续的红色节点)
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值