红黑二叉树节点的插入

红黑树的完整C语言实现 红黑树的完整代码实现。按照算法导论给出的算法。附二叉查找树的完整代码。纯C语言实现。 立即下载

进行红黑树节点的插入时候我们必须结合红黑树的性质,要不是真的很容易忙半天却发现写的代码漏洞百出不符合红黑树的性质

  • 主要总的来说是性质,其实笼统的来说我感觉两条性质用来验证就差不多了

    好了,列举额一下吧。

  1. 每个结点不是红色就是黑色
  2. 根节点是黑色的
  3. 如果一个节点是红色的,则它的两个孩子结点是黑色的
  4. 对于每个结点,从该结点到其所有后代叶结点的简单路径上,均 包含相同数目的黑色结点
  5. 每个叶子结点都是黑色的(此处的叶子结点指的是空结点

因为红黑树也是在搜索二叉树的基础上,我先画一颗红黑二叉树吧。
在这里插入图片描述
每个节点的指向是三个方向,但是这个画起来好累啊,构造红黑树的时候一看也就明白了,这里就说明一下啊。。。

  • 红黑树节点的定义
#include <iostream>
using namespace std;


enum COLOR{ RED, BLACK };

template<class V>
struct RBTreeNode
{
	RBTreeNode(const V& value = V(), COLOR color = RED)
	: _pLeft(nullptr)
	, _pRight(nullptr)
	, _pParent(nullptr)
	, _value(value)
	, _color(color)
	{}

	RBTreeNode<V>* _pLeft;
	RBTreeNode<V>* _pRight;
	RBTreeNode<V>* _pParent;
	V _value;        // 节点值域
	COLOR _color;    // 节点的颜色
};

这里还是主要看一下插入吧,如果在把删除看一下,估计要把博客写道半夜了。
红黑树的插入时候主要分三种情况,三种情况都涉及到颜色调整的,两种都涉及到旋转,所以红黑树必须是要研究三代的,这里是必须把图画清楚的
还有新插入节点默认着色是红色的,如果是黑色,每条路径上黑色节点的个数都相等这一条很重要的性质直接就违背了

我们用pCur代表当前节点的位置,用p代表父节点的位置,用g代表祖父节点,用u代表叔父节点

  • p,u都为红色节点,g为黑色节点
    在这里插入图片描述
    这种情况下插入节点的P,U都为红色,而G节点为黑色插入的节点对红黑树G的左右子树并没有造成什么影响,从这种调整来说并没有影响那条路径上的黑色节点数量,黑色节点的数量还是相等的。

  • P 为红,G为黑,U为黑或者不存在(这里分两种小情况,类似AVL树左旋右旋)
    在这里插入图片描述
    这种情况我画的是pCur在P左,P在G左,这种情况下,以P为旋转中心经行左旋。

    如果我们的pCur在P右,P在G右,我们进行右旋,这两种旋转的前提都是情况2,所以就把这两种情况当作子情况归入2当中了

  • P为红,G为黑,U为黑或者不存在(前提条件类似情况2,但是三个节点所处的位置为内侧,而情况2为外侧)
    在这里插入图片描述
    这种情况下是左右单旋,总之了旋转就是按我图上所画的,这种旋发,好像叫法还不一样,如果位于右子树内侧的话,旋转这是从这种旋转的右边角度来看道理上都是一个模子刻出来的

  • 插入代码

template<class V>
class RBTRee
{
	typedef RBTreeNode<V> Node;
	typedef Node* PNode;
public:
	RBTRee()
	{
		_pHead = new Node;
		_pHead->_pLeft = _pHead;
		_pHead->_pRight = _pHead;
		_pHead->_pParent = nullptr;
	}

	bool Insert(const V& value)
	{
		PNode& pRoot = GetRoot();

		if (nullptr == pRoot)
		{
			pRoot = new Node(value, BLACK);
		}
		else
		{
			// 找待插入节点的位置
			PNode pCur = pRoot;
			PNode pParent = nullptr;
			while (pCur)
			{
				pParent = pCur;
				if (value == pCur->_value)
					return true;
				else if (value < pCur->_value)
					pCur = pCur->_pLeft;
				else
					pCur = pCur->_pRight;
			}

			// 插入新节点
			pCur = new Node(value);
			if (value < pParent->_value)
				pParent->_pLeft = pCur;
			else
				pParent->_pRight = pCur;

			pCur->_pParent = pParent;

			// 更新节点的颜色,满足红黑树性质
			// ....
			while (pParent && RED == pParent->_color)
			{
				PNode grandFather = pParent->_pParent;
				if (pParent == grandFather->_pLeft)
				{
					PNode uncle = grandFather->_pRight;
					if (uncle && uncle->_color == RED)
					{
						// 情况一:叔叔节点存在且为红色
						pParent->_color = BLACK;
						uncle->_color = BLACK;
						grandFather->_color = RED;
						pCur = grandFather;
						pParent = pCur->_pParent;
					}
					else
					{
						// 叔叔节点不存在 || 叔叔节点存在且为黑色
						// 情况三
						if (pCur == pParent->_pRight)
						{
							RotateLeft(pParent);
							swap(pCur, pParent);
						}

						// 情况二
						RotateRight(grandFather);
						swap(grandFather->_color, pParent->_color);
					}
				}
				else
				{
					PNode unclue = grandFather->_pLeft;
					// 右侧--情况一
					if (unclue && RED == unclue->_color)
					{
						unclue->_color = BLACK;
						pParent->_color = BLACK;
						grandFather->_color = RED;
						pCur = grandFather;
						pParent = pCur->_pParent;
					}
					else
					{
						// 叔叔节点不存在 || 叔叔节点存在且为黑色
						if (pCur == pParent->_pLeft)
						{
							RotateRight(pParent);
							swap(pParent, pCur);
						}

						RotateLeft(grandFather);
						swap(grandFather->_color, pParent->_color);
					}
				}
			}
		}

		_pHead->_pLeft = LeftMost();
		_pHead->_pRight = RightMost();
		_pHead->_pParent->_color = BLACK;
		return true;
	}

插入除了分情况旋转外,其他操作其实还是类比搜索二叉树的。

  • 最后来看一下验证是否符合红黑树二叉树性质
bool IsValidRBTree()
	{
		PNode& pRoot = GetRoot();
		if (nullptr == pRoot)
			return true;

		if (RED == pRoot->_color)
		{
			cout << "违反性质二:根节点的颜色红色" << endl;
			return false;
		}

		// 获取左左侧路径中黑色节点的个数
		size_t blackCount = 0;
		PNode pCur = pRoot;
		while (pCur)
		{
			if (BLACK == pCur->_color)
				blackCount++;

			pCur = pCur->_pLeft;
		}

		size_t pathCount = 0;
		return _IsBalidRBTRee(pRoot, pathCount, blackCount);
	}
	bool _IsBalidRBTRee(PNode pRoot, size_t pathCount, size_t blackCount)
	{
		if (nullptr == pRoot)
			return true;

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

		if (BLACK == pRoot->_color)
			pathCount++;

		if (nullptr == pRoot->_pLeft && nullptr == pRoot->_pRight)
		{
			if (pathCount != blackCount)
			{
				cout << "违反性质四: 每条路径中黑色节点必须相同" << endl;
				return false;
			}
		}

		return _IsBalidRBTRee(pRoot->_pLeft, pathCount, blackCount) &&
			_IsBalidRBTRee(pRoot->_pRight, pathCount, blackCount);
	}

	void _InOrder(PNode pRoot)
	{
		if (pRoot)
		{
			_InOrder(pRoot->_pLeft);
			cout << pRoot->_value << endl;
			_InOrder(pRoot->_pRight);
		}
	}

	PNode& GetRoot()
	{
		return _pHead->_pParent;
	}

	PNode LeftMost()
	{
		PNode pRoot = GetRoot();
		if (nullptr == pRoot)
			return _pHead;

		PNode pCur = pRoot;
		while (pCur->_pLeft)
			pCur = pCur->_pLeft;

		return pCur;
	}

	PNode RightMost()
	{
		PNode pRoot = GetRoot();
		if (nullptr == pRoot)
			return _pHead;

		PNode pCur = pRoot;
		while (pCur->_pRight)
			pCur = pCur->_pRight;

		return pCur;
	}

	void RotateLeft(PNode pParent)
	{
		PNode pSubR = pParent->_pRight;
		PNode pSubRL = pSubR->_pLeft;

		pParent->_pRight = pSubRL;
		if (pSubRL)
			pSubRL->_pParent = pParent;

		pSubR->_pLeft = pParent;
		PNode pPParent = pParent->_pParent;
		pParent->_pParent = pSubR;
		pSubR->_pParent = pPParent;

		PNode& pRoot = GetRoot();
		if (pParent == pRoot)
			pRoot = pSubR;
		else
		{
			if (pPParent->_pLeft == pParent)
				pPParent->_pLeft = pSubR;
			else
				pPParent->_pRight = pSubR;
		}
	}

	void RotateRight(PNode pParent)
	{
		PNode pSubL = pParent->_pLeft;
		PNode pSubLR = pSubL->_pRight;

		pParent->_pLeft = pSubLR;
		if (pSubLR)
			pSubLR->_pParent = pParent;

		pSubL->_pRight = pParent;
		PNode pPParent = pParent->_pParent;
		pSubL->_pParent = pPParent;
		pParent->_pParent = pSubL;

		PNode& pRoot = GetRoot();
		if (pParent == pRoot)
			pRoot = pSubL;
		else
		{
			if (pPParent->_pLeft == pParent)
				pPParent->_pLeft = pSubL;
			else
				pPParent->_pRight = pSubL;
		}
	}

是否是红黑二叉树验证时候需要验证的性质其实主要是四条,但是最主要验证的还是每条路径上黑色节点的数量是否相等。验证相等时候我们选取最左侧的路径作为对比路径,计算出左侧节点的黑色节点个数,然后与验证路径对比,如果相符就满足。

  • 完整代码


#include <iostream>
using namespace std;


enum COLOR{ RED, BLACK };

template<class V>
struct RBTreeNode
{
	RBTreeNode(const V& value = V(), COLOR color = RED)
	: _pLeft(nullptr)
	, _pRight(nullptr)
	, _pParent(nullptr)
	, _value(value)
	, _color(color)
	{}

	RBTreeNode<V>* _pLeft;
	RBTreeNode<V>* _pRight;
	RBTreeNode<V>* _pParent;
	V _value;        // 节点值域
	COLOR _color;    // 节点的颜色
};


template<class V>
class RBTRee
{
	typedef RBTreeNode<V> Node;
	typedef Node* PNode;
public:
	RBTRee()
	{
		_pHead = new Node;
		_pHead->_pLeft = _pHead;
		_pHead->_pRight = _pHead;
		_pHead->_pParent = nullptr;
	}

	bool Insert(const V& value)
	{
		PNode& pRoot = GetRoot();

		if (nullptr == pRoot)
		{
			pRoot = new Node(value, BLACK);
		}
		else
		{
			// 找待插入节点的位置
			PNode pCur = pRoot;
			PNode pParent = nullptr;
			while (pCur)
			{
				pParent = pCur;
				if (value == pCur->_value)
					return true;
				else if (value < pCur->_value)
					pCur = pCur->_pLeft;
				else
					pCur = pCur->_pRight;
			}

			// 插入新节点
			pCur = new Node(value);
			if (value < pParent->_value)
				pParent->_pLeft = pCur;
			else
				pParent->_pRight = pCur;

			pCur->_pParent = pParent;

			// 更新节点的颜色,满足红黑树性质
			// ....
			while (pParent && RED == pParent->_color)
			{
				PNode grandFather = pParent->_pParent;
				if (pParent == grandFather->_pLeft)
				{
					PNode uncle = grandFather->_pRight;
					if (uncle && uncle->_color == RED)
					{
						// 情况一:叔叔节点存在且为红色
						pParent->_color = BLACK;
						uncle->_color = BLACK;
						grandFather->_color = RED;
						pCur = grandFather;
						pParent = pCur->_pParent;
					}
					else
					{
						// 叔叔节点不存在 || 叔叔节点存在且为黑色
						// 情况三
						if (pCur == pParent->_pRight)
						{
							RotateLeft(pParent);
							swap(pCur, pParent);
						}

						// 情况二
						RotateRight(grandFather);
						swap(grandFather->_color, pParent->_color);
					}
				}
				else
				{
					PNode unclue = grandFather->_pLeft;
					// 右侧--情况一
					if (unclue && RED == unclue->_color)
					{
						unclue->_color = BLACK;
						pParent->_color = BLACK;
						grandFather->_color = RED;
						pCur = grandFather;
						pParent = pCur->_pParent;
					}
					else
					{
						// 叔叔节点不存在 || 叔叔节点存在且为黑色
						if (pCur == pParent->_pLeft)
						{
							RotateRight(pParent);
							swap(pParent, pCur);
						}

						RotateLeft(grandFather);
						swap(grandFather->_color, pParent->_color);
					}
				}
			}
		}

		_pHead->_pLeft = LeftMost();
		_pHead->_pRight = RightMost();
		_pHead->_pParent->_color = BLACK;
		return true;
	}

	void InOrder()
	{
		_InOrder(GetRoot());
	}

	bool IsValidRBTree()
	{
		PNode& pRoot = GetRoot();
		if (nullptr == pRoot)
			return true;

		if (RED == pRoot->_color)
		{
			cout << "违反性质二:根节点的颜色红色" << endl;
			return false;
		}

		// 获取左左侧路径中黑色节点的个数
		size_t blackCount = 0;
		PNode pCur = pRoot;
		while (pCur)
		{
			if (BLACK == pCur->_color)
				blackCount++;

			pCur = pCur->_pLeft;
		}

		size_t pathCount = 0;
		return _IsBalidRBTRee(pRoot, pathCount, blackCount);
	}

private:
	bool _IsBalidRBTRee(PNode pRoot, size_t pathCount, size_t blackCount)
	{
		if (nullptr == pRoot)
			return true;

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

		if (BLACK == pRoot->_color)
			pathCount++;

		if (nullptr == pRoot->_pLeft && nullptr == pRoot->_pRight)
		{
			if (pathCount != blackCount)
			{
				cout << "违反性质四: 每条路径中黑色节点必须相同" << endl;
				return false;
			}
		}

		return _IsBalidRBTRee(pRoot->_pLeft, pathCount, blackCount) &&
			_IsBalidRBTRee(pRoot->_pRight, pathCount, blackCount);
	}

	void _InOrder(PNode pRoot)
	{
		if (pRoot)
		{
			_InOrder(pRoot->_pLeft);
			cout << pRoot->_value << endl;
			_InOrder(pRoot->_pRight);
		}
	}

	PNode& GetRoot()
	{
		return _pHead->_pParent;
	}

	PNode LeftMost()
	{
		PNode pRoot = GetRoot();
		if (nullptr == pRoot)
			return _pHead;

		PNode pCur = pRoot;
		while (pCur->_pLeft)
			pCur = pCur->_pLeft;

		return pCur;
	}

	PNode RightMost()
	{
		PNode pRoot = GetRoot();
		if (nullptr == pRoot)
			return _pHead;

		PNode pCur = pRoot;
		while (pCur->_pRight)
			pCur = pCur->_pRight;

		return pCur;
	}

	void RotateLeft(PNode pParent)
	{
		PNode pSubR = pParent->_pRight;
		PNode pSubRL = pSubR->_pLeft;

		pParent->_pRight = pSubRL;
		if (pSubRL)
			pSubRL->_pParent = pParent;

		pSubR->_pLeft = pParent;
		PNode pPParent = pParent->_pParent;
		pParent->_pParent = pSubR;
		pSubR->_pParent = pPParent;

		PNode& pRoot = GetRoot();
		if (pParent == pRoot)
			pRoot = pSubR;
		else
		{
			if (pPParent->_pLeft == pParent)
				pPParent->_pLeft = pSubR;
			else
				pPParent->_pRight = pSubR;
		}
	}

	void RotateRight(PNode pParent)
	{
		PNode pSubL = pParent->_pLeft;
		PNode pSubLR = pSubL->_pRight;

		pParent->_pLeft = pSubLR;
		if (pSubLR)
			pSubLR->_pParent = pParent;

		pSubL->_pRight = pParent;
		PNode pPParent = pParent->_pParent;
		pSubL->_pParent = pPParent;
		pParent->_pParent = pSubL;

		PNode& pRoot = GetRoot();
		if (pParent == pRoot)
			pRoot = pSubL;
		else
		{
			if (pPParent->_pLeft == pParent)
				pPParent->_pLeft = pSubL;
			else
				pPParent->_pRight = pSubL;
		}
	}
private:
	PNode _pHead;
};


void TestRBTree()
{
	int array[] = { 5, 3, 4, 1, 7, 8, 2, 6, 0, 9 };
	RBTRee<int> t;
	for (auto e : array)
		t.Insert(e);

	t.InOrder();

	if (t.IsValidRBTree())
	{
		cout << "valid rbtree" << endl;
	}
	else
	{
		cout << "invalid rbtree" << endl;
	}
}
int main()
{
	TestRBTree();
	return 0;

}


验证一下
在这里插入图片描述

CUDA详细安装及环境配置——环境配置指南 – CUDA+cuDNN+PyTorch 安装 本文详细介绍了如何确定显卡支持的CUDA版本、选择对应的cuDNN版本,并逐步安装CUDA、cuDNN和PyTorch。首先,通过命令行输入nvidia-smi.exe查看显卡支持的CUDA版本。接着,根据CUDA版本选择对应的cuDNN版本并下载。然后,从NVIDIA官方网站下载CUDA安装包,按照提示进行安装,并检查是否安装成功。同样地,下载cuDNN安装包,解压后将文件拷贝到CUDA安装目录中,并通过命令行验证安装是否成功。最后,根据PyTorch官网的指引,选择合适的安装命令进行PyTorch的安装 阅读详情

相关推荐

中科蓝讯蓝牙耳机SDK实战:从目录解析到消息处理框架

本文深入解析中科蓝讯蓝牙耳机SDK的目录结构与消息处理框架,提供从硬件驱动到蓝牙功能定制的实战指南。重点剖析SDK核心模块如消息队列机制、按键事件处理及电量报告优化,并分享二次开发中的调试技巧与避坑经验,助力开发者高效完成TWS耳机功能定制。

weixin_30335575的博客 390

红黑树的插入过程(图解)

红黑树是一种自平衡的二叉查找树它具有以下5个性质:1、节点颜色必须是红色或者黑色2、根节点是黑色3、每个叶子节点(NIL节点、空节点)是黑色的4、每个红色节点的两个子节点都是黑色5、从任一节点到每个叶子的所有路径都包含数目相同的黑色节点上图就是一颗红黑树,所有的空节点都指向最后这个黑色节点,称它为哨兵节点,从根节点沿任一路径出发到达哨兵节点,路径上的黑色节点总数是相同的。了解完红黑树的基本性质,我...

Lyt15829797751的博客 1万+

用AI+Playwright实现零代码UI自动化测试:以登录页面为例的实战指南

本文详细介绍了如何利用AI与Playwright结合实现零代码UI自动化测试,特别以登录页面为例进行实战演示。通过自然语言描述生成测试脚本,大幅降低技术门槛,提升测试效率,并支持跨浏览器验证。适合非技术人员快速上手专业级自动化测试。

weixin_28842269的博客 404

【算法导论】红黑树详解之插入

https://blog.youkuaiyun.com/cyp331203/article/details/42677833         红黑树是建立在二叉查找树的基础之上的,关于二叉查找树可以参看【算法导论】二叉搜索树的插入和删除和【算法导论】二叉树的前中后序非递归遍历实现。对于高度为h的二叉查找树而言,它的SEARCH、INSERT、DELETE、MINIMUM、MAXIMUM等操作的时间复杂度均为O(h)。所以

yygr的博客 2251

【漏洞修复】Diffie-Hellman Key Agreement Protocol 资源管理错误漏洞(CVE-2002-20001)

Diffie-Hellman Key Agreement Protocol 存在安全漏洞,远程攻击者可以发送实际上不是公钥的任意数字,并触发服务器端DHE模幂计算。

我的博客 1万+

AI 视觉宠物喂食器:智能识别 + 精准投喂,打造宠物喂养新体验

AI 视觉宠物喂食器将边缘 AI 计算与传统硬件结合,既解决了传统喂食器的核心痛点,又兼顾了 DIY 的易用性和扩展性。无论是宠物主人 DIY 使用,还是小型创客团队产品化,该方案都具备较高的实用价值和落地性,为宠物智能化喂养提供了轻量化的实现路径。

weixin_42300449的博客 419

红黑树详解(二)红黑树的插入(附动图和案例)

红黑树详解(二)红黑树的插入(附动图和案例) 摘要:     在很多源码涉及到大量数据处理的时候,通常都是用红黑树这一数据结构。红黑树是一种自平衡的二叉查找树,它能在进行插入和删除操作时通过特定操作保持二叉查找树的平衡,获得较高的查找性能。本文将使用图文详细的分析红黑树的插入 ​ 回顾一下红黑树的五条性质 1.节点不是红色就...

程序猿练习生 3004

高通平台蓝牙学习-- 基于WCN6750 Bluetooth 5.2的讲解

摘要:蓝牙5.2解决方案WCN6750具备多项先进特性:完全兼容5.2标准及ANT+协议,支持2Mbps高速BLE和长距离传输;采用射频集成方案,与WLAN共享天线并支持5G并发;内置功率放大器,支持Class1/2传输;提供双音频流和Slimbus接口优化。其HCI UART接口支持3.2Mbps速率,通过BlueZ协议栈实现蓝牙5.2功能,包括2Mbps模式和长距离传输,符合核心规范要求。(149字)

专业开发者的博客,一个从事Android WiFi和蓝牙的工程师 3万+

红黑二叉树插入

红黑树是一棵二叉搜索书,它在每个结点上增加了一个存储位来表示结点颜色(RED或BLACK)。通过对任何一条从根到叶子的简单路径上各个节点的颜色进行约束,红黑树确保没有一条路径会比其他路径长出2倍,因而是近似于平衡的。 树中每个结点包含5个属性:color,key,left,right和p。 一棵红黑树是满足下面红黑性质的二叉搜索树: 1.每个节点或是红色的,或是黑色的。 2.根

在路上 820

使用DrissionPage实现携程酒店信息智能爬取

本文介绍了一个基于DrissionPage技术的携程酒店信息爬虫系统,通过监听API数据包实现高效采集。系统可自动获取酒店名称、价格、评分、位置等15个维度的数据,支持多页滚动加载和智能去重。相比传统爬虫,该方法直接解析API返回的JSON数据,避免了复杂的HTML解析和加密参数分析,提高了开发效率和稳定性。文章详细阐述了13个关键实现步骤,并强调数据采集应严格遵守法律法规,仅用于技术学习和市场研究。该系统可为旅游决策、价格监测等提供数据支持,但需注意合理使用频率和隐私保护。

那些看似不起波澜的日复一日,会在某天让你看到坚持的意义 392

23、电生理与CSD分析:探索大脑活动的前沿技术

本文介绍了电生理与电流源密度(CSD)分析在探索大脑活动中的前沿应用。从电生理技术的发展现状,到局部场电位(LFPs)的起源与解释,重点阐述了CSD分析的原理、实验方法及其在绘制皮层兴奋流、解析突触输入和研究自发振荡中的广泛应用。文章还总结了该领域的优势与挑战,并展望了技术改进、多模态融合、数据分析创新及临床拓展的未来方向,展示了这些技术在揭示大脑功能机制中的关键作用。

Apple的专栏 124

红黑树及插入过程详解

介绍红黑树的特点,以及红黑树插入节点后的调整方式

weixin_49561506的博客 1720

在 IW31 录入班次与当班负责人,并让 IW38 列表同步显示:基于 IWO10018 + IWOC0004 的一套可落地增强方案

摘要 本文详细介绍了在SAP PM模块中实现工厂设备维护订单增强的完整方案,重点解决两个核心需求:在订单创建时新增班次负责人和班次字段,并在订单列表中直接显示这些信息。文章从需求分析、技术设计到具体实现步骤进行了系统阐述。 关键实现步骤包括: 通过CI_AUFK结构扩展AUFK表,确保字段持久化存储 使用IWO10018增强在IW31/IW32/IW33事务中添加输入界面 通过IWOC0004增强在IW38订单列表中显示新增字段 采用优化的数据填充策略提升性能 该方案不仅满足业务需求,还考虑了用户体验和系统

2007 年 ~ 2025 年,深耕 SAP 技术 18 年 182

详解c++---红黑二叉树的原理和实现

红黑二叉树的原理以及模拟实现

qq_68695298的博客 2166

最新的sdio 4.0 spec 协议标准 带书签 高清完整PDF版

Part-E1-SDIO-Specification-Ver4.00-Final-120220.pdf:最新的sdio 4.0 spec 协议标准 带书签 高清完整PDF版,包括SDIO 接口的外设,SDIO 接口官方协议等。

C# WinForm 基于DirectShow.dll编写的程序,可边预览边保存视频,音频和图片

基于微软的DirectShow.dll的二次开发1.自动识别连接的摄像头跟麦克风且可以对其进行选择(默认选中第一个)2.可录制wmv和avi两种格式的视频并且都带有音频,avi可以录制的分辨率和帧数进行选择,wmv默认进行了淸晰度优化如不喜欢可去除代码中有相关提示3.可在预览点开之后进行拍照,也可边录制视频边拍照4.添加了视频和音频的压缩功能(酌情使用)这次二次开发发现C#对DirectShow的相关信息太少,这次做完也不敢藏私共享出来,还望大家指正

java Collection-Map 之 TreeMap

TreeMap 内部定义了一个类 static final class Entry<K,V> implements Map.Entry<K,V>,(自平衡红黑二叉树)作为数据存储节点。 put方法先判断根节点是否为空,为空则在跟节点放置数据。 不为空,(调用比较器)将put的key循环比较parent节点的key,并动态修改parent的指向。最终存入数据。...

ankuaixiao2504的博客 139

android 蓝牙通讯demo

android 下蓝牙通讯demo,实现了发现蓝牙,使能蓝牙,通过蓝牙发送消息。

HashMap源码分析

HashMap 源码分析,红黑二叉树

Crooky1的博客 106

Statistics and Machine Learning Toolbox

Statistics and Machine Learning Toolbox(带书签),MATLAB统计学习工具

红黑树

背景 二叉搜索树可以支持任何一种基本动态集合操作,二叉搜索树 介绍了高度为h的二叉搜索树的insert,search,getMin,getMax,delete等操作的时间复杂度都是,但是如果数据量过大,还是会出现瓶颈,而红黑树是平衡搜索树的一种,在上面的这些动态操作的情况下,最坏的时间复杂度能缩短为。本文以HashMap的红黑二叉树为例,看看红黑二叉树的原理。 红黑树的定义: 红黑树有以下5...

程序袁小黑 435

红黑二叉树原理和分析

红黑二叉树:防走丢链接 https://blog.youkuaiyun.com/lsr40/article/details/85230703

qq_19729259的博客 460

深入Java集合学习系列:TreeMap实现

http://blog.youkuaiyun.com/tobeandnottobe/article/details/7232664 TreeMap使用红黑二叉树实现。 红黑二叉树: a.根节点是黑色的; b.红色节点的儿子节点是黑色的; c. 任何一个节点到空节点的所有路径上必包含相同数据的黑色节点; d. 叶子节点的子节点...

weixin_30276935的博客 62

[Java]-平衡二叉树,红黑二叉树,2-3二叉树

为了保证查找树的平衡性我们需要一些灵活性,这里我们运行一棵树的一个结点中可以保存多对键值,所以这里利用2-3查找树实现平衡查找 2-3平衡查找树 定义:一棵2-3查找树或为一棵空树,或由以下结点组成: 2-结点,含有一个键及其对应值,和两个链接,与一般二叉树中结点一致 3-结点,含有两个键(a,b)及其对应值,和三个链接,左链接指向小于a的所有键,中链接指向a到b之间的所有键,右链接指向大于b...

renboyu010214的博客 228

红黑二叉树

前两种场景,导致的结果都是左子树比右子树层级高超过1,产生不平衡,为解决不平衡问题,需要将当前节点的左子树上浮一个层级,当前节点下沉一个层,使得二叉树变平衡。这种操作称为左旋,把左子树旋转上来,当前节点下沉为左子树的右子树,并左子树的右子树挂载到当前节点的左子树。3- 节点:节点有2个值,3个子树。2- 节点:节点只有1个值,2个子树。左子树所有节点都小于当前节点;右子树所有节点都大于当前节点。特点:左子树节点比父节点小,右子树节点比父节点大。2-3树的特点是:树的节点可能有2到3个子树。

一亩田 161

悟空学Linux专栏----第7篇

有了队列的简单是最大的奥秘之后,悟空感觉自己找到了研究Linux内核代码的感觉了,每次悟空研究一段代码的时候,悟空都会拿这段代码设计的够不够简单来衡量代码的质量。而且悟空发现Linux内核中很多概念都遵循了这个原则,比如Linux中一切皆是文件的概念,也就是Linux中所有的东西都是文件,就连硬件设备也被称为设备文件。所有的操作都遵循文件的操作,大大简化了操作接口。   但是最近悟空碰到了一个令

悟空学Linux专栏博客 665

红黑二叉树(附写的源码)

如果我们希望它能够在数据量多的时候,层数少,那么就是每一层能够保存更多的数据,这样子虽然查找快了一些,但每一层又臃肿了一些。而为了性能的增强,从二叉树开始一步步进化,有了有序二叉树,然后到平衡二叉树,然后到了23树。3.1被插入节点父节点颜色为红色,并且叔叔节点颜色为黑色,并且插入节点是其父节点的左孩子。3.2被插入节点父节点颜色为红色,并且叔叔节点颜色为黑色,并且插入节点是其父节点的右孩子。从一个节点到这个节点的任意一个子孙节点,路径上包含相同个数的黑色节点。情况二:新节点的父节点颜色为黑,啥都不干。

多方通行8的博客 243

Java/二叉树,红黑二叉树

二叉树的定义 二叉树是树形结构的一个重要类型。 许多实际问题抽象出来的数据结构往往是二叉树的形式,即使是一般的树也能简单地转换为二叉树,而且二叉树的存储结构及其算法都较为简单,因此二叉树显得特别重要。 二叉树(BinaryTree)由一个节点及两棵互不相交的、分别称作这个根的左子树和右子树的二叉树组成。下图中展现了五种不同基本形态的二叉树。 (a) 为空树。 (b) 为仅有一个结点的二叉树。 © 是仅有左子树而右子树为空的二叉树。 (d) 是仅有右子树而左子树为空的二叉树。 (e) 是左、右子树均非空的二

WANGJIABING_的博客 396

红黑二叉树详解及理论分析

发表于我的博客网站(prajna.top): http://prajna.top/doc/2/175 什么是红-黑二叉树? 红-黑二叉树首先是一颗二叉树,它具有二叉树的所有性质,是一种平衡二叉树。普通二叉树在生成过程中,容易出现不平衡的现象,即使是使用随机算法生成二叉树,也是有一定概率生成不平衡的二叉树. 如下图所示 : ...

般若程序蝉(prajna.top)的专栏 3万+

关于红黑二叉树的理解

最近看了些关于红黑二叉树的博客,有一些自己的见解。 红黑二叉树是一种特殊的平衡二叉树,拥有平衡二叉树的所有特征,这里就不再重复。 红黑二叉树的规则: 1、每个节点都必须有叶子节点(叶子节点没有任何数据); 2、根节点和叶子节点必须是黑色; 3,红节点的父节点必须是黑色; 4、从根节点到任何叶子节点,他们的黑色节点的数目必须相同; 规则解释: 每个节点,不管有没有子节点,都必

hahahaha233333的博客 764
上一篇: AVL树节点的插入
下一篇: 四种智能指针的用法以及实现原理
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值