【数据结构】15.红黑树

已于 2024-08-12 09:21:48 修改
阅读量751 收藏 25
点赞数 21
分类专栏： 数据结构 文章标签： c++ 开发语言 算法 笔记 数据结构
于 2024-07-23 22:08:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80258336/article/details/140634426
版权

一、红黑树的概念

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

二、红黑树的性质

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

三、红黑树的分析与实现

3.1 红黑树的整体框架

//节点颜色
enum Colour 
{
	RED,
	BLACK 
};
//红黑树的节点
template<class K, class V>
struct RBTreeNode
{
	pair<K, V> _kv;//data
	RBTreeNode* _left;
	RBTreeNode* _right;
	RBTreeNode* _parent;
	Colour _col;
	RBTreeNode(const pair<K, V>& kv = pair<K, V>())
		:_kv(kv),
		_left(nullptr),
		_right(nullptr),
		_parent(nullptr),
		_col(RED)//破坏规则三的成本比破坏规则四要低
	{}
};
//红黑树
template<class K, class V>
class RBTree
{
	typedef RBTreeNode<K, V> Node;
public:

private:
	Node* _root=nullptr;
};

3.2 红黑树的查找

bool find(const K& key) const
{
	Node* cur = _root;
	while (cur)
	{
		if (key < cur->_kv.first)
		{
			cur = cur->_left;
		}
		else if (key > cur->_kv.first)
		{
			cur = cur->_right;
		}
		else
		{
			return true;
		}
	}
	return false;
}

3.3 红黑树的插入逻辑

在正式讲解插入之前，想先来讨论一下究竟是插入红色节点好，还是黑色节点好呢？
答案当然是插入红色节点更简洁一些，不难理解，当插入黑色节点时，我们需要保证规则四成立，也就是确定每一条路径上的黑色节点个数相同，这就意味着每次插入一个黑色节点就要检查一遍每条路径的黑色节点个数；而插入红色节点我们只需要考虑规则三即可，这样我们只需要判断插入节点的父节点是否为红节点，这样就方便了我们的实现。

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

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

插入的框架：

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 (kv.first < cur->_kv.first)
		{
			parent = cur;
			cur = cur->_left;
		}
		else if (kv.first > cur->_kv.first)
		{
			parent = cur;
			cur = cur->_right;
		}
		else
		{
			return false;
		}
	}
	//插入节点
	cur = new Node(kv);
	cur->_parent = parent;
	if (kv.first < parent->_kv.first)
		parent->_left = cur;
	else
		parent->_right = cur;
	//调整红黑树
	
	_root->_col = BLACK;//根节点一定是黑色的
	return true;
}

3.4 红黑树的调整

下面这张图片是分析插入后的情况：
在这里插入图片描述
对上述分析的过程我们需要将其转化为代码：

//调整颜色
//情况一：parent存在且为黑，不需要调整
//情况二：parent存在且为红，需要调整
while (parent && parent->_col == RED)
{
	//确定 g 和 u 节点
	Node* grandfather = parent->_parent;
	Node* uncle = nullptr;
	if (parent == grandfather->_left)
		uncle = grandfather->_right;
	else
		uncle = grandfather->_left;
	//在情况二下又有如下情况：
	//情况1：unclude存在且为红
	if (uncle && uncle->_col == RED)
	{
		parent->_col = uncle->_col = BLACK;
		grandfather->_col = RED;
		//继续向上调整
		cur = grandfather;
		parent = cur->_parent;
	}
	//情况2：uncle不存在或uncle为黑
	else if (!uncle || uncle->_col == BLACK)
	{
		//parent 是 grandfather 的左孩子
		if (parent == grandfather->_left)
		{
			//cur 是 parent 的左孩子
			if (cur == parent->_left)
			{
				//旋转加变色
				RotateRight(grandfather);
				parent->_col = BLACK;
				grandfather->_col = RED;
			}
			//cur 是 parent 的右孩子
			else
			{
				//旋转加变色
				RotateLeftThenRight(grandfather);
				cur->_col = BLACK;
				grandfather->_col = RED;
			}
		}
		//parent 是 grandfather 的右孩子
		else 
		{
			//cur 是 parent 的左孩子
			if (cur == parent->_left)
			{
				//旋转加变色
				RotateRightThenLeft(grandfather);
				cur->_col = BLACK;
				grandfather->_col = RED;
			}
			//cur 是 parent 的右孩子
			else
			{
				//旋转加变色
				RotateLeft(grandfather);
				parent->_col = BLACK;
				grandfather->_col = RED;
			}
		}
		break;//调整好能退出了
	}
	else
	{
		assert(false);//逻辑错误，理论上不可能走到
	}			
}
_root->_col = BLACK;

3.5 红黑树的插入

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 (kv.first < cur->_kv.first)
		{
			parent = cur;
			cur = cur->_left;
		}
		else if (kv.first > cur->_kv.first)
		{
			parent = cur;
			cur = cur->_right;
		}
		else
		{
			return false;
		}
	}
	//插入节点
	cur = new Node(kv);
	cur->_parent = parent;
	if (kv.first < parent->_kv.first)
		parent->_left = cur;
	else
		parent->_right = cur;

	//调整颜色
	//情况一：parent存在且为黑，不需要调整
	//情况二：parent存在且为红，需要调整
	while (parent && parent->_col == RED)
	{
		//确定 g 和 u 节点
		Node* grandfather = parent->_parent;
		Node* uncle = nullptr;
		if (parent == grandfather->_left)
			uncle = grandfather->_right;
		else
			uncle = grandfather->_left;
		//在情况二下又有如下情况：
		//情况1：unclude存在且为红
		if (uncle && uncle->_col == RED)
		{
			parent->_col = uncle->_col = BLACK;
			grandfather->_col = RED;
			//继续向上调整
			cur = grandfather;
			parent = cur->_parent;
		}
		//情况2：uncle不存在或uncle为黑
		else if (!uncle || uncle->_col == BLACK)
		{
			//parent 是 grandfather 的左孩子
			if (parent == grandfather->_left)
			{
				//cur 是 parent 的左孩子
				if (cur == parent->_left)
				{
					//旋转加变色
					RotateRight(grandfather);
					parent->_col = BLACK;
					grandfather->_col = RED;
				}
				//cur 是 parent 的右孩子
				else
				{
					//旋转加变色
					RotateLeftThenRight(grandfather);
					cur->_col = BLACK;
					grandfather->_col = RED;
				}
			}
			//parent 是 grandfather 的右孩子
			else 
			{
				//cur 是 parent 的左孩子
				if (cur == parent->_left)
				{
					//旋转加变色
					RotateRightThenLeft(grandfather);
					cur->_col = BLACK;
					grandfather->_col = RED;
				}
				//cur 是 parent 的右孩子
				else
				{
					//旋转加变色
					RotateLeft(grandfather);
					parent->_col = BLACK;
					grandfather->_col = RED;
				}
			}
			break;//调整好能退出了
		}
		else
		{
			assert(false);//逻辑错误，理论上不可能走到
		}			
	}
	_root->_col = BLACK;
	return true;
}

3.6 红黑树的验证

红黑树的检测分为两步：

  1. 检测其是否满足二叉搜索树(中序遍历是否为有序序列)
  2. 检测其是否满足红黑树的性质
bool IsBlance()
{
	if (_root == nullptr)
		return true;

	//根节点必须是黑色
	if (_root->_col != BLACK)
	{
		cout << "违反规则二" << endl;
		return false;
	}

	//每一个节点都存储一个值表示从根节点到该节点黑色节点的个数
	int BlackCount = 0;
	//找到一条路径上的所有黑色节点作为参照
	Node* cur = _root;
	while (cur)
	{
		if (cur->_col == BLACK)
			BlackCount++;
		cur = cur->_left;
	}
	//进行比对每一条路径黑色节点个数是否相等
	return JudgeNumsOfBlack(_root, 0, BlackCount);
}

bool JudgeNumsOfBlack(Node* root, int CurNum, int BlackNums)
{
	if (root == nullptr)
	{
		//为空时，只有到此节点路径和与比对路径黑色节点个数相等才满足规则四
		if (CurNum != BlackNums)
		{
			cout << "违反规则四" << endl;
			return false;
		}
		return true;
	}

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

	//判断是否满足规则三：没有连续的红色节点
	Node* parent = root->_parent;
	if (parent && parent->_col == RED && root->_col == RED)
	{
		cout << "违反规则三" << endl;
		return false;
	}

	return JudgeNumsOfBlack(root->_left, CurNum, BlackNums) &&
		JudgeNumsOfBlack(root->_right, CurNum, BlackNums);
}

3.7 红黑树的源码

#pragma once

#include<iostream>
#include<assert.h>
using namespace std;
//节点颜色
enum Colour 
{
	RED,
	BLACK 
};
//红黑树的节点
template<class K, class V>
struct RBTreeNode
{
	pair<K, V> _kv;//data
	RBTreeNode* _left;
	RBTreeNode* _right;
	RBTreeNode* _parent;
	Colour _col;
	RBTreeNode(const pair<K, V>& kv = pair<K, V>())
		:_kv(kv),
		_left(nullptr),
		_right(nullptr),
		_parent(nullptr),
		_col(RED)
	{}
};
//红黑树
template<class K, class V>
class RBTree
{
	typedef RBTreeNode<K, V> Node;
	Node* copy(Node* root)
	{
		if (root == nullptr)
			return nullptr;

		Node* newnode = new Node(root->_kv);
		newnode->_left = copy(root->_left);
		newnode->_right = copy(root->_right);
		return newnode;
	}
	void destory(Node* root)
	{
		if (root == nullptr)
			return;
		//必须后续销毁节点
		destory(root->_left);
		destory(root->_right);
		delete root;
		root = nullptr;
	}
public:
	//构造
	RBTree() = default;
	//拷贝构造
	RBTree(const RBTree& avl)
	{
		_root = copy(avl._root);
	}
	RBTree(initializer_list<pair<K, V>> il)
	{
		for (const auto& e : il)
			insert(e);
	}
	//赋值重载
	RBTree& operator=(const RBTree& bst)
	{
		//现代写法
		RBTree temp(bst);
		std::swap(_root, temp._root);
		return *this;
	}
	// 析构
	~RBTree()
	{
		destory(_root);
		_root = nullptr;
	}
	bool find(const K& key) const
	{
		Node* cur = _root;
		while (cur)
		{
			if (key < cur->_kv.first)
			{
				cur = cur->_left;
			}
			else if (key > cur->_kv.first)
			{
				cur = cur->_right;
			}
			else
			{
				return true;
			}
		}
		return false;
	}
	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 (kv.first < cur->_kv.first)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (kv.first > cur->_kv.first)
			{
				parent = cur;
				cur = cur->_right;
			}
			else
			{
				return false;
			}
		}
		//插入节点
		cur = new Node(kv);
		cur->_parent = parent;
		if (kv.first < parent->_kv.first)
			parent->_left = cur;
		else
			parent->_right = cur;

		//调整颜色
		//情况一：parent存在且为黑，不需要调整
		//情况二：parent存在且为红，需要调整
		while (parent && parent->_col == RED)
		{
			//确定 g 和 u 节点
			Node* grandfather = parent->_parent;
			Node* uncle = nullptr;
			if (parent == grandfather->_left)
				uncle = grandfather->_right;
			else
				uncle = grandfather->_left;
			//在情况二下又有如下情况：
			//情况1：unclude存在且为红
			if (uncle && uncle->_col == RED)
			{
				parent->_col = uncle->_col = BLACK;
				grandfather->_col = RED;
				//继续向上调整
				cur = grandfather;
				parent = cur->_parent;
			}
			//情况2：uncle不存在或uncle为黑
			else if (!uncle || uncle->_col == BLACK)
			{
				//parent 是 grandfather 的左孩子
				if (parent == grandfather->_left)
				{
					//cur 是 parent 的左孩子
					if (cur == parent->_left)
					{
						//旋转加变色
						RotateRight(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					//cur 是 parent 的右孩子
					else
					{
						//旋转加变色
						RotateLeftThenRight(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}
				}
				//parent 是 grandfather 的右孩子
				else 
				{
					//cur 是 parent 的左孩子
					if (cur == parent->_left)
					{
						//旋转加变色
						RotateRightThenLeft(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}
					//cur 是 parent 的右孩子
					else
					{
						//旋转加变色
						RotateLeft(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
				}
				break;//调整好能退出了
			}
			else
			{
				assert(false);//逻辑错误，理论上不可能走到
			}			
		}
		_root->_col = BLACK;
		return true;
	}
	//中序查找
	void inorder()
	{
		_inorder(_root);
	}
	bool IsBlance()
	{
		if (_root == nullptr)
			return true;

		//根节点必须是黑色
		if (_root->_col != BLACK)
		{
			cout << "违反规则二" << endl;
			return false;
		}

		//每一个节点都存储一个值表示从根节点到该节点黑色节点的个数
		int BlackCount = 0;
		//找到一条路径上的所有黑色节点作为参照
		Node* cur = _root;
		while (cur)
		{
			if (cur->_col == BLACK)
				BlackCount++;
			cur = cur->_left;
		}
		//进行比对每一条路径黑色节点个数是否相等
		return JudgeNumsOfBlack(_root, 0, BlackCount);
	}
private:
	bool JudgeNumsOfBlack(Node* root, int CurNum, int BlackNums)
	{
		if (root == nullptr)
		{
			//为空时，只有到此节点路径和与比对路径黑色节点个数相等才满足规则四
			if (CurNum != BlackNums)
			{
				cout << "违反规则四" << endl;
				return false;
			}
			return true;
		}

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

		//判断是否满足规则三：没有连续的红色节点
		Node* parent = root->_parent;
		if (parent && parent->_col == RED && root->_col == RED)
		{
			cout << "违反规则三" << endl;
			return false;
		}

		return JudgeNumsOfBlack(root->_left, CurNum, BlackNums) &&
			JudgeNumsOfBlack(root->_right, CurNum, BlackNums);
	}
	void _inorder(Node* root)
	{
		if (root == nullptr)
			return;

		_inorder(root->_left);
		cout << root->_kv.first << " ";
		_inorder(root->_right);
	}
	void RotateLeft(Node* parent)
	{
		//保存节点，后面链接
		Node* parentparent = parent->_parent;
		Node* sub = parent->_right;
		Node* subleft = sub->_left;

		//重新链接
		parent->_right = subleft;
		if (subleft)
			subleft->_parent = parent;
		sub->_left = parent;
		parent->_parent = sub;

		//和上面的节点链接
		if (parentparent == nullptr)
		{
			//说明parent原来是根节点
			_root = sub;
			sub->_parent = nullptr;
		}
		else
		{
			if (parentparent->_left == parent)
			{
				//原来是上面节点的左子树
				parentparent->_left = sub;
			}
			else
			{
				parentparent->_right = sub;
			}
			sub->_parent = parentparent;
		}
	}
	void RotateRight(Node* parent)
	{
		//保存节点，后面链接
		Node* parentparent = parent->_parent;
		Node* sub = parent->_left;
		Node* subright = sub->_right;

		//重新链接
		parent->_left = subright;
		if (subright)
			subright->_parent = parent;
		sub->_right = parent;
		parent->_parent = sub;

		//和上面的节点链接
		if (parentparent == nullptr)
		{
			//说明parent原来是根节点
			_root = sub;
			sub->_parent = nullptr;
		}
		else
		{
			if (parentparent->_left == parent)
			{
				//原来是上面节点的左子树
				parentparent->_left = sub;
			}
			else
			{
				parentparent->_right = sub;
			}
			sub->_parent = parentparent;
		}
	}
	void RotateLeftThenRight(Node* parent)
	{
		RotateLeft(parent->_left);
		RotateRight(parent);
	}
	void RotateRightThenLeft(Node* parent)
	{
		RotateRight(parent->_right);
		RotateLeft(parent);
	}
	
	Node* _root=nullptr;
};

四、红黑树与AVL树对比

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

五、红黑树的现实应用

  1. C++ STL库
  2. Java 库
  3. linux内核
  4. 其他一些库
卡戎-caryon
关注
  • 21
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
红黑树实现
li1829146612的博客
08-13 295
# 2.红黑树的特性 1. 每个结点不是红色就是黑色 2. 根节点是黑色的 3. 如果一个节点是红色的，则它的两个孩子结点是黑色的 4. 对于每个结点，从该结点到其所有后代叶结点的简单路径上，均包含相同数目的黑色结点 5. 每个叶子结点都是黑色的(此处的叶子结点指的是空结点）......
数据结构-红黑树.zip
03-21
红黑树（Red Black Tree）是一种自平衡二叉查找树，是在计算机科学中用到的一种数据结构，典型的用途是实现关联数组。这种数据结构由Rudolf Bayer在1972年首次提出，当时被称为平衡二叉B树（Symmetric Binary B-...
红黑树
wangdass
04-23 139
介绍    红黑树是一种自平衡二叉查找树，是一种扩充的BST，它可以在O(log⁡2n\log_2{n}log2​n)时间进行查找，插入，和删除等操作。主要是对内存中，比较小规模的数据进行索引。 性质 颜色特征: 结点是红色或者黑色的; 根特征: 根结点永远是黑色的; 外部特征: 扩充外部的叶子结点是空的,颜色为黑; 内部特征: 红色结点的两个子结点都是黑色的,不允许两个连续的红色结点; 深...
二叉搜索树BST&红黑树
@龙猫的博客
10-29 242
private void fixAfterInsertion(Entry<K,V> x) { // 新添加的节点是红色 x.color = RED; // 添加的节点 while (x != null && x != root && x.parent.color == RED) { // 当前节点非空且不是根节点且当前节点的父节点是红色 if (parentOf(x) == leftOf(parentOf(parentOf(x)))) { // 当前
【数据结构】红黑树
holle_world_ldx的博客
10-03 303
【数据结构】红黑树
红黑树算法原理（从二叉搜索树讲起）
login_sonata的博客
08-05 4588
原文：红黑树深入剖析及Java实现，本文修改了原文的一些小错误，如果想看红黑树的Java实现可以到原文去看。 红黑树是平衡二叉查找树的一种。为了深入理解红黑树，我们需要从二叉查找树开始讲起。BST二叉查找树（Binary Search Tree，简称BST）是一棵二叉树，它的左子节点的值比父节点的值要小，右节点的值要比父节点的值大。它的高度决定了它的查找效率。在理想的情况下，二叉查找树增删查改的时
红黑树-基于Java实现的红黑树数据结构.zip
03-21
红黑树是一种自平衡二叉查找树，由计算机科学家...总的来说，红黑树是数据结构中的重要组成部分，尤其在需要高效存储和检索大量有序数据的场合。通过理解和掌握红黑树的原理和实现，能提升编程能力，优化程序性能。
红黑树-基于C语言实现的红黑树数据结构.zip
03-21
- 转换操作：在插入和删除过程中，可能需要将红黑树转换成其他数据结构，如AVL树，以满足特定需求。 在实际应用中，红黑树广泛用于各种场景，如C++标准库中的STL map和set，它们底层就是基于红黑树实现的。红黑树的...
红黑树-基于C++实现的红黑树数据结构.zip
03-21
红黑树是一种自平衡二叉查找树，由Rudolf Bayer在1972年提出。它的设计目标是在保持二叉查找树基本性质的同时，...熟练掌握红黑树的原理和C++实现，对于提升数据结构和算法能力以及解决实际编程问题都具有重要意义。
数据结构之红黑树详解
12-31
在C++ STL中，很多部分(目前包括set, multiset, map, multimap)应用了红黑树的变体(SGI STL中的红黑树有一些变化，这些修改提供了更好的性能，以及对set操作的支持)。它是复杂的，但它的操作有着良好的最坏情况运行...
红黑树与二叉查找树(BST)与AVL树
刘看山是山的博客
07-02 302
1.二叉查找树（BST）Binary Search Tree 特点： 1.左子树上所有结点的值均小于或等于它的根结点的值。 2.右子树上所有结点的值均大于或等于它的根结点的值。 3.左、右子树也分别为二叉排序树。 下图中这棵树，就是一颗典型的二叉查找树： 但是BST的弊端： ​ 假设初始的二叉查找树只有三个结点，根结点值为9，左孩子值为8，右孩子值为12： 接下来我们依次插入如下五个结点：7,6,5,4,3。依照二叉查找树的特性，结果会变成什么样呢？ 好端端的二叉树变成了“瘸
C++之红黑树
cls的博客
05-23 1918
红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的。 4.2.2 红黑树的性质 1. 每个结点不是红色就是黑色 2. 根节点是黑色的 3. 如果一个节点是红色的，则它的两个孩子结点是黑色的，但是没有连续的红节点 4. 对于每个结点，从该结点到其所有后代叶结点的简单路径...
【C++篇】红黑树
wzd547191555的博客
07-02 797
博主:大大怪先森(记得关注哦!） 编程环境：vs2013 所示代码：码源代码如下（示例）： 四、红黑树的插入 五、红黑树和AVL的比较 总结 各位大大记得点赞，关注，一键三连哦!!!
C++精通之路：红黑树
yin_ming_hui的博客
08-01 1016
文章目录红黑树一：红黑树的概念二：红黑树的性质三：红黑树节点的定义四：红黑树结构五：红黑树的插入操作情况一（只需要变色）：情况二（单旋加变色）：情况三（双旋加变色）：插入的实现旋转实现六:红黑树的验证实现代码：七、红黑树的删除八：红黑树与AVL树的比较九：红黑树的应用总结 很多小伙伴为了刷题发愁 今天为大家推荐一款刷题神奇哦：刷题面试神器牛客 各大互联网大厂面试真题。从基础到入阶乃至原理刨析类面试题 应有尽有，赶快来装备自己吧！助你面试稳操胜券，solo全场面试官 红黑树 一：红黑树的概念 红黑树，是一
STL关联式容器之红黑树
handsomeKyne
07-12 1420
这一节我们来学习红黑树，如果你能够自己实现一个红黑树，那么对它的理解将会更加深刻。 1、树的总览 根节点到任何节点之间有一条唯一路径。 路径长度：指路径所经过的边数。 节点的深度：根节点至该节点的路径长度。根节点的深度为0。 节点的高度：该节点到其最深叶节点的高度。根节点的高度最大。 注意高度和深度的区别。可以这么理解，高度是向上变大的，而深度是向下变大的。 节点大小：该节点所有子代
总结：《list和vector》《AVL与红黑树》《set与map》《链表与顺序表》《算法排序》
dpfxaca6的博客
12-11 243
一，list和vector的区别 区别：vector为存储的对象分配一块连续的地址空间，因此对vector中的元素随机访问效率很高。在vecotor中插入或者删除某个元素，需要将现有元素进行复制，移动。如果vector中存储的对象很大，或者构造函数复杂，则在对现有元素进行拷贝时开销较大，因为拷贝对象要调用拷贝构造函数。对于简单的小对象，vector的效率优于list。vector在每次扩张容量的时...
数据结构——红黑树详解
最新发布
rab1211764820的博客
04-02 1225
红黑树的模拟实现 红黑树的验证 红黑树与AVL树的比较
腾讯面试题02.vector怎么实现动态空间分布；map用什么实现的；红黑树是什么，有什么特点；hashtable怎么实现的
sensenxiangshang
04-19 2833
1、vector怎么实现动态空间分布； vector容器基于数组实现，其元素在内存中连续存放，vector容器除了容器尾部之外，在其他任意位置插入或删除元素时，都需要移动该元素后面的所有元素。 2、map用什么实现的； map容器指的是关联数组，所谓“关联”指的是元素的值与键之间的关联，通过键来访问值。用红黑树实现的。 3、红黑树是什么，有什么特点； 红黑树是一种自平衡二
stl
huazifly的专栏
01-18 355
map 使用的是红黑树vector 已经排好序了
深入解析红黑树数据结构
总结来说，红黑树是数据结构中的重要组成部分，广泛应用于各种系统和库，如C++ STL中的map和set，因为它们提供了高效的插入、删除和查找操作。理解和掌握红黑树的原理和操作对于提升编程技能和优化算法性能至关重要...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值