红黑树的性质和实现

news2024/10/1 20:02:58

红黑树

由于AVL树为了保持平衡需要经常旋转，开销是很大的。因此，红黑树比起AVL树放宽了平衡的限制。

概念

红黑树，在每个节点上增加一个存储位表示节点的颜色，可以是RED或BLACK。

通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍

因而AVL树是严格平衡，红黑树是接近平衡的

image-20231025151209277

红黑树的性质

首先声明一个定义：简单路径。

从根节点走到NIL节点就是一条简单路径。（NIL节点也就是空节点）

  • 每个节点不是黑色就是红色

  • 根节点是黑色的

  • 如果一个节点是红色的，则它的两个孩子节点必须是黑色的

    也就是说：任何路径上没有连续的红色节点

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

    可以简单的认为：每条路径上黑色节点的数量相同

  • 每个NIL节点都是黑色的

思考：为什么满足上面的性质，红黑树就能保证：其最长路径中节点个数不会超过最短路径节点个数的两倍？

首先要知道：红黑树中，最短路径为全黑路径，最长路径为一黑一红交替路径

再由于每条路径的黑色节点数相同，就能够保证：2*最短路径≤最长路径

红黑树的节点设计

enum Color
{
	RED,
	BLACK
};

template<class K,class V>
struct RETreeNode
{
	RETreeNode<K, V>* _parent;
	RETreeNode<K, V>* _left;
	RETreeNode<K, V>* _right;
	pair<K, V> _kv;
	Color _col;

	RETreeNode(const pair<K, V>& kv)
		:_kv(kv)
		, _parent(nullptr)
		, _left(nullptr)
		, _right(nullptr)
		, _col(RED)
	{}
};

插入的新结点的默认颜色应该是红色。（宁愿是违反性质三也不去违反性质四）

假设插入的是黑色节点，那么路径之间的黑节点的个数不再相同，所有路径都出现了问题

假设插入的是红节点：如果其父亲是黑节点那么一点问题都没有；如果父亲是红节点，那么也只有这一条路径有问题

红黑树的框架设计

template<class K,class V>
class RBTree
{
	typedef RETreeNode<K, V> Node;
public:
    //……
private:
 	Node* _root = nullptr;
};

红黑树的插入

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

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

bool Insert(const pair<K, V>& kv)，下面分布来讲：

第一步：插入节点
//如果为空，则直接新建节点插入即可
if (_root == nullptr)
{
    _root = new Node(kv);
    _root->_col = BLACK;//根节点为黑
    return true;
}

Node* cur = _root;
Node* parent = _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->_parent = parent;
if (parent->_kv.first < kv.first)
{
    parent->_right = cur;
}
else
{
    parent->_left = cur;
}

这里的逻辑就是二叉搜索树插入的逻辑

第二步：检测红黑树性质是否被破坏

因为新节点的默认颜色是红色，因此：

  • 如果其双亲节点的颜色是黑色，没有违反红黑树任何性质，则不需要调整
  • 但当新插入节点的双亲节点颜色为红色时，就违反了性质三不能有连在一起的红色节点

此时需要对红黑树分情况来讨论：

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

情况一：cur为红，p为红，g为黑，u存在且为红

image-20231025160309773

此处看到的树，可能是一棵完整的树，也可能是一棵子树

此外cur并不一定是新插入的节点，有可能是正好向上调整到这个节点

处理方法：

  • p和u变黑，g变红

    此时，局部子树里面，已满足红黑树的性质

  • 继续向上处理：

    • g没有父亲，即g就是根节点，那么将g变黑即可。插入完成
    • g有父亲，且父亲是黑色。那么此时插入完成
    • g有父亲，父亲是红色。将g作为cur，和刚才是相同的处理方式。

    这里向上处理是个循环，而循环的结束条件为：g的父亲不存在或者g的父亲存在且为黑

情况二：cur为红，p为红，g为黑，u不存在或者u存在且为黑

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

u的情况有两种：

  • 如果u不存在，则cur一定是新插入的节点。因为如果不是，那么cur和p一定有一个节点为黑色，此时就不满足性质4了

    image-20231025173053991

  • 如果u存在且为黑，那么cur节点原来的颜色一定是黑色。现在看到其是红色的原因是因为cur在子树调整的过程中将cur从黑色变成红色了

    image-20231025172837656

由于涉及旋转，所以需要对g、p、u的位置进行判断，以便使用对应的旋转

最终代码：

//判断是否破坏红黑树的性质
while (parent && parent->_col == RED)
{
    Node* grandfather = parent->_parent;

    if (parent == grandfather->_left)		//parent在grandfather的左边
    {
        Node* uncle = grandfather->_right;
        if (uncle && uncle->_col == RED)//uncle存在且为红
        {
            //直接变色
            parent->_col = uncle->_col = BLACK;
            grandfather->_col = RED;

            //再向上判断调整
            cur = grandfather;
            parent = cur->_parent;
        }
        else//uncle不存在或为黑
        {
            if (cur == parent->_left)		//cur在parent左侧，需要右单旋
            {
                RotateR(grandfather);
                parent->_col = BLACK;
                grandfather->_col = RED;
            }
            else//cur在parent右侧，需要左右双旋
            {
                RotateL(parent);
                RotateR(grandfather);
                cur->_col = BLACK;
                grandfather->_col = RED;
            }

            break;
        }
    }
    else//parent在grandfather的右边
    {
        Node* uncle = grandfather->_left;
        if (uncle && uncle->_col == RED)//uncle存在且为红
        {
            //直接变色
            parent->_col = uncle->_col = BLACK;
            grandfather->_col = RED;

            //再向上判断调整
            cur = grandfather;
            parent = cur->_parent;
        }
        else//uncle不存在或为黑
        {
            if (cur == parent->_right)	//cur在parent右侧，需要左单旋
            {
                RotateL(grandfather);
                parent->_col = BLACK;
                grandfather->_col = RED;
            }
            else //cur在parent左侧，需要右左双旋
            {
                RotateR(parent);
                RotateL(grandfather);
                cur->_col = BLACK;
                grandfather->_col = RED;
            }

            break;
        }
    }
}

//不管三七二十一，根节点一定为黑
_root->_col = BLACK;
return true;
插入的完整代码
bool Insert(const pair<K, V>& kv)
{
    if (_root == nullptr)
    {
        _root = new Node(kv);
        _root->_col = BLACK;//根节点为黑
        return true;
    }

    Node* cur = _root;
    Node* parent = _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->_parent = parent;
    if (parent->_kv.first < kv.first)
    {
        parent->_right = cur;
    }
    else
    {
        parent->_left = cur;
    }

    //判断是否破坏红黑树的性质
    while (parent && parent->_col == RED)
    {
        Node* grandfather = parent->_parent;

        if (parent == grandfather->_left)	//parent在grandfather的左边
        {
            Node* uncle = grandfather->_right;
            if (uncle && uncle->_col == RED)		//uncle存在且为红
            {
                //直接变色
                parent->_col = uncle->_col = BLACK;
                grandfather->_col = RED;

                //再向上判断调整
                cur = grandfather;
                parent = cur->_parent;
            }
            else		//uncle不存在或为黑
            {
                if (cur == parent->_left)	//cur在parent左侧，需要右单旋
                {
                    RotateR(grandfather);
                    parent->_col = BLACK;
                    grandfather->_col = RED;
                }
                else  //cur在parent右侧，需要左右双旋
                {
                    RotateL(parent);
                    RotateR(grandfather);
                    cur->_col = BLACK;
                    grandfather->_col = RED;
                }

                break;
            }
        }
        else		//parent在grandfather的右边
        {
            Node* uncle = grandfather->_left;
            if (uncle && uncle->_col == RED)		//uncle存在且为红
            {
                //直接变色
                parent->_col = uncle->_col = BLACK;
                grandfather->_col = RED;

                //再向上判断调整
                cur = grandfather;
                parent = cur->_parent;
            }
            else		//uncle不存在或为黑
            {
                if (cur == parent->_right)	//cur在parent右侧，需要左单旋
                {
                    RotateL(grandfather);
                    parent->_col = BLACK;
                    grandfather->_col = RED;
                }
                else  //cur在parent左侧，需要右左双旋
                {
                    RotateR(parent);
                    RotateL(grandfather);
                    cur->_col = BLACK;
                    grandfather->_col = RED;
                }

                break;
            }
        }
    }

    //根节点一定为黑
    _root->_col = BLACK;
    return true;
}

//左单旋
void RotateL(Node* parent)
{
    Node* cur = parent->_right;
    Node* curleft = cur->_left;

    parent->_right = curleft;
    if (curleft)
    {
        curleft->_parent = parent;
    }
    cur->_left = parent;

    Node* ppnode = parent->_parent;//记录parent的原父亲节点

    parent->_parent = cur;

    //对cur的父亲进行更新
    if (parent == _root)
    {
        _root = cur;
        cur->_parent = nullptr;
    }
    else//说明左旋的部分只是某棵树的局部
    {
        if (ppnode->_left == parent)
        {
            ppnode->_left = cur;
        }
        else
        {
            ppnode->_right = cur;
        }
        cur->_parent = ppnode;
    }
}

//右单旋
void RotateR(Node* parent)
{
    Node* cur = parent->_left;
    Node* curright = cur->_right;

    //让右节点接到parent的左边，再将parent接到cur的右边
    parent->_left = curright;
    if (curright)
    {
        curright->_parent = parent;
    }
    cur->_right = parent;

    Node* ppnode = parent->_parent;//记录parent的原父亲节点
    parent->_parent = cur;

    //对cur的父亲进行更新
    if (parent == _root)
    {
        _root = cur;
        cur->_parent = nullptr;
    }
    else//说明右旋的部分只是某棵树的局部
    {
        if (ppnode->_left == parent)
        {
            ppnode->_left = cur;
        }
        else
        {
            ppnode->_right = cur;
        }
        cur->_parent = ppnode;
    }
}

红黑树的验证

红黑树的检测分为两步：

  • 检测其是否满足二叉搜索树（即看中序遍历）
  • 检测其是否满足红黑树的性质

这里主要说一下第二步：

//检查节点颜色
bool CheckColour(Node* root, int blacknum, int benchmark)//这里的blacknum不能是引用，为的就是当回退到根节点时blacknum的值为1，这样能使各路径的黑节点个数之间不会相互影响
{
    //当root为空，说明该路径走到头了，此时将统计的黑节点个数与基准值进行比较
    if (root == nullptr)
    {
        if (blacknum != benchmark)
            return false;

        return true;
    }

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

    //若root为红，且root的父亲存在也为红
    if (root->_col == RED && root->_parent && root->_parent->_col == RED)
    {
        cout << root->_kv.first << "出现连续红色节点" << endl;
        return false;
    }

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

bool IsBalance()
{
    return IsBalance(_root);
}

//判断红黑树是否平衡
bool IsBalance(Node* root)
{
    if (root == nullptr)
        return true;

    //根节点一定为黑
    if (root->_col != BLACK)
        return false;

    //为了判断各路径的黑节点个数是否相同，先给出一个基准值(以最左或最右路径为基准值)
    int benchmark = 0;//基准值
    Node* cur = root;
    while (cur)
    {
        if (cur->_col == BLACK)
            ++benchmark;
        cur = cur->_left;
    }

    return CheckColour(root, 0, benchmark);
}

AVL树和红黑树的比较

AVL树优势在于树的高度低，而红黑树的优势在于旋转次数少

image-20231019221053680

单看搜索，AVL树的效率大概是红黑树的两倍

但其实对于CPU而言，搜索30次和搜索60次，几乎没有区别

所以我们认为两者的性能是同一量级的

但是AVL树控制严格平衡是付出代价的，插入和删除时需要进行大量旋转。而红黑树减少了旋转的次数

我们通过如下代码对AVL树和红黑树的高度和旋转次数进行对比：

分别在AVLTree.h和RBTree.h中添加如下代码：

public:
//计算高度
//获取树的高度
int TreeHeight()
{
    return TreeHeight(_root);
}

int TreeHeight(Node* root)
{
    if (root == nullptr)
        return 0;

    int leftHeight = TreeHeight(root->_left);
    int rightHeight = TreeHeight(root->_right);

    return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
}

//增加一个公有成员：旋转次数
public:
	int _rotateCount = 0;//旋转次数
//分别在红黑树和AVL树的左单旋与右单旋的开头增加一行代码：			  ++_rotateCount

main.cpp中调用代码如下：

#include"RBTree.h"
#include"AVLTree.h"
#include<vector>

int main()
{
	const int N = 1000000;
	vector<int> v;
	v.reserve(N);
	srand(time(0));

	for (size_t i = 0; i < N; i++)
	{
		v.push_back(rand());
	}

	RBTree<int, int> rbt;
	for (auto e : v)
	{
		rbt.Insert(make_pair(e, e));
	}
	cout <<"红黑树是否平衡："<<rbt.IsBalance() << endl;
	cout <<"红黑树高度："<< rbt.TreeHeight() << endl;
	cout <<"红黑树旋转次数："<< rbt._rotateCount << endl;


	AVLTree<int, int> avlt;
	for (auto e : v)
	{
		avlt.Insert(make_pair(e, e));
	}
	cout <<"AVL树是否平衡："<<avlt.IsBalance() << endl;
	cout <<"AVL树高度："<<avlt.Height() << endl;
	cout <<"AVL树旋转次数："<<avlt._rotateCount << endl;

	return 0;
}

两次运行结果：外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

image-20231025175041691

总结：两个树都是高效的平衡二叉树，增删查改的时间复杂度都是logN。不过红黑树降低了旋转次数，因此相对AVL树更优一点，所以被使用的也更多

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1180281.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

EGpKa

EGpKa

利用数据增强的可解释图神经网络预测碳氢化合物的 pKa&#xff0c;原文 Explainable Graph Neural Networks with Data Augmentation for Predicting pKa of C–H Acids&#xff0c;代码在 DATA AND SOFTWARE AVAILABILITY。模型框架如下&#xff1a;
阅读更多...
如何使用Linux DataEase数据可视化分析工具结合内网穿透实现远程办公

如何使用Linux DataEase数据可视化分析工具结合内网穿透实现远程办公

文章目录 前言1. 安装DataEase2. 本地访问测试3. 安装 cpolar内网穿透软件4. 配置DataEase公网访问地址5. 公网远程访问Data Ease6. 固定Data Ease公网地址 前言 DataEase 是开源的数据可视化分析工具&#xff0c;帮助用户快速分析数据并洞察业务趋势&#xff0c;从而实现业务…
阅读更多...
git从入门到会用

git从入门到会用

git从入门到大牛 什么是git理解版本控制版本控制软件 远程仓库git安装windows 安装git 客户端安装下载客户端安装界面介绍 客户端操作仓库管理创建本地仓库切换本地仓库删除本地仓库 文件操作创建文件修改文件删除文件新增/修改/删除 标志 分支管理创建分支切换分支合并分支 标…
阅读更多...
【嵌入式 C 常用算法 3 -- 非线性存储结构 二叉树】

【嵌入式 C 常用算法 3 -- 非线性存储结构 二叉树】

文章目录 树概念介绍树相关术语结点子树结点的度结点的层次有序树和无序树森林空树&#xff08;简单了解即可&#xff09; 二叉树二叉树性质满二叉树完全二叉树 二叉树的深度遍历前序遍历中序遍历后续遍历 二叉树的层次遍历二叉树的顺序存储结构二叉树的顺序存储结构C代码实现 …
阅读更多...
如何解决DC电源模块的电源噪声问题

如何解决DC电源模块的电源噪声问题

BOSHIDA 如何解决DC电源模块的电源噪声问题 在电子设备的设计和制作过程中&#xff0c;电源噪声是一个非常重要的考虑因素。DC电源模块的电源噪声问题是电子设备中普遍存在的问题之一。它不仅会影响设备的性能&#xff0c;还会对设备的寿命和稳定性产生负面影响。因此&#xf…
阅读更多...
第二证券：消费电子概念活跃，博硕科技“20cm”涨停，天龙股份斩获10连板

第二证券：消费电子概念活跃，博硕科技“20cm”涨停，天龙股份斩获10连板

消费电子概念7日盘中再度拉升&#xff0c;到发稿&#xff0c;博硕科技“20cm”涨停&#xff0c;光大同创、波长光电涨超10%&#xff0c;易德龙、向阳科技、得润电子、天龙股份、同兴达等涨停。 博硕科技强势涨停&#xff0c;公司昨日在接受安排调研时表明&#xff0c;公司从上…
阅读更多...
第二证券：炒股常识技巧大全？

第二证券：炒股常识技巧大全？

炒股对许多出资者来说既是一种出资方式&#xff0c;也是一种兴趣。可是&#xff0c;关于初学者来说&#xff0c;炒股可能是一个充溢风险的国际。所以&#xff0c;了解一些炒股的常识技巧关于出资者的长时间成功至关重要。本文将从多个角度分析炒股的常识技巧。 首要&#xff0…
阅读更多...
广域网加速的作用:企业为什么需要广域网加速?

广域网加速的作用:企业为什么需要广域网加速?

由于局域网与广域网之间巨大的带宽鸿沟&#xff0c;通过增加带宽来满足膨胀的流量需求是不切实际的。 并且广域网带宽成本较高&#xff0c;增加广域网带宽对任何企业都意味着巨大的成本负担。这些使得控制 管理广域网带宽使用成为必需。 企业为什么要加速广域网? 对重要的企…
阅读更多...
bilibili快速升满级(使用Docker 容器脚本)

bilibili快速升满级(使用Docker 容器脚本)

部署bilibili升级运行容器脚本 docker run --name"bili" -v /bili/Logs:/app/Logs -e Ray_DailyTaskConfig__Cron"30 9 * * *" -e Ray_LiveLotteryTaskConfig__Cron"40 9 * * *" -e Ray_UnfollowBatchedTaskConfig__Cron"…
阅读更多...
『MySQL快速上手』-②-数据库基础

『MySQL快速上手』-②-数据库基础

文章目录 1.什么是数据库2.MySQL的基本使用2.1 MySQL的安装2.2 连接MySQL服务器2.3 服务器、数据库与表的关系2.4 使用案例 3.SQL语句分类4.存储引擎4.1 什么是存储引擎4.2 查看存储引擎 1.什么是数据库 存储数据用文件就可以了&#xff0c;为什么还要弄个数据库&#xff1f;文…
阅读更多...
批量剪辑神器，专业又好用，支持一站式AI脚本创作、批量剪辑、矩阵分发……

批量剪辑神器，专业又好用，支持一站式AI脚本创作、批量剪辑、矩阵分发……

越来越多短视频领域的小伙伴都用上了超级编导批量剪辑这款软件&#xff0c;这也是小编今天要推广给大家的一款批量剪辑工具。 超级编导问世两年多&#xff0c;吸取了同类软件的优点、并结合市场环境、用户反馈&#xff0c;弥补了其他软件的不足&#xff0c;能够一站式完成AI脚…
阅读更多...
重写abp框架UserManager类

重写abp框架UserManager类

背景&#xff1a;用过abp框架的应该都知道&#xff0c;abp框架会封装一些成熟的类方法提供给使用者来使用&#xff0c;用来操作 一些内置的实体类&#xff08;类中一些字段设置为了protected internal&#xff09;&#xff0c;比如IdentityUser、IdentityRole等。但是这些封装的…
阅读更多...
那些误导消费者的PoE交换机，你知道多少？

那些误导消费者的PoE交换机，你知道多少？

PoE交换机是一种具备供电功能的交换机&#xff0c;广泛运用于安保监控和无线覆盖领域&#xff0c;有效避免了对摄像头和无线AP进行繁琐的电源布线。通常来说&#xff0c;对于规模较大的无线覆盖和网络监控项目&#xff0c;大多数人会选择使用支持PoE的交换机。 自PoE供电技术问…
阅读更多...
必看！2023年最新MSP开源应用程序指南电子书大揭秘

必看！2023年最新MSP开源应用程序指南电子书大揭秘

开源工具有利于节省成本、更好的技术和灵活性已经成为业界的共识。 在理想的世界中&#xff0c;我们用于工作的一切都可以是基于开源的。 但是在生产关键服务的实施和管理中&#xff0c;工程师和业务决策者必须有更好的决策方法来确定哪些工具可以适用于每个需求。 这并不表示…
阅读更多...
A. Hit the Lottery

A. Hit the Lottery

#include<bits/stdc.h> using namespace std; const int N1e55; int n,a[N],res; int main(){scanf("%d",&n);int an/100;n%100;int bn/20;n%20;int cn/10;n%10;int dn/5;n%5;int en;cout<<abcde;return 0; }
阅读更多...
APISpace 手机号码归属地API接口案例代码

APISpace 手机号码归属地API接口案例代码

1.手机号码归属地API产品介绍 APISpace 的 手机号码归属地API&#xff0c;提供全国移动、联通、电信等手机号码归属地查询&#xff0c;上亿条数据囊括最新的170、166、147等号段&#xff0c;更新及时、准确度高。 2.手机号码归属地API详解 2.1 接口请求 请求方式&#xff1a…
阅读更多...
知行电子口岸EDI端口介绍

知行电子口岸EDI端口介绍

电子口岸或者其他物流企业需要确保能够生成和解析符合交通部要求的EDI数据格式。这可能需要进行一些EDI数据映射工作&#xff0c;以确保数据的正确传输和处理。为了支持此需求&#xff0c;我们的开发人员将这些功能模块集成在电子口岸端口中&#xff0c;这个端口的主要功能是将…
阅读更多...
建立TCP连接后发送窗口, 接收窗口, 拥塞窗口的变化情况

建立TCP连接后发送窗口, 接收窗口, 拥塞窗口的变化情况

参数设置 最大段长MSS1KB, 拥塞窗口初始阈值为32KB, 接收窗口为20KB 变化如下
阅读更多...
Unreal UnLua + Lua Protobuf

Unreal UnLua + Lua Protobuf

Unreal UnLua Lua Protobuf https://protobuf.dev/ protobuf wire format&#xff1a;pb 编译到底层的数据协议 https://github.com/starwing/lua-protobuf/blob/master/README.zh.md buffer 处理 lua string 可以当 buffer 用&#xff0c;# len 不会遇到 0 截断&#xf…
阅读更多...
【今天放个大招，带你手把手搭建 Jenkins 的分布式构建】

【今天放个大招，带你手把手搭建 Jenkins 的分布式构建】

UI 自动化测试代码写完了以后&#xff0c;会放到 Jenkins 这样的持续集成工具上去构建。 如果 Jenkins 平台是搭建在服务器上&#xff0c;会面临 2 个问题&#xff1a; 第一个问题是 UI 自动化测试需要渲染界面&#xff0c;需要消耗大量的 CPU 和内存资源&#xff0c;如果服务器…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023