【数据结构】：红黑树（RB Tree）

最新推荐文章于 2022-08-18 12:05:53 发布
最新推荐文章于 2022-08-18 12:05:53 发布
阅读量489 收藏 1
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ChaseRaod/article/details/78384803
版权

红黑树是近似平衡的二叉搜索树。
红黑树的性质:
1，每个节点不是红色就是黑色
2，根节点必须是黑色
3，没有连续的红节点
4，每条路径上黑色节点数目相等

红黑树保证最长路径不超过最短路径的两倍。那么，为什么满足以上这些条件就能保证呢？
最短路径一定是节点全黑，要保证每条路径的黑节点数量相等，只能在两个黑节点之间添加红节点，所以最长路径不会超过最短路径的两倍。
红黑树保证效率为log2^N

这里写图片描述

如上图所示是一棵简单的红黑树，红黑树的插入要通过旋转和变色来调节平衡。

当parent是grandfather的左孩子，uncle是grandfather的右孩子时，插入可分为以下情况：

1，叔叔节点存在且为红色
这里写图片描述

这里写图片描述

Node* grandfther = parent->_parent;
            if (parent == grandfther->_left)
            {
                Node* uncle = grandfther->_right;
                if (uncle && uncle->_col == RED)
                {
                    parent->_col = BLACK;
                    uncle->_col = BLACK;
                    grandfther->_col = RED;

                    cur = grandfther;
                    parent = cur->_parent;
                }

2，叔叔节点不存在或存在且为黑
这里写图片描述

将parent变黑，grandfather变红，进行右单旋
这里写图片描述

else // u 不存在 u黑
                {
                    if(cur == parent->_right) // 双旋
                    {
                        RotateL(parent);
                        swap(cur,parent);
                    }

                    RotateR(grandfther);
                    parent->_col = BLACK;
                    grandfther->_col = RED;
                    break;
                }

3，cur是parent的右孩子，需要双旋
这里写图片描述

当parent是grandfather的右时，需要分析的情况还是以上三种，只是方向相反而已。

完整代码：

#pragma once
#include<iostream>
using namespace std;

enum Colour
{
    RED,
    BLACK,
};

template<class K, class V>
struct RBTreeNode
{
    K _key;
    K _value;

    RBTreeNode<K, V>* _left;
    RBTreeNode<K, V>* _right;
    RBTreeNode<K, V>* _parent;

    Colour _col;

    RBTreeNode(const K& key, const V& value)
        :_key(key)
        , _value(value)
        , _left(NULL)
        , _right(NULL)
        , _parent(NULL)
        , _col(RED)
    {}
};


template<class K, class V>
class RBTree
{
    typedef RBTreeNode<K, V> Node;
public:
    RBTree()
        :_root(NULL)
    {}

    RBTree(const RBTree<K, V>& tree)
    {
        _Copy(tree._root);
    }


    ~RBTree()
    {
        _Destroy(_root);
    }

    RBTree<K, V>& operator = (const RBTree<K, V>& tree)
    {
        RBTree<K, V> tmp(tree);
        swap(_root, tree._root);
        return *this;
    }


    bool Insert(const K& key, const V& value)
    {
        if (_root == NULL)
        {
            _root = new Node(key, value);
            _root->_col = BLACK;
            return true;
        }

        Node* parent = NULL;
        Node* cur = _root;
        while (cur)
        {
            if (cur->_key < key)
            {
                parent = cur;
                cur = cur->_right;
            }
            else if (cur->_key > key)
            {
                parent = cur;
                cur = cur->_left;
            }
            else
            {
                return false;
            }
        }

        cur = new Node(key, value);
        if (parent->_key < key)
        {
            parent->_right = cur;
            cur->_parent = parent;
        }
        else
        {
            parent->_left = cur;
            cur->_parent = parent;
        }

        while (parent && parent->_col == RED)
        {
            Node* grandfather = parent->_parent;
            if (parent == grandfather->_left)
            {
                Node* uncle = grandfather->_right;
                if (uncle && uncle->_col == RED)
                {
                    parent->_col = BLACK;
                    uncle->_col = BLACK;
                    grandfather->_col = RED;

                    cur = grandfather;
                    parent = cur->_parent;
                }
                else // u 不存在 u黑
                {
                    if (cur == parent->_right) // 双旋
                    {
                        RotateL(parent);
                        swap(cur, parent);
                    }

                    RotateR(grandfather);
                    parent->_col = BLACK;
                    grandfather->_col = RED;
                    break;
                }
            }
            //parent = grandfather->right
            else if (parent == grandfather->_right)
            {
                Node* uncle = grandfather->_left;
                if (uncle && uncle->_col == RED)
                {
                    parent->_col = BLACK;
                    uncle->_col = BLACK;
                    grandfather->_col = RED;

                    cur = grandfather;
                    parent = cur->_parent;
                }
                else
                {
                    if (cur == parent->_right)
                    {
                        RotateR(parent);
                        swap(parent, cur);
                    }
                    RotateL(grandfather);
                    parent->_col = BLACK;
                    grandfather->_col = RED;
                    break;
                }
            }
        }
        _root->_col = BLACK;
        return true;
    }

    void InOrder()
    {
        _InOrder(_root);
    }

    bool IsBalance()
    {
        Node* cur = _root;
        if (_root == NULL)
        {
            return true;
        }
        //根节点是黑色
        if (_root->_col == RED)
        {
            return false;
        }
        int BlackNode = 0;
        //统计最左路径上黑色节点的数量
        while (cur)
        {
            if (cur->_col == BLACK)
            {
                ++BlackNode;
            }
            cur = cur->_left;
        }
        //一条路径上黑色节点的数量
        int num = 0;
        return _IsBlance(_root, BlackNode, num);
    }
protected:
    void _Copy(Node* root)
    {
        Node* newNode = NULL;
        Node* cur = root;
        while (cur)
        {
            newNode = new Node(cur->_key, cur->_value);
            newNode->_left = _Copy(cur->_left);
            newNode->_right = _Copy(cur->_right);
        }
    }

    void _Destroy(Node* root)
    {
        Node* cur = root;
        if (root == NULL)
            return;
        _Destroy(cur->_left);
        _Destroy(cur->_right);
        delete cur;
        cur = NULL;
    }


    bool _IsBlance(Node* root, const int BlackNode, int num)
    {
        //一条路径已经走完
        if (root == NULL)
        {
            if (num != BlackNode)
            {
                cout << "黑色节点数量不相等" << endl;
                return false;
            }
            else
            {
                return true;
            }
        }
        if (root->_col == BLACK)
        {
            ++num;
        }
        if((root->_col == RED) && (root->_parent) && (root->_parent->_col == RED))
        {
            cout << "有连续的红节点" << root->_key << endl;
            return false;
        }
        return _IsBlance(root->_left, BlackNode, num)
            && _IsBlance(root->_right, BlackNode, num);
    }

    //右旋
    void RotateR(Node* parent)
    {
        Node* subL = parent->_left;
        Node* subLR = subL->_right;
        parent->_left = subLR;
        if (subLR)
            subLR->_parent = parent;

        subL->_right = parent;
        Node* ppNode = parent->_parent;
        parent->_parent = subL;

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

    //左旋
    void RotateL(Node* parent)
    {
        Node* subR = parent->_right;
        Node* subRL = subR->_left;

        parent->_right = subRL;
        if (subRL)
            subRL->_parent = parent;

        subR->_left = parent;
        Node* ppNode = parent->_parent;
        parent->_parent = subR;

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

    void _InOrder(Node* root)
    {
        Node* cur = root;
        if (cur == NULL)
            return;
        _InOrder(cur->_left);
        cout << cur->_key << " ";
        _InOrder(cur->_right);
    }
private:
    Node* _root;
};

void TestRBTree()
{
    RBTree<int, int> t;
    int a[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };
    for (int i = 0; i < sizeof(a) / sizeof(a[0]); ++i)
    {
        t.Insert(a[i],i);
    }
    t.InOrder();
    cout << endl;
    cout << "IsBalance?" << t.IsBalance() << endl;
}

我们知道，红黑树是近似平衡的二叉树，那么为什么不直接使用平衡二叉树呢？
原因是红黑树最坏的情况也是log2^N,但它不像平衡二叉树需要严格控制平衡因子，红黑树只需控制节点的颜色，因此它的旋转次数相对于平衡二叉树能少一些，因此，实际中，红黑树的应用更为广泛。

红黑树的应用：
1. C++ STL库 – map
2. Java 库
3. linux内核
4. 其他一些库

ChaseRaod
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构--RBTree/BTree/B+Tree
HAH--M的博客
07-29 436
1. 红黑树的性质 红黑树本身就是一颗二叉搜索树，只不过给他添加了很多的限制 红黑树的性质如下： 根节点是黑色 不存在两个红色节点相连的情况 每个节点不是红色就是黑色 所有的叶节点（NiL）都是黑色 2. 变换规则 ...
深入探索RB-tree数据结构
weixin_30677475的博客
04-20 89
引子 部门在各个团队推广软件通用技能矩阵工具，希望通过度量找到能力薄弱点，引导团队进行改进。从我们团队的数据上看，团队在数据结构和算法上的短板明显，需要加强，这也是写这篇文章的背后的初衷。 数据结构和算法是程序员的基本技能，也是大牛程序员的试金石。Linus大神就曾说过："bad programer care about code, good progamer care about dat...
RB-TREE
计算机系秃头少女的博客
09-05 111
定义 高度 B树高度的2倍。 插入 插入点的叔父节点是黑色 AVL树zig\zag操作 插入的叔父节点都是红色 B树上溢->节点分裂
创建RB树c++
weixin_45964488的博客
12-14 809
样例输入1： 13 1 45 34 98 9 4 35 23 36 37 90 85 80 3 85 27 9 样例输出1： 34(B) 4(B) 1(B) 9(B) 23® 45(B) 36(B) 35® 37® 90® 85(B) 80® 98(B) 1 98 34(B) 4(B) 1(B) 23(B) 45(B) 36(B) 35® 37® 90® 80(B) 98(B) 样例输入2： 3 18 2 7 0 样例输出2： 7(B) 2® 18® 2 18 7(B) 2® 18® 注意：遍历输出..
【数据结构】 RBTree(红黑树)简单实现
GoodJob
03-22 780
[数据结构] -- Red-Black-Tree简单实现 红黑树的性质： 1. 红黑树的根节点为黑色 2. 红黑树的节点黑或红 3. 叶子节点为nil黑节点 4. 红色节点的孩子节点为黑色节点 5. 从任意节点到其子孙的叶子节点的路径上包含相同的黑色节点个数（保证了从根节点到叶子节点的最长路径小于最短路径的两倍，从而实现二叉平衡树的局部平衡性） 根据《算法导论》、java 中的Tre...
rb.zip_红黑树_红黑树 打印
最新发布
09-24
红黑树（Red-Black Tree）是一种自平衡二叉查找树，由计算机科学家鲁道夫·贝尔在1978年提出。它在保持二叉查找树特性的同时，通过引入颜色属性来确保树的平衡，从而提高了数据操作的效率。红黑树的主要目标是保证在...
rb_tree.html
07-30
该HTML文件提供离线对平衡二叉树之红黑树在线测试，可以将红黑树的变色旋转步骤显示出来，如果有疑问可以参考我的博客：https://blog.csdn.net/wsdc0521/article/details/107677009
RB_Tree.rar_数据结构_Visual_C++_
08-12
在“RB_Tree.rar_数据结构_Visual_C++_”这个压缩包中，我们可以推测包含了一个C++实现的红黑树数据结构。以下是对红黑树主要知识点的详细解释： 1. **基本概念**： - **节点属性**：每个节点包含键值、颜色（红色...
数据结构红黑树的实现代码
12-06
数据结构中红黑树的实现代码，//建立一个节点 rb_tree_node* RBTree::create_node (int node_data) { rb_tree_node * node=new rb_tree_node; node->left=NULL; node->parent=NULL; node->rb_color=red; ...
rb-tree.rar
05-06
红黑树（Red-Black Tree）是一种自平衡二叉查找树，由计算机科学家朱利奥·平凯利（Juliusz R. Chrobak）和尼尔斯·吉尔伯特（Nils A. Gustafsson）在1978年提出。它的设计目标是保证在最坏情况下的操作效率，比如...
RB树原理与实现
qq_16096353的博客
07-08 383
RB树原理与实现一、基本概念二、基本性质三、左旋和右旋四、插入操作总结 一、基本概念 红黑树是一种自平衡二叉搜索树，节点只有红色和黑色两种颜色。 二、基本性质 节点是红色和黑色； 根节点必须是黑色； 每个叶节点（NULL节点----空节点）都必须是黑色； 每个红节点的两个子节点都是黑色，即每个叶节点到根节点的路径上面不能出现连续的红色节点； 任意节点到到其对应的叶子节点的每条路径上的黑色节点...
红黑树详解
lan墨的博客
07-28 820
红黑树 我们知道二叉查找树有较高的查找速度，同时为了避免单枝树等情况,又希望该二叉树接近于满二叉树，或者二叉树的每一个节点的左、右子树深度尽量相等，这样的二叉树称为平衡二叉树。平衡二叉树的常用实现方法有红黑树、AVL、替罪羊树、Treap、伸展树等。接下来我们看一下红黑树的原理。 定义 红黑树（英语：Red–black tree）是一种自平衡二叉查找树，是在计算机科学中用到的一种数据结构，典型的用...
为什么红黑树的最长路径不超过最短路径的两倍
m0_50170844的博客
03-10 2415
红黑树的性质： 每个节点不是红色就是黑色 根节点为黑色 没有连续的红色节点 对于每个节点，每条路径上的黑色节点数相同 那么为什么当满足以上性质时，就能保证最长路径不超过最短路径的二倍了呢？ 我们分析一下： 最短路径为全黑，最长路径就是红黑节点交替（因为红色节点不能连续），每条路径的黑色节点相同，则最长路径、刚好是最短路径的两倍。 红黑树为什么删除效率高： 红黑树不追求"完全平衡"，即不像AVL那样要求节点的高度差 <= 1，它只要求部分达到平衡，但是提出了为节点增加颜色，红黑是用非严格的平衡来
数据结构-红黑树
m0_61433144的博客
08-18 1112
红黑树也是一种二叉排序树，在红黑树中每个结点存储着对应的颜色(红色或者黑色)，由于AVL树的高度平衡是因为非常频繁地调用旋转来保存自身平衡的，代价较大。所以在AVL树的基础上进一步放宽条件，引入红黑树，即红黑树的最长路径不会比最短路径长两倍。......
数据结构与算法——RB树简介
Be The Best！
03-28 3450
红黑树简介(RB-tree)
数据结构 红黑树（RBTree）的原理与实现
WhiteShirtI的博客
05-20 968
学习红黑树之前你应该保证你学过AVL树，也就是平衡二叉搜索树 数据结构 AVL树 AVL树是一棵高度平衡的二叉搜索树，其要求每个结点的高度差不能大于1，这样子就保证了其查询的时间复杂度为log2(N)，不会出现单支树而导致时间复杂度退化到线性时间。但是AVL树的插入和删除性能非常低下，只要稍微不平衡，都需要进行旋转操作，实现起来也相对困难。所以如果当你需要查询效率高且有序时你可以有优先选择AVL树，但是如果你所需的数据结构是频繁的插入与删除，且需要高效查询且有序时，你可以优先考虑红黑树（RBTree） 红黑
hash vs RBTree
聚焦游戏和图形引擎开发技术
06-07 2382
数据结构：最小堆/哈希表/二叉树/平衡二叉树/红黑树的意义（什么情况下使用）接触堆数据结构是在排序里面讲的，空间复杂度O(1),时间复杂度O(NlogN)，但是在实践中还是不如快速排序（好像快速排序可以更好的利用硬件特性）。堆的意义就在于：最快的找到最大/最小值，在堆结构中插入一个值重新构造堆结构，取走最大/最下值后重新构造堆结构其时间复杂度为O(logN)，而其他方法最少
【Linux编程-数据结构】rbtree
B.souls
10-27 422
Linux kernel rbtree 因编写内核模块时需要用到rbtree来记录异步request，研究分析了一下kernel rbtree的使用方法，记录于此。本文主要参考了内核文档rbtree.txt rbtree简介 Red-black trees（rbtree）是一种自平衡的二叉搜索树，用于存储可分类的key/value数据对。它不同于radix trees或者hash tables。 radix trees用于有效存储稀疏数组（使用长整型索引进行节点的插入、查询和删除），其索引值太大无法用
并查集解决朋友圈问题
ChaseRaod的博客
11-28 1617
题目：加入已知n个人和m对好友关系（存于数组r）,如果两个人是直接或间接的好友（好友的好友的好友………），则认为他们属于同一个朋友圈。请写程序求出这n个人里一共有多少个朋友圈。 例如：n=5,m=3,r={{1，2}，{2，3}，{4，5}}，表示有5个人，1和2是好友，2和3是好友，4和5是好友，则1，2，3属于同一个朋友圈，4和5属于另一个朋友圈。结果为2个朋友圈。这道题目的求解需要用到一种数
深入解析红黑树数据结构
总结来说，红黑树是数据结构中的重要组成部分，广泛应用于各种系统和库，如C++ STL中的map和set，因为它们提供了高效的插入、删除和查找操作。理解和掌握红黑树的原理和操作对于提升编程技能和优化算法性能至关重要...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值