第六章：红黑树

news2024/11/22 4:30:20

系列文章目录

文章目录

  • 系列文章目录
  • 前言
  • 1、红黑树的介绍
    • 1. 红黑树的概念
    • 1.2 红黑树的性质
  • 2、红黑树的节点的定义
  • 3、红黑树的插入（看叔叔的颜色就行）
    • 3.1 情况一：uncle存在且为红
    • 3.2 情况二：uncle不存在/存在且为黑（直线）
    • 3.3 情况三：uncle不存在/存在且为黑（折线）
    • 3.4 总结
  • 4、红黑树的平衡检测
  • 5、红黑树的整体代码

前言

红黑树是一种二叉搜索树，通过来节点颜色来实现接近平衡。

1、红黑树的介绍

1. 红黑树的概念

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

在这里插入图片描述

1.2 红黑树的性质

红黑树本质也是一种二叉搜索树。底层结构需要使用二叉搜索树的地方，基本上都会使用红黑树来实现，而AVL树也因此坐上了冷板凳。

红黑树通过在每个节点上添加一个存储位，用于存储“RED”或“BLACK”。通过节点上红/黑颜色限制，确保最长路径不超过最短路径的两倍，因而它是接近平衡的树形结构。最短路径：全黑；最长路径：一黑一红交替。

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

  2. 根节点是黑色的。

  3. 如果一个节点是红色的，则它的两个孩子结点是黑色的。(不能出现连续的红色节点)

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

  5. 每个叶子结点都是黑色的(此处的叶子结点指的是空结点)。(走到NULL才算一条路径)

最优情况：全黑或每条路径都是一黑一红的满二叉树，高度logN。

最差情况：每颗子树左子树全黑，右子树一黑一红。高度2*logN。

可以发现，最坏情况的时间复杂度和AVL树一样，都是O(logN)，但是红黑树这种近似平衡的结构减少了大量旋转，综合性能优于AVL树。

2、红黑树的节点的定义

// 节点的颜色
enum Color { RED, BLACK };
// 红黑树节点的定义
template<class K, class V>
struct RBTreeNode
{
	RBTreeNode(const pair<K,V>& kv, Color col = RED)
		: _Left(nullptr)
		, _Right(nullptr)
		, _Parent(nullptr)
		, _kv(kv)
		, _col(col)
	{}
	RBTreeNode<K, V>* _Left; // 节点的左孩子
	RBTreeNode<K, V>* _Right; // 节点的右孩子
	RBTreeNode<K, V>* _Parent; // 节点的双亲(红黑树需要旋转，为了实现简单给出该字段)
	pair<K, V> _kv; // 节点的值域
	Color _col; // 节点的颜色
};

但是在构造函数中为什么默认是红色呢？为什么不能是黑色呢？

新节点给红色，可能会违反上面说的红黑树性质3；如果新节点给黑色，必定会违反性质4。

3、红黑树的插入（看叔叔的颜色就行）

插入红色节点后，判定红黑树性质是否被破坏

3.1 情况一：uncle存在且为红

在这里插入图片描述

可以这么想：cur为红那么就需要将parent变为黑；parent变黑需要控制每条路径上黑节点的数量相同，那么就要把uncle变黑；如果grandfather不是根，需要反转为红，用以控制路径黑节点数量相同。继续向上调整即可。

3.2 情况二：uncle不存在/存在且为黑（直线）

uncle的情况分两种：

  1. uncle不存在，则cur为插入节点，单旋即可。

在这里插入图片描述

  1. uncle存在且为黑是第一种情况变过来的。

在这里插入图片描述

3.3 情况三：uncle不存在/存在且为黑（折线）

uncle的情况分两种。

  1. uncle不存在，则cur为插入节点，两次单旋即可。

在这里插入图片描述

  1. uncle存在且为黑，先掰直。

在这里插入图片描述

3.4 总结

插入新节点时，父节点为红，看叔叔的颜色。

1、叔叔存在且为红，变色，向上调整（可能变为三种情况中的任意一种）。

2、叔叔不存在/存在且为黑，直线。单旋+变色。

3、叔叔不存在/存在且为黑，折线，两次单旋+变色。

4、红黑树的平衡检测

//检测是否符合红黑树
bool IsBalance()
{
    if (_root && _root->_col == RED)
    {
        cout << "根节点颜色是红色" << endl;
        return false;
    }

    //基准值
    int benchmark = 0;
    Node* cur = _root;
    while (cur)
    {
        if (cur->_col == BLACK)
            ++benchmark;
        cur = cur->_left;
    }

    //连续红色节点
    return _Check(_root, 0, benchmark);
}

//检验是否有连续的红色节点以及黑色节点的数量
bool _Check(Node* root, int blackNum, int benchmark)
{
    if (root == nullptr)
    {
        if (benchmark != blackNum)
        {
            cout << "某条路径黑色节点的数量不相等" << endl;
            return false;
        }

        return true;
    }

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

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

    return _Check(root->_left, blackNum, benchmark)
        && _Check(root->_right, blackNum, benchmark);
}

  1. 在_IsBalance中确定号一条路径中黑色节点的数量，作为参数传递给Check函数，Check函数需要在递归至根节点时，统计，每条路径黑色节点数量是否和基准值ref相等。

  2. Check函数中还需要判断：子节点为红，父节点也为红（此时不平衡）

5、红黑树的整体代码

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

// 节点的颜色
enum Color { RED, BLACK };
// 红黑树节点的定义
template<class K, class V>
struct RBTreeNode
{
	RBTreeNode(const pair<K,V>& kv, Color col = RED)
		: _left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _kv(kv)
		, _col(col)
	{}
	RBTreeNode<K, V>* _left; // 节点的左孩子
	RBTreeNode<K, V>* _right; // 节点的右孩子
	RBTreeNode<K, V>* _parent; // 节点的双亲(红黑树需要旋转，为了实现简单给出该字段)
	pair<K, V> _kv; // 节点的值域
	Color _col; // 节点的颜色
};

template<class K, class V>
class 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);

		if (parent->_kv.first > kv.first)
		{
			parent->_left = cur;
		}
		else
		{
			parent->_right = cur;
		}

		cur->_parent = parent;//链接父节点

		while (parent && parent->_col == RED)
		{
			Node* grandfather = parent->_parent;
			if (grandfather->_left == parent)
			{
				
				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->_left)
					{
						RotateR(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else
					{
						RotateL(parent);
						RotateR(grandfather);
						cur->_col = BLACK;
						//parent->_col = RED;
						grandfather->_col = RED;
					}

					break;
				}
			}
			else  // grandfather->_right == parent
			{
				Node* uncle = grandfather->_left;
				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(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else
					{
						RotateR(parent);
						RotateL(grandfather);
						cur->_col = BLACK;
						//parent->_col = RED;
						grandfather->_col = RED;
					}

					break;
				}
			}
		}

		_root->_col = BLACK;

		return true;
	}

	//中序遍历
	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}

	//检测是否符合红黑树
	bool IsBalance()
	{
		if (_root && _root->_col == RED)
		{
			cout << "根节点颜色是红色" << endl;
			return false;
		}

		//基准值
		int benchmark = 0;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_col == BLACK)
				++benchmark;
			cur = cur->_left;
		}

		//连续红色节点
		return _Check(_root, 0, benchmark);
	}
	
	//求高度
	int Height()
	{
		return _Height(_root);
	}

	//析构函数
	~RBTree()
	{
		_Destroy(_root);
		_root = nullptr;
	}
private:
	//左旋转
	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 (ppnode == nullptr)
		{
			_root = subR;
			_root->_parent = nullptr;
		}
		else
		{
			if (ppnode->_left == parent)
			{
				ppnode->_left = subR;
			}
			else
			{
				ppnode->_right = subR;
			}

			subR->_parent = ppnode;
		}

		//parent->_bf = subR->_bf = 0;
	}

	//右旋转
	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;
			_root->_parent = nullptr;
		}
		else
		{
			if (ppnode->_left == parent)
			{
				ppnode->_left = subL;
			}
			else
			{
				ppnode->_right = subL;

			}
			subL->_parent = ppnode;
		}

		//parent->_bf = subL->_bf = 0;

	}

	//左右旋转
	void RotateLR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;

		int bf = subLR->_bf;

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

		/*if (bf == 1)
		{
			parent->_bf = 0;
			subLR->_bf = 0;
			subL->_bf = -1;
		}
		else if (bf == -1)
		{
			parent->_bf = 1;
			subLR->_bf = 0;
			subL->_bf = 0;
		}
		else if (bf == 0)
		{
			parent->_bf = 0;
			subLR->_bf = 0;
			subL->_bf = 0;
		}
		else
		{
			assert(false);
		}*/

	}

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

		int bf = subRL->_bf;

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

		/*if (bf == 1)
		{
			parent->_bf = -1;
			subRL->_bf = 0;
			subR->_bf = 0;
		}
		else if (bf == -1)
		{
			parent->_bf = 0;
			subRL->_bf = 0;
			subR->_bf = 1;
		}
		else if (bf == 0)
		{
			parent->_bf = 0;
			subRL->_bf = 0;
			subR->_bf = 0;
		}
		else
		{
			assert(false);
		}*/
	}

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

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

	//检验是否有连续的红色节点以及黑色节点的数量
	bool _Check(Node* root, int blackNum, int benchmark)
	{
		if (root == nullptr)
		{
			if (benchmark != blackNum)
			{
				cout << "某条路径黑色节点的数量不相等" << endl;
				return false;
			}

			return true;
		}

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

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

		return _Check(root->_left, blackNum, benchmark)
			&& _Check(root->_right, blackNum, benchmark);
	}

	//树的高度
	int _Height(Node* root)
	{
		if (root == NULL)
			return 0;

		int leftH = _Height(root->_left);
		int rightH = _Height(root->_right);

		return leftH > rightH ? leftH + 1 : rightH + 1;
	}

	//删除树
	void _Destroy(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}

		_Destroy(root->_left);
		_Destroy(root->_right);
		delete root;
	}

	//查找
	Node* Find(const K& key)
	{
		Node* cur = _root;
		while (cur)
		{
			if (cur->_kv.first < key)
			{
				cur = cur->_right;
			}
			else if (cur->_kv.first > key)
			{
				cur = cur->_left;
			}
			else
			{
				return cur;
			}
		}

		return nullptr;
	}

private:
	Node* _root = nullptr;
};


void Test_RBTree1()
{//测试代码1
	//int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };
	int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };
	RBTree<int, int> t1;
	for (auto e : a)
	{
		t1.Insert(make_pair(e, e));
		//cout << e << ":" << t1.IsBalance() << endl;
	}

	t1.InOrder();
	//cout << t1.IsBalance() << endl;
}

void Test_RBTree2()
{//测试代码2
	srand(time(0));
	const size_t N = 50000;
	RBTree<int, int> t;
	for (size_t i = 0; i < N; ++i)
	{
		size_t x = rand() + i;
		t.Insert(make_pair(x, x));
		//cout << t.IsBalance() << endl;
	}

	//t.Inorder();

	cout << t.IsBalance() << endl;
	cout << t.Height() << endl;
}

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

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

相关文章

Django基础1——项目实现流程

Django基础1——项目实现流程

文章目录 一、前提了解二、准备开发环境2.1 创建项目2.1.1 pycharm创建2.1.2 命令创建 2.2 创建应用 例1&#xff1a;效果实现例2&#xff1a;网页展示日志文件 一、前提了解 基本了解&#xff1a; 官网Django是Python的一个主流Web框架&#xff0c;提供一站式解决方案&#xf…
阅读更多...
Android Studio中引入MagicIndicator

Android Studio中引入MagicIndicator

1.github中下载文件 GitHub - hackware1993/MagicIndicator: A powerful, customizable and extensible ViewPager indicator framework. As the best alternative of ViewPagerIndicator, TabLayout and PagerSlidingTabStrip —— 强大、可定制、易扩展的 ViewPager 指示器框…
阅读更多...
计算机视觉入门 1）卷积分类器

计算机视觉入门 1）卷积分类器

目录 一、卷积分类器&#xff08;The Convolutional Classifer&#xff09;训练分类器 二、【代码示例】汽车卡车图片分类器步骤1. 导入数据步骤2 - 定义预训练模型步骤3 - 连接头部步骤4 - 训练模型 一、卷积分类器&#xff08;The Convolutional Classifer&#xff09; 卷积…
阅读更多...
系统架构设计师之NoSQL数据库及其分类

系统架构设计师之NoSQL数据库及其分类

系统架构设计师之NoSQL数据库及其分类
阅读更多...
结构型（六） - 组合模式

结构型（六） - 组合模式

一、概念 组合模式&#xff08;Composite Pattern&#xff09;&#xff1a;将对象组合成树形结构以表示“部分-整体”的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。 使用场景&#xff1a;组合结构不常用&#xff0c;需要部分与整体的层次关系为树形结…
阅读更多...
网络协议详解之STP

网络协议详解之STP

目录 一、STP协议&#xff08;生成树&#xff09; 1.1 生成树协议核心知识点&#xff1a; 1.2 生成树协议与导致问题&#xff1a; 生成树含义&#xff1a; 1.3 802.1D 规则&#xff1a; 802.1D 缺点&#xff1a; 1.4 PVST cisco私有 1.5 PVST 1.6 快速生成树 快速的原…
阅读更多...
内网穿透软件给企业带来哪些改变？快解析怎么样？

内网穿透软件给企业带来哪些改变？快解析怎么样？

随着科技的发达&#xff0c;使得信息交流变得非常重要。但是企业在使用互联网进行数据传输时面临着一些困境&#xff0c;比如企业内部的服务器无法直接与外部网络进行通信&#xff0c;导致无法远程访问企业内部资源。解决这一问题的有效方法是使用内网穿透软件。下面给大家详细…
阅读更多...
组合总和-LeetCode

组合总和-LeetCode

给你一个无重复元素的整数数组 candidates 和一个目标整数 target &#xff0c;找出 candidates 中可以使数字和为目标数 target 的所有不同组合 &#xff0c;并以列表形式返回。你可以按 任意顺序返回这些组合。 candidates 中的同一个数字可以无限制重复被选取 。如果至少一个…
阅读更多...
WSL2和本地windows端口互通

WSL2和本地windows端口互通

众所周知 WSL 默认安装后&#xff0c;只允许windows访问 Windows Subsystem for Linux&#xff0c;而WSL是不能反之访问本地windows。我之前用vmware的思路认为是nat的网络模式&#xff0c;于是改成了桥接&#xff0c;结果wsl的桥接模式被我改的能访问本地&#xff0c;但是却不…
阅读更多...
猜数字小游戏python

猜数字小游戏python

---------------------------END--------------------------- 题外话 “不是只有程序员才要学编程&#xff1f;&#xff01;” 认真查了一下招聘网站&#xff0c;发现它其实早已变成一项全民的基本技能了。 连国企都纷纷要求大家学Python! 世界飞速发展&#xff0c;互联网…
阅读更多...
【0基础入门Python Web笔记】二、python 之逻辑运算和制流程语句

【0基础入门Python Web笔记】二、python 之逻辑运算和制流程语句

二、python 之逻辑运算和制流程语句 逻辑运算控制流程语句条件语句&#xff08;if语句&#xff09;循环结构&#xff08;for循环、while循环&#xff09;continue、break和pass关键字控制流程语句的嵌套以及elif 更多实战项目可进入下方官网 逻辑运算 Python提供基本的逻辑运算…
阅读更多...
【线程池】换个姿势来看线程池中不一样的阻塞队列（一）

【线程池】换个姿势来看线程池中不一样的阻塞队列（一）

前言 本文中无特别说明的话&#xff0c;线程池指的是 java.util.concurrent #ThreadPoolExecutor 本文只探讨线程池中阻塞队列相关&#xff0c;暂时不对线程池的其他方面进行说明&#xff0c;如果对线程池感兴趣的话&#xff0c;接下来几天我会多分享些和线程池相关的知识&…
阅读更多...
基于蜻蜓算法优化的BP神经网络（预测应用） - 附代码

基于蜻蜓算法优化的BP神经网络（预测应用） - 附代码

基于蜻蜓算法优化的BP神经网络&#xff08;预测应用&#xff09; - 附代码 文章目录 基于蜻蜓算法优化的BP神经网络&#xff08;预测应用&#xff09; - 附代码1.数据介绍2.蜻蜓优化BP神经网络2.1 BP神经网络参数设置2.2 蜻蜓算法应用 4.测试结果&#xff1a;5.Matlab代码 摘要…
阅读更多...
软件测试报告：包含哪些内容？

软件测试报告：包含哪些内容？

软件测试报告的内容 软件测试报告通常包括以下内容&#xff1a; 1、项目背景&#xff1a;介绍测试报告的编写目的、测试系统名称、测试环境和用到的专业术语。 2、需求内容&#xff1a;罗列该项目的测试功能点,具体到每个模块功能&#xff0c;以新增的功能和修改的功能为主&…
阅读更多...
jmeter HTTP请求默认值

jmeter HTTP请求默认值

首先&#xff0c;打开JMeter并创建一个新的测试计划。 右键单击测试计划&#xff0c;选择"添加" > “配置元件” > “HTTP请求默认值”。 在HTTP请求默认值中&#xff0c;您可以设置全局的HTTP请求属性&#xff0c;例如&#xff1a; 服务器地址&#xff1a…
阅读更多...
cad图怎么转换成pdf格式？一招教你轻松转换

cad图怎么转换成pdf格式？一招教你轻松转换

将CAD文件转换成PDF格式有很多优势。首先&#xff0c;PDF格式是一种非常流行的文件格式&#xff0c;几乎所有电脑上都可以打开。这意味着即使将PDF文件发送给其他人&#xff0c;他们也可以轻松地查看文件&#xff0c;此外&#xff0c;PDF格式可以保留CAD文件的图形和布局&#…
阅读更多...
Rancher使用cert-manager安装报错解决

Rancher使用cert-manager安装报错解决

报错&#xff1a; rancher-rke-01:~/rke/rancher-helm/rancher # helm install rancher rancher-stable/rancher --namespace cattle-system --set hostnamewww.rancher.local Error: INSTALLATION FAILED: Internal error occurred: failed calling webhook "webhook…
阅读更多...
Redis-设置密码linux服务器

Redis-设置密码linux服务器

操作步骤 打开Redis的配置文件&#xff0c;通常位于 /etc/redis/redis.conf。在配置文件中找到 #requirepass 或 requirepass 的行&#xff0c;如果存在的话&#xff0c;取消行首的注释符号 #。将密码设置为你想要的值&#xff0c;例如 requirepass YourPassword。确保将 Your…
阅读更多...
嵌入式蓝海变红海？其实是大浪淘沙！

嵌入式蓝海变红海？其实是大浪淘沙！

嵌入式是当下热门的职业方向之一&#xff0c;吸引了众多求职者的目光。然而&#xff0c;有人担心大家一拥而上&#xff0c;导致嵌入式就业竞争激烈&#xff0c;找工作难度大。其实&#xff0c;嵌入式行业的竞争并非无法逾越的天堑&#xff0c;也远远没有从蓝海变成红海&#xf…
阅读更多...
RocketMQ MQTT使用教程

RocketMQ MQTT使用教程

一、概览 传统的消息队列MQ主要应用于服务&#xff08;端&#xff09;之间的消息通信&#xff0c;比如电商领域的交易消息、支付消息、物流消息等等。然而在消息这个大类下&#xff0c;还有一个非常重要且常见的消息领域&#xff0c;即IoT类终端设备消息。近些年&#xff0c;我…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023