【C++】模拟map和set以及改造红黑树

已于 2023-05-21 10:13:20 修改
阅读量449 收藏
点赞数
分类专栏： C++ 文章标签： c++ c语言 开发语言
于 2023-02-20 17:35:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ahaooooooo/article/details/129124108
版权

文章目录

1、set和map的基础用法

stl中，像vector、list、deque等这样的容器，称之为序列式容器，其底层是线性序列的数据结构，里面存储的元素本身。
关联式容器，关联式容器不同的是，其存储是一个<key, value>键值对。
STL中关于键值对的定义:
在这里插入图片描述
简单来说就是可以通过一个pair对象访问其两个成员变量first和second，达到键值对的目的。

树型结构中的关联式容器主要有set、multiset、map和multimap。这四个容器的底层都是用的红黑树。
下面先一个一个看。

1.1 set的基本使用

在这里插入图片描述
set存储的是一值，和大部分容器一样，有着基本的begin、end、insert、erase、find、empty、size，这也是主要的功能。
值得说的是set由于底层是一个红黑树，其存储的数据没有重复的，并且set不允许修改数据，所以相较于map缺少了[]访问符，因为会打乱其结构。
 
如果需要重复的数据，multiset就派上了用场，multiset除了存储的数据可以重复外，其它的用法和set基本一致。
在这里插入图片描述

#include <iostream>
#include <set>
using std::cout;
using std::endl;

template<class T>
void testCont();

void testSet()
{
	//set默认less->升序 greater->降序
	testCont< std::set<int, std::greater<int>> >();
}

void testMultiset()
{
	testCont< std::multiset<int, std::greater<int>> >();
}


template<class T>
void testCont()
{
	T s;
	int arr[] = { 1,4,6,7,9,2,5,6 };
	//set不仅可以排序，也有去重功能
	for (auto& e : arr)
	{
		s.insert(e);
	}

	typename T::iterator it = s.begin();
	while (it != s.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;

	it = s.find(4);
	s.erase(it);
	for (auto& k : s)
	{
		cout << k << " ";
	}
	cout << endl;
}


int main()
{
	testSet();
	testMultiset();
	return 0;
}

在这里插入图片描述
 

1.2 map的基本使用

这里是引用
map存储的是一个键值对，有着基本的begin、end、insert、erase、find、empty、size、[]，这也是主要的功能。

 
在这里插入图片描述
multimap和map基本上一样，除了可以存储重复数据以及没有[]操作符。

 

值得注意的是map的[]操作符:
在官方文档中，将[]操作符等价于
在这里插入图片描述
其中insert，返回一个键值对，如果插入新值，返回新结点的迭代器和true，如果已有结点返回指向已有结点的迭代器和false。
在这里插入图片描述
在这里插入图片描述

简化后如下

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

常规用法

#include <iostream>
#include <map>
using std::cout;
using std::endl;

template<class T>
void testCont();

void testMap()
{
	testCont< std::map<int, int, std::greater<int>> >();
}

void testMultimap()
{
	testCont< std::multimap<int, int, std::greater<int>> >();
}


template<class T>
void testCont()
{
	T s;
	int arr[] = { 1,4,6,7,9,2,5,6 };

	//map不仅可以排序，也有去重功能
	for (auto& e : arr)
	{
		s.insert(std::make_pair(e, e));
	}

	typename T::iterator it = s.begin();
	while (it != s.end())
	{
		cout << (*it).first << ":" << (*it).second << " ";
		++it;
	}
	cout << endl;

	it = s.find(4);
	s.erase(it);
	for (auto& kv : s)
	{
		cout << kv.first << ":" << kv.second << " ";
	}
	cout << endl;
	cout << endl;
}

void testinsert()
{
	std::map<int, int, std::greater<int>> m;
	std::multimap<int, int, std::greater<int>> ml;

	//multimap 不支持[]操作符，因为其存储重复数据
	int arr[] = { 1,4,6,7,9,2,5,6 };
	for (auto& e : arr)
	{
		m[e] = e;
		//ml[e] = e; error
		ml.insert(std::make_pair(e, e));
	}

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

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

}

int main()
{
	testMap();
	testMultimap();

	testinsert();

	return 0;
}

 

2、set和map的模拟实现

为了更好的认识set和map，通过了解它们的stl源码，简单实现它们的功能。
 
set和map底层都是通过红黑树实现的。
在这里插入图片描述

2.1 建立map和set类

1、首先为了避免于std中重名，将创建的类放入test命名空间。
2、在stl源码中，map给红黑树传的模板参数是一个key和一个键值对
3、为了应对对红黑树结点取值不同的情况，通过传一个keyofValue类型，再通过仿函数的形式区分map和set访问的不同类型。
4、定义map迭代器的时候，typaname是为了表示
RBTree<K, pair<const K, V>, mapKeyOfValue>::iterator
是一个类型而不是一个其他的具体的值。（因为类::这样是可以访问类中定义的static类型和静态方法的）
5、注意键值对中的key不能修改。

//map.h
#pragma once
#include "RBTree.h"

namespace test
{
	template<class K, class V>
	class map
	{
		struct mapKeyOfValue
		{
			//专门放在mapKeyOfValue中，这样可读性好
			const K& operator()(const pair<const K, V>& kv)
			{
				return kv.first;
			}
		};
	public:
		typedef typename RBTree<K, pair<const K, V>, mapKeyOfValue>::iterator iterator;
		typedef typename RBTree<K, pair<const K, V>, mapKeyOfValue>::const_iterator const_iterator;
		pair<iterator, bool> insert(const pair<const K, V>& kv)
		{
			return _t.insert(kv);
		}

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

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

		const_iterator begin() const
		{
			return _t.begin();
		}

		const_iterator end() const
		{
			return _t.end();
		}

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

		iterator find(const K& k)
		{
			return _t.find(k);
		}

		/*const_iterator find(const K& k) const
		{
			return _t.find(k);
		}*/

	private:
		RBTree<K, pair<const K, V>, mapKeyOfValue> _t;
	};

1、set要求的是迭代器返回指向的结点不能被修改，所以定义的iterator和const_iterator，都用的是红黑树的const_iterator进行定义。
2、set中的insert调用红黑树中的insert会返回一个键值对，这个键值对里面的iterator返回的是红黑树中的普通迭代器，这个普通迭代器再返回给set中的insert键值对时，会发生键值对的拷贝构造，对应红黑树的普通迭代器需要转换成const迭代器（因为set中iterator是用红黑树const迭代器实现的）。（我们在红黑树迭代器类中看具体是怎么处理的）

#pragma once
#include "RBTree.h"

namespace test
{
	template<class K>
	class set
	{
		struct setKeyOfValue
		{
			const K& operator()(const K& k)
			{
				return k;
			}
		};
	public:
		typedef typename RBTree<K, K, setKeyOfValue>::const_iterator iterator;
		typedef typename RBTree<K, K, setKeyOfValue>::const_iterator const_iterator;

		pair<iterator, bool> insert(const K& k)
		{
			//这里返回的一个pair，然后调用pair的拷贝构造，pair拷贝构造又要调用iterator的拷贝构造（调用默认拷贝构造），
			//因为这里的iterator是RBTree中的const迭代器，返回的pair里是RBTree的普通迭代器
			//所以出现了如何将普通迭代器转换成const迭代器的问题
			//return _t.insert(k);
			

			//这样写就好理解一点
			pair<typename RBTree<K, K, setKeyOfValue>::iterator, bool> ret = _t.insert(k);
			return pair<iterator, bool>(ret.first, ret.second);
		}

		//这里只需要提供普通迭代器版本就行，因为const this指针会调用RBTree里的const迭代器
		iterator begin() const
		{
			return _t.begin();
		}

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

		iterator find(const K& k)
		{
			return _t.find(k);
		}
	private:
		RBTree<K, K, setKeyOfValue> _t;
	};

2.1 红黑树的完善

在红黑树的结点中，只存一个值，map中存键值对，set中存一个值。

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

enum Color { RED = 0, BLACK };

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


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

实现红黑树迭代器

迭代器中通过模板参数有这几个妙手：
1、比较常见的，对应普通迭代器需要返回T&、T*，对应const迭代器需要返回const T&、const T*，通过template<class T, class Ref, class Ptr>，就能实现普通迭代器和const迭代器的转换。
2、如果需要将普通迭代器转换成const迭代器，通过
typedef RBTreeIterator<T, T&, T*> iterator;表示普通迭代器。
在需要用普通迭代器构造成const迭代器的时候，通过调用RBTreeIterator(const iterator& s)这个构造就能实现。

//RBTree.h
// 对于红黑树类中定义迭代器
//	typedef RBTreeIterator<T, T&, T*> iterator;
//	typedef RBTreeIterator<T, const T&, const T*> const_iterator;
template<class T, class Ref, class Ptr>
struct RBTreeIterator
{
	typedef RBTreeNode<T> Node;
	typedef RBTreeIterator<T, Ref, Ptr> Self;
	typedef RBTreeIterator<T, T&, T*> iterator;
	RBTreeIterator(Node* node)
		:_node(node)
	{}
	
	//当是普通迭代器的时候，Self和iterator都一样这时候下面的函数是一个拷贝构造
	//当是const迭代器的时候，Ref是const T&，Ptr是const T*
	//这个时候，Self代表const迭代器，iterator还是一个普通迭代器下面的函数就成了一个构造函数（用普通构造const的构造函数)。
	RBTreeIterator(const iterator& s)
		:_node(s._node)
	{}

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

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

	Self& operator++()
	{
		if (_node->_right)
		{
			Node* minRight = _node->_right;
			while (minRight->_left)
			{
				minRight = minRight->_left;
			}

			_node = minRight;
		}
		else
		{
			Node* cur = _node;
			Node* parent = cur->_parent;
			while (parent && parent->_right == cur)
			{
				cur = parent;
				parent = parent->_parent;
			}

			_node = parent;
		}

		return *this;
	}

	Self& operator--()
	{
		if (_node->_left)
		{
			Node* maxLeft = _node->_left;
			while (maxLeft->_right)
			{
				maxLeft = maxLeft->_right;
			}

			_node = maxLeft;
		}
		else
		{
			Node* cur = _node;
			Node* parent = cur->_parent;
			while (parent && parent->_left == cur)
			{
				cur = parent;
				parent = parent->_parent;
			}

			_node = parent;
		}

		return *this;
	}

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

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

	Node* _node;
};

改造红黑树插入

template<class K, class T, class KeyOfValue>
class RBTree
{
	typedef RBTreeNode<T> Node;
public:
	typedef RBTreeIterator<T, T&, T*> iterator;
	typedef RBTreeIterator<T, const T&, const T*> const_iterator;
	
	//树的最左结点
	iterator begin()
	{
		if (_root == nullptr)
		{
			return iterator(nullptr);
		}
		Node* pbegin = _root;
		while (pbegin->_left)
		{
			pbegin = pbegin->_left;
		}
		return iterator(pbegin);
	}

	iterator end()
	{
		return iterator(nullptr);
	}
	
	//迭代器指向的结点不能改变
	const_iterator begin() const
	{
		if (_root == nullptr)
		{
			return const_iterator(nullptr);
		}
		Node* pbegin = _root;
		while (pbegin->_left)
		{
			pbegin = pbegin->_left;
		}
		return const_iterator(pbegin);
	}

	const_iterator end() const
	{
		return const_iterator(nullptr);
	}
	
	
	pair<iterator, bool> insert(const T& data)
	{
		if (_root == nullptr)
		{
			_root = new Node(data);
			_root->_col = BLACK;
			return make_pair(iterator(_root), true);
		}
		
		//类实例化
		KeyOfValue kov;
		Node* cur = _root;
		Node* parent = _root;
		while (cur)
		{
			//仿函数
			if (kov(cur->_data) < kov(data))
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (kov(cur->_data) > kov(data))
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return make_pair(iterator(cur), false);
			}
		}

		cur = new Node(data);
		Node* ret = cur;
		cur->_col = RED;
		if (kov(parent->_data) < kov(cur->_data))
		{
			parent->_right = cur;
			cur->_parent = parent;
		}
		else
		{
			parent->_left = cur;
			cur->_parent = parent;
		}

		while (parent && parent->_col == RED)
		{
			Node* grandparent = parent->_parent;
			if (parent == grandparent->_left)
			{
				Node* uncle = grandparent->_right;
				if (uncle && uncle->_col == RED)
				{
					//第一种情况
					parent->_col = BLACK;
					uncle->_col = BLACK;
					grandparent->_col = RED;

					cur = grandparent;
					parent = cur->_parent;
				}
				else
				{
					//需要判断cur在parent的哪边
					if (parent->_right == cur)
					{
						//情况四
						RotateL(parent);
						RotateR(grandparent);
						cur->_col = BLACK;
						grandparent->_col = RED;
					}
					else
					{
						//情况二/三
						RotateR(grandparent);
						parent->_col = BLACK;
						grandparent->_col = RED;
					}
					break;
				}
			}
			else
			{
				Node* uncle = grandparent->_left;
				if (uncle && uncle->_col == RED)
				{
					//第一种情况
					parent->_col = BLACK;
					uncle->_col = BLACK;
					grandparent->_col = RED;

					cur = grandparent;
					parent = cur->_parent;
				}
				else
				{
					//需要判断cur在parent的哪边
					if (parent->_right == cur)
					{
						//情况二/三
						RotateL(grandparent);
						parent->_col = BLACK;
						grandparent->_col = RED;
					}
					else
					{
						//情况四
						RotateR(parent);
						RotateL(grandparent);
						cur->_col = BLACK;
						grandparent->_col = RED;
					}
					break;
				}

			}
		}

		_root->_col = BLACK;
		return make_pair(iterator(ret), true);
	}

	void RotateL(Node* parent)
	{
		Node* sub = parent->_right;
		Node* subL = sub->_left;

		parent->_right = subL;
		if (subL)
		{
			subL->_parent = parent;
		}
		sub->_left = parent;
		Node* ppnode = parent->_parent;
		parent->_parent = sub;

		if (ppnode == nullptr)
		{
			_root = sub;
			_root->_parent = nullptr;
		}
		else
		{
			if (ppnode->_right == parent)
			{
				ppnode->_right = sub;
			}
			else
			{
				ppnode->_left = sub;
			}
			sub->_parent = ppnode;
		}
	}

	void RotateR(Node* parent)
	{
		Node* sub = parent->_left;
		Node* subR = sub->_right;

		parent->_left = subR;
		if (subR)
		{
			subR->_parent = parent;
		}

		sub->_right = parent;
		Node* ppnode = parent->_parent;
		parent->_parent = sub;

		if (ppnode == nullptr)
		{
			_root = sub;
			_root->_parent = nullptr;
		}
		else
		{
			if (ppnode->_right == parent)
			{
				ppnode->_right = sub;
			}
			else
			{
				ppnode->_left = sub;
			}
			sub->_parent = ppnode;
		}
	}
	
	iterator find(const K& k)
	{
		if (_root == nullptr)
		{
			return iterator(nullptr);
		}

		KeyOfValue kov;
		Node* cur = _root;
		while (cur)
		{
			if (kov(cur->_data) < k)
			{
				cur = cur->_right;
			}
			else if (kov(cur->_data) > k)
			{
				cur = cur->_left;
			}
			else
			{
				return iterator(cur);
			}
		}

		return iterator(nullptr);
	}
private:
	Node* _root = nullptr;
};

结果测试

#include "map.h"
#include "set.h"
	void maptest()
	{
		test::map<int, int> m;
		int arr[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };
		for (auto& e : arr)
		{
			m[e] = e;
		}

		test::map<int, int>::iterator it = m.begin();
		while (it != m.end())
		{
			cout << (*it).first << ":" << (*it).second << endl;
			++it;
		}

		test::map<string, int> countMap;
		string arr1[] = { "苹果", "西瓜", "香蕉", "草莓", "苹果", "西瓜", "苹果", "苹果", "西瓜", "苹果", "香蕉", "苹果", "香蕉" };
		for (auto& e : arr1)
		{
			countMap[e]++;
		}

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

		test::map<string, int>::iterator it1 = countMap.find("西瓜");
		cout << "西瓜: " << (*it1).second << endl;
	}
	
	void settest()
	{
		test::set<int> s;
		int arr[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };
		for (auto& e : arr)
		{
			s.insert(e);
		}

		test::set<int>::iterator it = s.begin();
		while (it != s.end())
		{
			//*it += 10; //set不能修改数据
			cout << *it << " ";
			++it;
		}

		cout << endl;
		it = s.find(4);
		cout << *it << endl;

	}
	
	int main()
	{
		settest();
		maptest();
		return 0;
	}

在这里插入图片描述

本节完~

Ahao_te
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
红黑树模拟实现STL中的map与set（附详细代码）
zhao_leilei的博客
01-26 689
文章目录1.红黑树的迭代器2.改造红黑树3.map的模拟实现4.set的模拟实现 1.红黑树的迭代器 迭代器的好处是可以方便遍历，使数据结构的底层实现与用户透明。如果想要给红黑树增加迭代器，需要考虑以下问题： begin()与end() STL明确规定，begin()与end()代表的是一段前闭后开的区间，而对红黑树进行中序遍历后，可以得到一个有序的序列，因此：begin()可以放在红黑树中最小节点(即最左侧节点)的位置，end()放在最大节点(最右侧节点)的下一个位置，关键是最大节点的下一个位置在哪块？能
map和set的模拟实现
最新发布
06-06
在IT领域，数据结构是编程的基础，...总之，通过封装红黑树并结合C++的面向对象特性，我们可以构建出高性能的Map和Set模拟实现。这不仅可以加深对数据结构和算法的理解，也有助于在实际项目中构建高效的数据处理机制。
红黑树实现——STL中的map
zhongjie的专栏
11-04 7797
红黑树实现——STL中的map [ 2009-07-24 13:55:31 | 作者: dklkt ] 字号: 大 | 中 | 小 [转载]STL中map实现技术 来源：http://blog.csdn.net/Fandywang_jlu/archive/2008/03/23/2208363.aspx 红黑树是一种自平衡二叉查找树，是在计算机科学中用到的一种数据结构，
STL中map和set底层的红黑树实现
一面之媛
08-28 469
我们都知道map和set的实现是依赖红黑树的 怎样写红黑树可以让map和set都可以使用呢？ 在这里我们定义了一个模版参数，如果它是key那么它就是set，如果它是map，那么它就是map； 我们分析一下，红黑树迭代器的前置++ 到当前结点，就说明了它的左子树和自己都已经访问过了 1，当前位置，若右树不为空，则访问右树的最左结点 2，当前位置，若右树为空，则找祖先中孩子不是他的右 若右访问完，那么父亲这棵树也就访问完了 前置–的算法思想和++是近似的。 比较大小时，set直接比较它的key，而map是比
STL容器之map和set的补充——红黑树
qq_33093885的博客
03-06 1083
c++红黑树的学习和模拟实现
【C++】-- STL之用红黑树模拟实现map和set
局部变量和全局变量
09-08 1057
用红黑树同时封装出set和map时，set传给value的是一个value，map传给value的是一个pair，set和map传给红黑树的value决定了这棵树里面存的节点值类型。上层容器不同，底层红黑树的Key和T也不同。
使用C++实现的rbtree红黑树.zip
03-21
红黑树（Red-Black Tree）是一种自平衡的二叉...红黑树广泛应用于各种数据结构和算法中，如STL中的map和set容器，以及数据库索引等场景。理解和掌握红黑树的原理及C++实现，对于提升编程能力和解决实际问题大有裨益。
红黑树-基于C++实现的红黑树数据结构.zip
03-21
例如，在C++标准模板库(STL)中，`std::set`和`std::map`就是基于红黑树实现的。 在C++中实现红黑树时，通常会定义一个名为`RBTree`的类，包含私有成员变量（如根节点指针）和公共成员函数（如`insert`, `delete`, `...
C++红黑树实现过程
09-15
在实际应用中，红黑树常用于实现STL中的`std::map`和`std::set`，以及内存管理的哈希表等数据结构，因为它提供了高效的查找、插入和删除操作。在C++中，理解和实现红黑树可以帮助开发者深入掌握数据结构和算法，提升...
c++容器list、vector、map、set区别与用法详解
08-19
"c++容器list、vector、map、set区别与用法详解" c++容器是c++标准模板库（STL）中的一个重要组件，提供了多种数据结构的实现，包括list、vector、map、set等。这些容器的使用可以大大提高开发效率和代码可读性。 ...
科普解读：为什么C++ STL中的map使用红黑树而不是散列表？
Lion_Long的博客
07-27 1688
文章探讨了C++STL中的map使用红黑树而非散列表的原因，分析了红黑树和散列表在查找、插入、删除操作的时间复杂度、空间利用率等方面的差异，并介绍了unordered_map作为散列表实现的特点和应用场景。红黑树在保持良好平衡性的同时提供稳定的查找效率，适合有序存储，而unordered_map利用散列表实现快速插入和查找，但不保证元素顺序。
STL—— 用一棵红黑树同时封装出map和set
裙下的霸气的博客
01-27 556
STL——红黑树封装....
红黑树（BTree）
langk_的博客
09-08 343
红黑树是怎么平衡的？
Stl中map、set 容器（数据结构：AVL树、红黑树）--C++
qq_63412763的博客
09-24 1820
Stl的容器中，map和set都是用的树状数据结构----二叉树！但实际上用的并不是普普通通的树状结构，而是一种设计好的，规律性极强的树状数据结构：红黑树（二叉树的一种，细节下面讲）对于map和set来讲，中序遍历依旧是有序的，而这和之前讲的二叉搜索树有点相似。
STL笔记【map(红黑树)，multimap，unordered_map(哈希)，unordered_multimap】
weixin_44238769的博客
04-06 389
map的一些常用方法 对于map来说，底层实现是红黑树，在插入的时候就会按照key值来排序，所以如果是插入的自定义数据类型那么就需要写仿函数，重载小括号来实现插入，对于自定义排序规则也要通过仿函数以及重载小括号来实现想要的排序。 multimap相对于map来说可以插入重复的key值，与set相同的是，map如果插入的数据的key是一样的就会插入失败，不同点是通过map[key] = value；这种方法来实现的插入，如果存在key值则更新value，如果不存在key值则插入key-value键值对。 vo
map底层为什么用红黑树实现
Ternence_zq的博客
11-19 7025
参考回答： 1、红黑树： 红黑树是一种二叉查找树，但在每个节点增加一个存储位表示节点的颜色，可以是红或黑（非红即黑）。 通过对任何一条从根到叶子的路径上各个节点着色的方式的限制，红黑树确保没有一条路径会比其它路径长出两倍，因此，红黑树是一种弱平衡二叉树，相对于要求严格的AVL树来说，它的旋转次数少，所以对于搜索，插入，删除操作较多的情况下，通常使用红黑树。 性质： 每个节点非红即黑 根节点是黑的; 每个叶节点（叶节点即树尾端NULL指针或NULL节点）都是黑的; 如果一个节点是红色的，则它的
STL中map用法详解
人的梦想是不会终结的
04-01 761
Map是STL的一个关联容器，它提供一对一（其中第一个可以称为关键字，每个关键字只能在map中出现一次，第二个可能称为该关键字的值）的数据处理能力，由于这个特性，它完成有可能在我们处理一对一数据的时候，在编程上提供快速通道。这里说下map内部数据的组织，map内部自建一颗红黑树(一种非严格意义上的平衡二叉树)，这颗树具有对数据自动排序的功能，所以在map内部所有的数据都是有序的，后边我们会见识到有
2020-08-16
qq_40510469的博客
08-16 139
完整简单的红黑树算法 一、红黑树性质 1.每个结点要么是红的要么是黑的 2.根结点是黑的 3.每个叶结点（叶结点即指树尾端NIL指针或NULL结点）都是黑的 4.如果一个结点是红的，那么它的两个儿子都是黑的 5.对于任意结点而言，其到叶结点树尾端NIL指针的每条路径都包含相同数目的黑结点 总结：平衡状态下红黑树要么单支黑-红，要么有两个子节 二、复杂度 O（lgn） 三、结点插入 将一个节点插入到红黑树中，需要执行哪些步骤呢？首先，将红黑树当作一颗二叉查找树，将节点插入；然后，将.
C++ map set 红黑树
07-28
C++中的map和set容器都是基于红黑树实现的。 红黑树是一种自平衡的二叉搜索树，它通过对节点进行染色来满足一定的性质，从而保持树的平衡。红黑树的性质包括： 1. 每个节点只能是红色或黑色。 2. 根节点是黑色。 3...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值