由红黑树到map/set

最新推荐文章于 2024-11-02 14:41:43 发布
最新推荐文章于 2024-11-02 14:41:43 发布
阅读量444 收藏 6
点赞数 6
分类专栏： C++学习 文章标签： 开发语言 c++ 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_67401157/article/details/132042356
版权

文章目录

预备知识：

一.map/set 的封装思路

在实现了红黑树的部分功能后，我们可以便可以将红黑树作为底层结构来封装map 和set，其中map是 K-Value 模型 ，而 set 是 Key 模型。

我们接下来将使用模板、仿函数和一棵红黑树实现 map和set。

1.封装思路

因为 map 存储的是pair ，而 set 存储的是 Key ，所以其解决的根本方向就是：

  • 如果是 map，红黑树中就按照 pair 的 K进行比较，从而插入；

  • 如果是 set，红黑树中就按照 Key 值进行比较，从而插入。

让 map / set 主动传出待比较的数据，红黑树只用根据数据间关系进行插入即可，不用在乎待比较的数据是何种结构。

2.红黑树节点调整

上文我们实现的红黑树是按照键值对的方式进行存储的，而接下来我们要同时封装 map/set，故不能直接定死存储的结构，所以我们在此进行修改。
将原来的kv 模型改为data模型，data 即是比较的数据内容。

在这里插入图片描述

注意，将 Kv模型改为 data后，插入与查找中比较的代码都要进行更新，稍后会讲解。

3.map 和 set 的定义

map 和 set 底层都使用的红黑树，所以我们 map/set 的功能就是调用红黑树的成员函数即可。

template<class K, class V>
class Map
{
private:
	RBTree<K, pair<K, V>> _t;
};
 
template<class K>
class Set
{
private:
	RBTree<K,K> _t;
};

因为Map有两个模板参数，而 Set 只有一个模板参数。所以当我们使用的一个红黑树实现时，要进行匹配处理。即使 Set 是一个模板参数，在调用红黑树时也要传入两个模板参数。因为第一个模板参数是匹配 Map 满足红黑树的两个模板参数，而第二个模板参数是为了让底层红黑树拿到比较的数据。

为什么Map除了传入pair外，第一个参数直接传入 K，为什么不能省略？

因为Find的存在，map中Find函数是直接按pair中的 K 进行查找的，所以要额外设置该参数。

4.仿函数 KeyOfValue

接下来我们就要将数据取出供红黑树比较了，如果是 map，就按pair中的 K去比较，如果是 set，就按Key比较。

为此我们可以在 map 和 set 内部定义一个仿函数将其数据取出。

template<class K, class V>
class Map
{
    //Map-keyofvalue 仿函数
	struct MapKeyOfvalue
	{
		const K& operator()(const std::pair<K, V>& kv)
		{
			return kv.first;
		}
	};
private:
	RBTree<K, pair<K, V>> _t;
};
 
template<class K>
class Set
{
    //Set-keyofvalue 仿函数
    struct SetKeyOfvalue
	{
		const K& operator()(const K& key)
		{
			return key;
		}
	};
private:
	RBTree<K,K> _t;
};

然后我们将其仿函数也作为模板，传入红黑树中，对应的，红黑树要添加一个模板参数来接收该仿函数。

改动代码如下：

在这里插入图片描述
改动这些之后，我们便要将红黑树中比较数据大小的地方进行修改

用仿函数将数据取出，然后进行比较：

//根据模板参数创建仿函数
KeyOfvalue kovalue;
if (!_root)
{
	_root = new Node(data);
	_root->_col = BLACK;
	return true;
}
Node* parent = nullptr;
Node* cur = _root;
while (cur)
{
    //比较处————进行改动
	if (kovalue(cur->_data) > kovalue(data))
	{
		parent = cur;
		cur = cur->_left;
	}
    //比较处————进行改动
	else if (kovalue(cur->_data) < kovalue(data))
	{
		parent = cur;
		cur = cur->_right;
	}
	else
	{
		return false;
	}
}
//创建新节点，使用data进行构造
cur = new Node(data);
//比较处————进行改动
if (kovalue(parent->_data) > kovalue(data))
{
	parent->_left = cur;
}
else
{
	parent->_right = cur;
}
cur->_parent = parent;

这样，红黑树便可以适配 map/set 的插入了。

5.map/set 的插入

接下来map/set 的插入直接套用红黑树的即可。

代码如下：

//map的插入，插入pair
bool insert(const pair<K, V>& kv)
{
	return _t.Insert(kv);
}
 
//set的插入，插入key
bool insert(const K& key)
{
	return _t.Insert(key);
}

二.map/set 迭代器实现

1.迭代器的定义

//		节点数据	引用/const引用  指针/const指针
template <class T,class Ref,class Ptr>
struct __RBTreeIterator
{
	typedef RBTreeNode<T> Node;
	typedef __RBTreeIterator<T, Ref, Ptr> self;
	Node* _node;
public:
	__RBTreeIterator(Node* node)
		:_node(node)
	{}
}

首先，我们要明确，其实 map/set 只是一层套壳，其中的功能都是由红黑树实现后，再封装到map/set中供我们使用，迭代器也不例外。

2.解引用运算符重载

解引用即返回该节点的存储的数据，主要用于 set 中，返回该数据的引用。

Ref operator*()
{
	return _node->_data;
}

3.成员访问运算符重载

成员访问操作符即返回该节点的地址，主要用于 map 中，方便访问 pair 中的first以及second。

Ptr operator->()
{
	return &(_node->_data);
}

4.(不)等于运算符重载

bool operator==(const self& s) 
{
	return _node == s._node;
}
 
 
bool operator!=(const self& s) 
{
	return _node != s._node;
}

5.begin() 与 end()

迭代器常用成员函数begin()与end()，其中begin()对应红黑树的最左节点，end()对应最后一个节点的下一个节点，即nullptr(为了简化，并未设置哨兵节点实现将其完美实现)

iterator begin()
{
	Node* left = _root;
	while (left && left->_left)
	{
		left = left->_left;
	}
	return iterator(left);
}
 
iterator end()
{
	return iterator(nullptr);
}

如果 map/set 中想使用红黑树中的迭代器，我们需要在 map/set 中进行声明。

声明如下：

如果想取一个类模板中的一个类型，要使用 typedname 进行声明。
告诉编译器这是一个类型，并不是一个静态变量

//如果想取一个类模板中的一个类型，要使用 typedname 进行声明。
//告诉编译器这是一个类型，并不是一个静态变量
typedef typename RBTree<K, pair<K, V>, MapKeyOfvalue>::iterator iterator;

6.++ 运算符重载

首先我们需要明确，迭代器++是让当前迭代器指向红黑树中序遍历的下一个节点。

以下图的35节点为例。

  • 当迭代器指向 35 时，进行 ++，指向右子树最左节点，即 40。
  • 当迭代器指向 40 时，进行 ++，右子树为空，指向父节点，即 45。
  • 当迭代器指向 45 时，进行 ++，指向右子树最左节点，即 48。
  • 当迭代器指向 48 时，进行 ++，指向未遍历的父节点，即 50。

在这里插入图片描述
分析上面的情况，发现迭代器 ++ 始终围绕着右子树是否存在进行。

现在我们将其抽象化，分析其规律：

  1. 右子树不为空，进行 ++ 则是指向右子树中序的第一个(最左节点)。
  2. 右子树为空，++ 找孩子不是父亲右节点的祖先。
self& operator++()
{
	//如果右子树存在
	if (_node->_right)
	{
		Node* left = _node->_right;
		//则寻找右子树的最左节点
		while (left->_left)
		{
			left = left->_left;
		}
		_node = left;
	}
	//如果右子树不存在
	else
	{
        //找孩子不是父亲右节点的节点
		Node* parent = _node->_parent;
		Node* cur = _node;=
		while (cur == parent->_right)
		{
			cur = cur->_parent;
			parent = parent->_parent;
			//防止最后一个节点寻找祖先导致程序崩溃
			if (parent == nullptr)
			{
				break;
			}
		}
		_node = parent;
	}
	return *this;
}

需要注意，当 ++ 到最后一个节点的时候。有可能在寻找非父亲右节点的祖先时，父节点一路走到 nullptr 的情况，如图：

在这里插入图片描述
所以在每次 parent 更新时都进行一次判断，即可。

7.-- 运算符重载

有了前面++的模拟实现，实现 --就是反着遍历即可。

  1. 左子树不为空，进行 -- 则是指向左子树中序的最后一个(最右节点)。
  2. 左子树为空，-- 找孩子不是父亲左节点的祖先。
self& operator--()
{
	//如果左子树存在
	if (_node->left)
	{
		//找左子树的最右节点
		Node* right = _node->_left;
		while (right->_right)
		{
			right = right->_right;
		}
		_node = rihgt;
	}
	//如果左子树不存在
	else
	{
		//找孩子不是父亲左节点的节点
		Node* parent = _node->parent;
		Node* cur = _node;
		while (parent->_left == cur)
		{
			cur = cur->_parent;
			parent = parent->_parent;
			if (parent == nullptr)
			{
				break;
			}
		}
		_node = parent;
	}
	return *this;
}

8.[ ]下标访问运算符重载

我们来看 map 的[]下标访问操作符，其中 []返回的是mapped_type(pair) 类型。

在这里插入图片描述

再看 set 中的insert也是返回 pair，虽然很反常，但是官方库中确实是这样书写的。

在这里插入图片描述

因为 set 没有[]运算符重载，所以 set 中不必提供该函数，只用在 map 中提供即可。

首先，我们向 map 中 insert 数据 pair；pair的第一个参数为用户传入的 key 值，第二个参数则是用户声明的第二个模板参数的默认构造函数(如果是 int，则调用 int的构造函数，如果是string，则默认构造 string)。

pair<iterator, bool> result = insert(make_pair(key, V()));

然后我们返回迭代器指向的 pair 数据中的second。

//result.first取出迭代器，使用->运算符重载取出data地址，访问second并返回
return result.first->second;

V& operator[](const K& key)
{
	pair<iterator, bool> result = insert(make_pair(key, V()));
	//如果存在，则插入失败
	//如果不存在，则插入数据
	//无论是否存在,都返回 second;
	return result.first->second;
}

三.源码

1.RBTree

enum Colour
{
	RED,
	BLACK,
};

template<class T>
struct RBTreeNode
{
	RBTreeNode<T>* _left;
	RBTreeNode<T>* _right;
	RBTreeNode<T>* _parent;
	T _data;
	Colour _col;

	RBTreeNode(const T& data)
		:_left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _data(data)
		, _col(RED)
	{}
};

template<class T, class Ref, class Ptr>
struct __RBTreeIterator
{
	typedef RBTreeNode<T> Node;
	typedef __RBTreeIterator<T, Ref, Ptr> Self;
	Node* _node;

	__RBTreeIterator(Node* node)
		:_node(node)
	{}

	// 1、typedef __RBTreeIterator<T, T&, T*> itertaor;  拷贝构造
	// 2、 typedef __RBTreeIterator<T, const T&, const T*> const_itertaor;
	//  支持普通迭代器构造const迭代器的构造函数

	__RBTreeIterator(const __RBTreeIterator<T, T&, T*>& it)
		:_node(it._node)
	{}

	Ref operator*()
	{
		return _node->_data;
	}

	Ptr operator->()
	{
		return &_node->_data;
	}

	bool operator!=(const Self& s)
	{
		return _node != s._node;
	}

	Self& operator++()
	{
		if (_node->_right)
		{
			// 1、右不为空，下一个就是右子树的最左节点
			Node* subLeft = _node->_right;
			while (subLeft->_left)
			{
				subLeft = subLeft->_left;
			}

			_node = subLeft;
		}
		else
		{
			// 2、右为空，沿着到根的路径，找孩子是父亲左的那个祖先
			Node* cur = _node;
			Node* parent = cur->_parent;
			while (parent && cur == parent->_right)
			{
				cur = parent;
				parent = parent->_parent;
			}

			_node = parent;
		}

		return *this;
	}

	Self& operator--()
	{
		if (_node->_left)
		{
			// 1、左不为空，找左子树最右节点
			Node* subRight = _node->_left;
			while (subRight->_right)
			{
				subRight = subRight->_right;
			}

			_node = subRight;
		}
		else
		{
			// 2、左为空，孩子是父亲的右的那个祖先
			Node* cur = _node;
			Node* parent = cur->_parent;
			while (parent && cur == parent->_left)
			{
				cur = parent;
				parent = parent->_parent;
			}

			_node = parent;
		}

		return *this;
	}
};

// 仿函数
template<class K, class T, class KeyOfT>
class RBTree
{
	typedef RBTreeNode<T> Node;
public:
	~RBTree()
	{
		_Destroy(_root);
		_root = nullptr;
	}
public:
	typedef __RBTreeIterator<T, T&, T*> itertaor;
	typedef __RBTreeIterator<T, const T&, const T*> const_itertaor;

	itertaor begin()
	{
		Node* cur = _root;
		while (cur && cur->_left)
		{
			cur = cur->_left;
		}

		return itertaor(cur);
	}

	itertaor end()
	{
		return itertaor(nullptr);
	}

	const_itertaor begin() const
	{
		Node* cur = _root;
		while (cur && cur->_left)
		{
			cur = cur->_left;
		}

		return const_itertaor(cur);
	}

	const_itertaor end() const
	{
		return const_itertaor(nullptr);
	}

	Node* Find(const K& key)
	{
		Node* cur = _root;
		KeyOfT kot;
		while (cur)
		{
			if (kot(cur->_data) < key)
			{
				cur = cur->_right;
			}
			else if (kot(cur->_data) > key)
			{
				cur = cur->_left;
			}
			else
			{
				return cur;
			}
		}

		return nullptr;
	}

	pair<itertaor, bool> Insert(const T& data)
	{
		if (_root == nullptr)
		{
			_root = new Node(data);
			_root->_col = BLACK;

			return make_pair(itertaor(_root), true);
		}

		KeyOfT kot;
		Node* parent = nullptr;
		Node* cur = _root;
		while (cur)
		{
			if (kot(cur->_data) < kot(data))
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (kot(cur->_data) > kot(data))
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return make_pair(itertaor(cur), false);
			}
		}

		cur = new Node(data);
		Node* newnode = cur;
		if (kot(parent->_data) > kot(data))
		{
			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;
				// 情况1：u存在且为红，变色处理，并继续往上处理
				if (uncle && uncle->_col == RED)
				{
					parent->_col = BLACK;
					uncle->_col = BLACK;
					grandfather->_col = RED;

					// 继续往上调整
					cur = grandfather;
					parent = cur->_parent;
				}
				else // 情况2+3：u不存在/u存在且为黑，旋转+变色
				{
					//     g
					//   p   u
					// c 
					if (cur == parent->_left)
					{
						RotateR(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else
					{
						//     g
						//   p   u
						//     c
						RotateL(parent);
						RotateR(grandfather);
						cur->_col = BLACK;
						//parent->_col = RED;
						grandfather->_col = RED;
					}

					break;
				}
			}
			else // (grandfather->_right == parent)
			{
				//    g
				//  u   p
				//        c
				Node* uncle = grandfather->_left;
				// 情况1：u存在且为红，变色处理，并继续往上处理
				if (uncle && uncle->_col == RED)
				{
					parent->_col = BLACK;
					uncle->_col = BLACK;
					grandfather->_col = RED;

					// 继续往上调整
					cur = grandfather;
					parent = cur->_parent;
				}
				else // 情况2+3：u不存在/u存在且为黑，旋转+变色
				{
					//    g
					//  u   p
					//        c
					if (cur == parent->_right)
					{
						RotateL(grandfather);
						grandfather->_col = RED;
						parent->_col = BLACK;
					}
					else
					{
						//    g
						//  u   p
						//    c
						RotateR(parent);
						RotateL(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}

					break;
				}
			}
		}

		_root->_col = BLACK;

		return make_pair(itertaor(newnode), true);;
	}

	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);
	}

private:
	void _Destroy(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}

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

	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;
	}

	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);
	}

	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;
		}
	}

	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;
		}
	}

private:
	Node* _root = nullptr;
};

2.map.h

template<class K, class V>
class map
{
	struct MapKeyOfT
	{
		const K& operator()(const pair<const K, V>& kv)
		{
			return kv.first;
		}
	};
public:
	typedef typename RBTree<K, pair<const K, V>, MapKeyOfT>::itertaor iterator;

	iterator begin()
	{
		return _t.begin();
	}

	iterator end()
	{
		return _t.end();
	}

	V& operator[](const K& key)
	{
		pair<iterator, bool> ret = _t.Insert(make_pair(key, V()));
		return ret.first->second;
	}

	pair<iterator, bool> insert(const pair<const K, V>& kv)
	{
		return _t.Insert(kv);
	}
private:
	RBTree<K, pair<const K, V>, MapKeyOfT> _t;
};

void test_map1()
{
	map<string, string> dict;
	dict.insert(make_pair("sort", ""));
	dict.insert(make_pair("string", "ַ"));
	dict.insert(make_pair("count", ""));
	dict.insert(make_pair("string", "(ַ)")); // ʧ

	map<string, string>::iterator it = dict.begin();
	while (it != dict.end())
	{
		cout << it->first << ":" << it->second << endl;
		/*it->first = "1111";
		it->second = "111";*/

		++it;
	}
	cout << endl;

	for (auto& kv : dict)
	{
		cout << kv.first << ":" << kv.second << endl;
	}
	cout << endl;
};

3.set.h

template<class K>
class set
{
	struct SetKeyOfT
	{
		const K& operator()(const K& key)
		{
			return key;
		}
	};
public:
	typedef typename RBTree<K, K, SetKeyOfT>::const_itertaor iterator;
	typedef typename RBTree<K, K, SetKeyOfT>::const_itertaor const_iterator;


	iterator begin()
	{
		return _t.begin();
	}

	iterator end()
	{
		return _t.end();
	}

	pair<iterator, bool> insert(const K& key)
	{
		return _t.Insert(key);
	}
private:
	RBTree<K, K, SetKeyOfT> _t;
};
殿下p
关注
专栏目录
红黑树封装 map/set 及其迭代器(C++)
Brant_zero的博客
11-26 2597
使用红黑树封装map/set，并实现map/set的迭代器，支持成员访问、解引用、下标访问操作符++、-- 等功能.
【C++】红黑树 --- map/set 底层
YoungMLet的博客
11-13 1356
了解 map/set 底层红黑树的插入！使用红黑树封装 map/set ！
红黑树+红黑树模拟实现map/set
cxy_zjt的博客
11-07 899
红黑树 1.红黑树相关概念 (1).红黑树的性质 2. 红黑树核心代码实现 **(1).红黑树结点的定义** (2)插入的几种情况 Ⅰ插入的条件判断 a.cur为红，p为红，u存在且为红 b.cur为红，p为红，u不存在/存在且为黑 3. 红黑树和AVL树的比较 红黑树模拟实现map/set 1.红黑树迭代器的实现 (1).迭代器的++与-- (2)洪恩红黑树中的begin（）和end（） 2.改造红黑树 a.begin()和end() b.pairinsert(const
STL map / set 底层机制: 红黑树完全剖析
专注游戏研发
08-21 3019
前言： 在 STL 的容器中两大阵营 (vector deque list forward_list) 顺序容器 与 关联容器 （map set unorder_map unorder_set） 。 关联容器指的是以关键字匹配指定数据的一种关联数据结构的集合， 在关联容器中通过关键字去查找对应的数据是非常块的， 下面我们会彻底地去剖析其底层实现机制 ： 红黑树。 由基础树 到 二叉搜索树 介绍红黑树之前，容许我介绍树的概念。 1. 树（tree）， 在计算机科学中，是十分基础的数据结构： .
红黑树及map和set的模拟实现
2303_77348867的博客
07-09 1206
/节点颜色enum ColorRED,BLACK//红黑树节点的定义{}//节点的左孩子//节点的右孩子//节点的双亲//节点的值域//节点的颜色。
【数据结构】认识红黑树 --map/set的底层原理
ly_6699的博客
03-20 2255
**红黑树**也叫RB树(Red-Black Tree)，实际就是一种二叉搜索树，只是它的节点不是通过平衡因子来控制树的形状，而是为节点设置了两种颜色来控制，使得树中**最长路径中节点个数不会超过最短路径节点个数的两倍**，这样就能保证树触发旋转的几率大大减小。因此红黑树在每个节点上增加了一个一个的存储位表示节点的颜色，可以是Red或Black。
C++进阶-红黑树（map和set）
weixin_64423718的博客
07-26 1011
/ 枚举RED,BLACK// 节点类// 父亲节点// 左孩子节点// 右孩子节点// 节点数据// 节点颜色// 构造函数, _kv(kv){}
使用红黑树封装map和set
qq_47406941的博客
06-07 911
红黑树和AVL树都是二叉搜索树，但是从效率以及实现方式等方面综合来看，红黑树比AVL树更优。也就是说，红黑树是一种更好的，适合搜索的数据结构。同时，红黑树的使用方面非常广泛，Java库、linux内核、c++ST ...
对红黑树的认识总结
热门推荐
张彦峰的博客
05-12 171万+
当在红黑树中执行插入操作时，需要考虑两个主要方面：保持二叉搜索树性质和保持红黑性质。以下是插入操作的详细步骤，包括可能的旋转操作和颜色调整。插入操作的基本步骤：首先，将新节点插入到红黑树中，就像在普通的二叉搜索树中一样。新节点会被标记为红色，因为它可能会破坏红黑性质的第一个性质（根节点必须是黑色）。插入新节点后，可能会破坏红黑性质。需要通过一系列的操作来调整以确保所有的红黑性质得到满足。在进行旋转操作之前，需要进行颜色调整以满足红黑性质。
【 C++ 】用一颗红黑树封装map和set
bit_zyx的博客
09-04 522
目录 1、前言 2、红黑树模板参数的控制 3、模板参数中仿函数的增加 4、红黑树迭代器的实现 5、红黑树的begin()和end() 6、红黑树的Find查找函数 7、红黑树源码链接 8、set的代码 9、map的代码
map与set的底层大概框架-红黑树
04-04
学习map和set的友友们如果对红黑树的底层框架很模糊。 可以借鉴一下本文件中的红黑树。 虽然有些地方写的不够全不够好， 但是基本的迭代器功能都已经实现。其实红黑树的学习主要就是学习它的插入， 最重要的就是...
红黑树封装map&&set源代码
06-01
红黑树（Red-Black Tree）是一种自平衡二叉查找树，它在计算机科学中扮演着重要的角色，尤其是在实现高效的数据结构如哈希映射（Map）和集合（Set）时。红黑树的主要特性是它能保持近似的平衡状态，从而确保了插入、...
2024年，Rust开发语言，现在怎么样了?
LiangGang365的专栏
10-27 1162
Rust到底好不好用，最终还是要看具体的业务场景应用。比如，目前用Rust来编写纯UI的前端，可能还不是很成熟。但在内存管理、安全性和性能优化等领域，Rust无疑是一种非常优秀的语言选择。国内华为、字节、百度、阿里、美团等在通用组件、基础平台系统都在使用rust，其他国内数据库厂商、交易所、理想汽车、小鹏汽车等，以及大量在区块链、游戏行业提供的远程职位
c++中局部变量和全局变量同名，使用::访问全局变量
weixin_43845922的博客
11-02 185
局部变量可以与全局变量同名，在函数内引用这个变量时，会用到同名的局部变量，而不会用到全局变量。于有些编译器而言，在同一个函数内可以定义多个同名的局部变量，比如在两个循环体内都定义一个同名的局。答：能，局部会屏蔽全局。要用全局变量，需要使用”::”部变量，而那个局部变量的作用域就在那个循环体内。局部变量能否和全局变量重名？
Camp4-L0：Linux 前置基础
fangsfdavid的博客
10-29 869
书生浦语大模型实战营第四期：Linux前置基础
【C语言】预处理(预编译)详解(下)（C语言最终篇）
hdxbufcbjuhg的博客
10-29 2207
在编译⼀个程序的时候我们如果要将⼀条语句（⼀组语句）编译或者放弃编译，就可以使用条件编译，比如调试性的代码删掉很浪费，保留又很碍事，我们就可以使用条件编译，在编译的时候不编译这些调试性的代码在这里我们就可以使用一个技巧，在最开头使用#define定义一个符号，如果我们没有注释或者删除这个符号，那么我们就可以编译里面的调试性代码，进行正常调试，如果我们注释或者删除这个符号，那么我们就不编译里面的调试性代码，不影响代码的正常运行。
C++编程法则365天一天一条（344）理解std::optional的设计初衷
最新发布
二进制君
11-02 32
的设计初衷是为了解决处理可选值时的安全性和清晰性问题，提供一种简洁、易用的方式来表示和管理可能不存在的值。通过引入，C++ 提供了一个更现代化的替代方案，减少了使用传统空指针和特定标记值所带来的复杂性和错误风险。
CSP/信奥赛C++刷题训练：经典深搜例题（1）：洛谷1605 ：迷宫
weixin_66461496的博客
11-02 691
CSP/信奥赛C++刷题训练：经典深搜例题（1）：洛谷1605 ：迷宫
第20课-C++【二叉搜索树】
2401_83603768的博客
10-25 1140
二叉搜索树（Binary search tree）是一种特殊的二叉树，它的每个节点的左子树中的所有节点值都小于该节点值，而右子树中的所有节点值都大于该节点值。
C++红黑树封装实现map和set模拟
本资源将通过封装红黑树来模拟实现map和set。红黑树是一种自平衡的二叉搜索树，通过对插入和删除操作的特定处理，它可以保证最坏情况下的时间复杂度为O(log n)，这对于需要高效搜索和插入操作的场景非常有用。 在...
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

殿下p

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

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

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

打赏作者

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

抵扣说明：

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

余额充值