_cpp 红黑树快速了解底层结构

最新推荐文章于 2024-06-22 22:24:55 发布
最新推荐文章于 2024-06-22 22:24:55 发布
阅读量659 收藏 2
点赞数 4
分类专栏： c++ 文章标签： 数据结构 算法 排序算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Dingyuan0/article/details/127700500
版权

文章目录

0. 前言

  • 友友们上一章节我们了解了AVL树的底层结构，此章我们来了解红黑树。
  • AVL树是一棵绝对平衡的二叉搜索树，其要求每个节点的左右子树高度差的绝对值都不超过1，这样可以保证查询时高效的时间复杂度，即 l o g 2 ( N ) log_2 (N) log2​(N)。
  • AVL树的性能方面：对AVL树做一些结构修的操作，性能非常低下，比如：插入时要维护其绝对平衡，旋转的次数比较多，更差的是在删除时，有可能一直要让旋转持续到根的位置。因此：如果需要一种查询高效且有序的数据结构，而且数据的个数为静态的(即不会改变)，可以考虑AVL树，但一个结构经常修改，就不太适合。

下面开始本章红黑树的内容~

1. 红黑树的概念

  • 红黑树，当然也是一种二叉搜索树，我们可以通过中序遍历可以得到一个有序序列；

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

  • 这个时候友友们就很疑惑，下面说红黑树的性质：

2. 红黑树的性质

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

通过上面规则，红黑树就能保证：其最长路径中节点个数不会超过最短路径节点个数的两倍。(最坏情况最短路径全黑，最长一半黑一半红)

3. 红黑树节点的定义

// 节点的颜色
enum Colour
{
	RED,
	BLACK
};
// 红黑树节点的定义
template<class K, class V>
struct RBTreeNode
{
	RBTreeNode<K, V>* _left;	// 节点的左孩子
	RBTreeNode<K, V>* _right;	// 节点的右孩子
	RBTreeNode<K, V>* _parent;	// 节点的双亲(红黑树需要旋转，为了实现简单给出该字段)

	pair<K, V> _kv;	// 节点的值域
	Colour _col;	// 节点的颜色

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

为了方便了解红黑树，我把它写死了；就是pair类型。

4. 红黑树的插入操作

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

1. 按照二叉搜索的树规则插入新节点

		if (_root == nullptr)
		{
			_root = new Node(kv);
			_root->_col = BLACK;
			return true;
		}

		//找find
		Node* parent = nullptr;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_kv.first < kv.first)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_kv.first > kv.first)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				//重复的
				return false;
			}
		}


		//插入
		cur = new Node(kv);
		cur->_col = RED;

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

2. 检测新节点插入后，红黑树的性质是否造到破坏

注意：我们插入节点为红色便于调整。
因为新节点的默认颜色是红色，因此：如果其双亲节点的颜色是黑色，没有违反红黑树任何
性质，则不需要调整；但当新插入节点的双亲节点颜色为红色时，就违反了性质三不能有连在一起的红色节点；
此时需要对红黑树分情况来讨论：约定:cur为当前节点，p为父节点，g为祖父节点，u为叔叔节点。

注意：旋转上一篇AVL树旋转已经详细说明了，此章不做补充了。

  • 情况一: cur为红，p为红，g为黑，u存在且为红
    在这里插入图片描述

    • 将p,u改为黑，g改为红，然后把g当成cur，继续向上调整。

  • 情况二: cur为红，p为红，g为黑，u不存在/u存在且为黑
    在这里插入图片描述

    • p为g的左孩子，cur为p的左孩子，则进行右单旋转；
    • p为g的右孩子，cur为p的右孩子，则进行左单旋转p、g变色–p变黑，g变红。

  • 情况三: cur为红，p为红，g为黑，u不存在/u存在且为黑
    *

    • p为g的左孩子，cur为p的右孩子，则针对p做左单旋转；
    • p为g的右孩子，cur为p的左孩子，则针对p做右单旋转
      则转换成了情况2。

3. 下面整体插入代码实现

代码里面也有详细注释供uu们分析~

	bool Insert(const pair<K, V>& kv)
	{
		if (_root == nullptr)
		{
			_root = new Node(kv);
			_root->_col = BLACK;
			return true;
		}

		//找find
		Node* parent = nullptr;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_kv.first < kv.first)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_kv.first > kv.first)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				//重复的
				return false;
			}
		}


		//插入
		cur = new Node(kv);
		cur->_col = RED;

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

		//调整颜色
		while (parent && parent->_col == RED)	//父母为红，违法规则；才调整
		{
			Node* grandfather = parent->_parent;
			assert(grandfather);
			assert(grandfather->_col == BLACK);
			//关键看叔叔
			//     g
			//   p or p
			// 
			if (parent == grandfather->_left)
			{
				Node* uncle = grandfather->_right;
				//情况一: uncle存在且为红，变色＋继续往上调整
				//     g
				//   p   u
				//   c
				if (uncle && uncle->_col==RED)
				{
					parent->_col = BLACK;
					uncle->_col = BLACK;
					grandfather->_col = RED;

					cur = grandfather;
					parent = cur->_parent;
				}
				else  //uncle || uncle->_col == BLACK
				{
					//情况二、三: uncle存在且为黑或者不存在，变色＋旋转
					if (cur == parent->_left)
					{
						//     g				p
						//   p   u			  c	  g
						//  c						u
						//(g)右单旋＋变色
						RotateR(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else
					{
						//     g             g				c
						//   p   u		   c   u		  p	   g
						//		c		 p	                     u
						//(p)左单旋＋(g)右单旋+ 变色
						RotateL(parent);
						RotateR(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}

					break;
				}
			}
			else    //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  //uncle || uncle->_col == BLACK
				{
					//情况二、三: uncle存在且为黑或者不存在，变色＋旋转
					if (cur == parent->_right)
					{
						//(g)左单旋＋变色
						RotateL(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else
					{
						//(p)右单旋＋(g)左单旋+ 变色
						RotateR(parent);
						RotateL(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}

					break;
				}
			}
		}

		_root->_col = BLACK;
		return true;
	}

5. 红黑树的检测分为两步：

  1. 检测其是否满足二叉搜索树(中序遍历是否为有序序列)；
	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}
  1. 检测其是否满足红黑树的性质。
    思路：我们通过递归来计数每条路径上黑色节点的个数，（注意记录节点个数的变量要利用栈的性质，这样可以保证返回上一个高度的黑色节点数还是原来的）;红色看它自己和它父亲是否都为红色节点。
	bool IsBalance()
	{
		// 空树也是红黑树
		if (_root == nullptr)
		{
			return true;
		}
		// 检测根节点是否满足情况
		if (_root->_col == RED)
		{
			return false;
		}
		
		// 获取任意一条路径中黑色节点的个数
		//黑色节点数量的基准
		int benchmark = 0;

		return PrecCheck(_root, 0, benchmark);
	}


	bool PrecCheck(Node* root, int blackNum, int& benchmark)
	{
		if (root == nullptr)
		{
			if (benchmark == 0)
			{
				benchmark = blackNum;
				return true;
			}

			if (benchmark != blackNum)
			{
				cout << "某条黑色结点数量不对" << endl;
				return false;
			}
			else
			{
				return true;
			}
		}

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

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

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

	void _InOrder(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}

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

6. 本章代码总结：

// .h文件

#pragma once
#include<iostream>
#include<assert.h>

using namespace std;
enum Colour
{
	RED,
	BLACK
};

template<class K, class V>
struct RBTreeNode
{
	RBTreeNode<K, V>* _left;
	RBTreeNode<K, V>* _right;
	RBTreeNode<K, V>* _parent;

	pair<K, V> _kv;
	Colour _col;

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

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

	bool Insert(const pair<K, V>& kv)
	{
		if (_root == nullptr)
		{
			_root = new Node(kv);
			_root->_col = BLACK;
			return true;
		}

		//找find
		Node* parent = nullptr;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_kv.first < kv.first)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_kv.first > kv.first)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				//重复的
				return false;
			}
		}


		//插入
		cur = new Node(kv);
		cur->_col = RED;

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

		//调整颜色
		while (parent && parent->_col == RED)	//父母为红，违法规则；才调整
		{
			Node* grandfather = parent->_parent;
			assert(grandfather);
			assert(grandfather->_col == BLACK);
			//关键看叔叔
			//     g
			//   p or p
			// 
			if (parent == grandfather->_left)
			{
				Node* uncle = grandfather->_right;
				//情况一: uncle存在且为红，变色＋继续往上调整
				//     g
				//   p   u
				//   c
				if (uncle && uncle->_col==RED)
				{
					parent->_col = BLACK;
					uncle->_col = BLACK;
					grandfather->_col = RED;

					cur = grandfather;
					parent = cur->_parent;
				}
				else  //uncle || uncle->_col == BLACK
				{
					//情况二、三: uncle存在且为黑或者不存在，变色＋旋转
					if (cur == parent->_left)
					{
						//     g				p
						//   p   u			  c	  g
						//  c						u
						//(g)右单旋＋变色
						RotateR(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else
					{
						//     g             g				c
						//   p   u		   c   u		  p	   g
						//		c		 p	                     u
						//(p)左单旋＋(g)右单旋+ 变色
						RotateL(parent);
						RotateR(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}

					break;
				}
			}
			else    //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  //uncle || uncle->_col == BLACK
				{
					//情况二、三: uncle存在且为黑或者不存在，变色＋旋转
					if (cur == parent->_right)
					{
						//(g)左单旋＋变色
						RotateL(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else
					{
						//(p)右单旋＋(g)左单旋+ 变色
						RotateR(parent);
						RotateL(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}

					break;
				}
			}
		}

		_root->_col = BLACK;
		return true;
	}

	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}

	bool IsBalance()
	{
		if (_root == nullptr)
		{
			return true;
		}

		if (_root->_col == RED)
		{
			return false;
		}

		//黑色节点数量的基准
		int benchmark = 0;

		return PrecCheck(_root, 0, benchmark);
	}
private:
	bool PrecCheck(Node* root, int blackNum, int& benchmark)
	{
		if (root == nullptr)
		{
			if (benchmark == 0)
			{
				benchmark = blackNum;
				return true;
			}

			if (benchmark != blackNum)
			{
				cout << "某条黑色结点数量不对" << endl;
				return false;
			}
			else
			{
				return true;
			}
		}

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

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

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

	void _InOrder(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}

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

	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 (_root == parent)
		{
			_root = subL;
			_root->_parent = nullptr;
		}
		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;
		}

		Node* ppNode = parent->_parent;
		subR->_left = parent;
		parent->_parent = subR;
		if (parent == _root)
		{
			_root = subR;
			_root->_parent = nullptr;
		}
		else
		{
			if (ppNode->_left == parent)
			{
				ppNode->_left = subR;
			}
			else  //ppNode->_right == parent
			{
				ppNode->_right = subR;
			}
			subR->_parent = ppNode;
		}

	}

	Node* _root = nullptr;
};

void  TestRBTree1()
{
	//int a[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };
	int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };
	//int a[] = { 1,2,3,4,5,6,7,8,9 };
	RBTree<int, int> t;
	for (auto e : a)
	{
		t.Insert(make_pair(e, e));
	}

	t.InOrder();

	if (t.IsBalance())
		cout << "ture" << endl;
	else
		cout << "false" << endl;
}

void TestRBTree()
{
	size_t N = 1000;
	srand(time(0));
	RBTree<int, int> t1;
	for (size_t i = 0; i < N; i++)
	{
		int x = rand();
		t1.Insert(make_pair(x, i));
	}

	cout << "IsBalance:" << t1.IsBalance() << endl;
}

/.cpp文件

#include"BR_TREE.h"

int main()
{
	TestRBTree1();
	TestRBTree();
	return 0;
}

1. 结果–展示：

在这里插入图片描述

昨天；明天。今天。
关注
  • 4
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 8
    评论
专栏目录
底层实现数据结构：红黑树
ChanYipFan的博客
04-18 1110
学习某个知识（比如红黑树），一上来就扔给你5个定义（就算算法导论那样），告诉你这就是红黑树，然后又从这5个定义推出更多定义。其实这会让学习者很难理解到底什么是红黑树的，这样最大的问题就在于没有介绍清楚这个红黑树是从哪来的，我们为什么要把节点定义成红色或黑色。 2-3树插入元素： 一个原则: 添加节点将永远不会添加到一个空的位置(和二叉搜索树不同)、只会和最后找到的叶子节点做融合：...
map、set（底层结构）——C++
Ll_R_lL的博客
11-16 2683
高度平衡二叉搜索树，是以人名命名的一棵AVL树或者是空树，或者是具有以下性质的二叉搜索树：如果一棵二叉搜索树是的，它就是AVL树。如果它有n个结点，其高度可保持在 O(log2n)O(log_2 n)O(log2​n)，搜索时间复杂度O(log2nlog_2 nlog2​n)平衡因子需要三叉链 但是旋转的时候也会变复杂 t AVL树就是在二叉搜索树的基础上引入了平衡因子，因此AVL树也可以看成是二叉搜索树。那么AVL树的插入过程可以分为两步： 原则： 如果在一棵原本是平衡的AVL树中插入一个新节点
红黑树的底层结构实现
JavaBoy_XZL的博客
12-23 528
红黑树的定义 红黑树是含有红黑链接并满足以下条件的二叉查找树 1、红链接均为左连接； 2、没有任何一个结点同时和两条红链接相连； 3、该树是完美黑色平衡的，即任意空链接到根结点的路径上的黑链接数量相同。 红黑树中存储元素的结点 因为每个结点都只会有一条指向自己的链接（即它的父结点指向它），我们可以在之前的Node结点中新增一个布尔类型的变量color来表示此链接的颜色。我们规定：如果指向此结点的链接是红色的，那么该变量的值为true；如果指向此结点的链接时黑色的，那么该变量的值为false.
深入理解C++红黑树
最新发布
gyc2727的博客
06-22 867
红黑树（Red-Black Tree）是一种自平衡的二叉搜索树，它可以在插入、删除和查找操作中保持相对高效的性能。由于其独特的性质，红黑树在计算机科学中得到了广泛的应用，特别是在需要动态维护有序数据集合的场景中。本文将详细介绍红黑树的基本概念、性质、实现以及应用。红黑树的实现涉及到节点定义、插入操作、删除操作以及旋转和颜色调整等辅助操作。红黑树的性质保证了它在插入、删除和查找操作中的高效性。
Cpp || 红黑树
Template Code
04-16 301
红黑树相关知识,快来看看,学习吧.
【cpp---＞红黑树】
kk1125778230的博客
05-20 117
红黑树是二叉搜索树的另一种实现方式，它不同于绝对平衡的AVl树，而是一颗接近平衡的二叉搜索树；红黑树相对AVl树来说更为抽象。
红黑树的底层阐述
lightingsui的博客
11-17 364
欢迎查看本人的私人博客： http://39.106.81.183:8000 红黑树介绍 首先说为什么叫红黑树？有接触过AVL（平衡二叉树）的应该知道，在AVL树中，维持树的平衡是靠平衡因子，说白了就是左右子树的高度相差不能超过1，且左右子树各是AVL树。但是在红黑树中，维持树的平衡靠的可不是平衡因子，而是每个节点的颜色（红黑树的节点只能为红色或者黑色），这是红黑树与AVL树的区别。 红黑树与A...
alogrithm_structure_cpp
02-14
`std::set`和`std::map`是基于红黑树实现的关联容器，提供了键值对的存储和快速查找。 2. **迭代器**：迭代器是访问容器内元素的一种机制，类似于指针，但具有更丰富的操作和安全特性。通过迭代器，可以遍历容器的...
轻松搞定面试中的红黑树问题
11-27
本文将深入探讨红黑树的相关概念及其应用场景，帮助读者更好地理解和掌握这一重要的数据结构。 #### 1. STL中的`set`底层使用的是什么数据结构？ C++标准模板库（STL）中的`set`容器底层使用的是红黑树（Red-Black...
红黑树面试题目---华为C++工程师
WangY.H
05-06 2217
1.stl中的set底层用的什么数据结构？ 红黑树 2.红黑树的数据结构怎么定义？ [cpp] view plain copy 1 enum Color 2. { 3. RED = 0, 4. BLACK = 1 5. }; 6. 7. struct RBTreeNode 8. { 9. stru...
C语言和cpp实现的数据结构
01-02
C语言是一种底层、静态类型的编程语言，它的语法简洁，执行效率高，特别适合实现底层的数据结构。C语言提供的指针操作使得直接操控内存成为可能，这对于创建动态数据结构如链表、树等非常有利。例如，你可以使用...
C++【红黑树】
芊樱烛渊的博客
11-05 1019
AVLTree：要求左右高度差不超过1红黑树：AVLTree过分严格，可能会导致过分的旋转，那能不能不要那么严格呢？需要达到的目的，最长路径不超过最短路径的二倍。也就是说，我们的AVLTree是严格平衡，我们的红黑树是不严格平衡，而是近似平衡结果：相对而言，插入同样的数据，AVL树的旋转更多，红黑树的旋转次数更少假设N是100w，AVL树为logN的高度，也就是大概20左右但是我们的红黑树的话，最短的高度大概是logN也就是20左右，最深的应该为2*logN，为40次左右。
红黑树c++实现
小小程序员
03-06 1267
一、红黑树的基本概念 性质： 1、根结点的颜色是黑色 2、红结点的两个孩子都为黑色 3、根结点的父结点，所有叶子结点都为黑色（在程序中用NIL替换） 4、每个结点到其所有后代叶结点的简单路径上，均包含相同数目的黑色结点   黑高：从某个结点出发（不含该结点）到达一个叶结点的任意一条简单路径上的黑色结点个数称为该结点的黑高   二、c++源代码 #include using
教你透彻了解红黑树
世界是兔子的
03-11 2812
https://github.com/julycoding/The-Art-Of-Programming-By-July/blob/master/ebook/zh/03.01.md 教你透彻了解红黑树 二叉查找树 由于红黑树本质上就是一棵二叉查找树，所以在了解红黑树之前，咱们先来看下二叉查找树。 二叉查找树（Binary Search Tree），也称有序二叉树（ord
深入理解C++红黑树的底层实现及应用
qq_51536567的博客
10-22 168
RBTree
Cpp || 红黑树迭代器
Template Code
04-17 538
红黑树迭代器 迭代器的好处是可以方便遍历,是数据结构的底层实现与用户透明,如果想要给红黑树增加迭代器,需要考虑以前的问题: begin()与end() STL明确规定，begin()与end()代表的是一段前闭后开的区间，而对红黑树进行中序遍历后，可以得到一个有序的序列，因此：begin()可以放在红黑树中最小节点(即最左侧节点)的位置，end()放在最大节点(最右侧节点)的下一个...
深入浅出C++ ——手撕红黑树
weixin_55051736的博客
02-22 780
/节点的值域 Colour _col;//节点的颜色 RBTreeNode < K , V > * _left;//节点的左孩子 RBTreeNode < K , V > * _right;//节点的右孩子 RBTreeNode < K , V > * _parent;//节点的双亲 };
C/C++数据结构（十二）—— 红黑树
热门推荐
Edison's 小宇宙
03-01 10万+
红黑树是每个节点都带有颜色属性的二叉查找树，颜色为红色或黑色。
C++map的数据结构红黑树
07-09
在C++中，std::map 是使用红黑树（RedBlack Tree）作为底层数据结构实现的。红黑树是一种自平衡二叉查找树，它具有以下特点： 1. 每个节点要么红色，要么是黑色。 2. 根节点是黑色的。 3. 所有叶子节点（NIL节点）都是黑色的。 4. 如果一个节点是红色的，则它的两个子节点都是黑色的。 5. 对于每个节点，从该节点到其后代叶子节点的简单路径上，均包含相同数目的黑色节点。 这些特性保证了红黑树的平衡性，使得在最坏情况下，插入、删除和查找操作的时间复杂度都是O(log n)。 std::map 是C++标准库中提供的关联容器之一，它提供了一种键值对的存储方式，并根据键的顺序自动进行排序。通过使用红黑树作为底层数据结构，std::map 可以在插入、删除和查找操作上具有较好的性能表现。 以下是一个使用 std::map 的简单示例： ```cpp #include <iostream> #include <map> int main() { std::map<int, std::string> myMap; // 插入键值对 myMap.insert(std::make_pair(1, "Apple")); myMap.insert(std::make_pair(2, "Banana")); myMap.insert(std::make_pair(3, "Orange")); // 遍历输出 for (const auto& pair : myMap) { std::cout << pair.first << ": " << pair.second << std::endl; } // 查找键对应的值 auto it = myMap.find(2); if (it != myMap.end()) { std::cout << "Value of key 2: " << it->second << std::endl; } return 0; } ``` 上述示例中，我们使用 std::map 存储了一些水果的名称，并按照键的顺序输出。通过调用 find() 函数，我们可以查找指定键对应的值。 希望以上回答能够解决你的问题！如有更多疑问，请继续提问。
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

昨天；明天。今天。

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值