红黑树封装实现map和set

最新推荐文章于 2024-09-15 19:46:31 发布
最新推荐文章于 2024-09-15 19:46:31 发布
阅读量47 收藏
点赞数
分类专栏： C++ # 数据结构 文章标签： java 前端 javascript
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_54202947/article/details/131302939
版权

全文目录

map和set

map和set 是STL中的容器，两者底层的实现都是参考文档：


map参考文档

在这里插入图片描述


set参考文档

在这里插入图片描述

两个容器底层都是去重的二叉搜索树实现的，一般使用高效的红黑树通过封装来实现。

红黑树的封装

先看一下原码：

在这里插入图片描述

在STL的原码中红黑树是有两个数据类型的树，map和set是通过控制模板类型的传递来生成不同数据类型的红黑树。

map传递：key 和 pair<key, value>

set传递： key 和 key

但是这样有导致了红黑树比较时不知道是使用单类型还是pair类来进行的比较，所以在参数传递时还会将传递仿函数，指定使用key进行比较

map的比较仿函数：

template<typename K, typename V>
struct MapValueOfT
{
	const K& operator()(const pair<K, V>& kv) const
	{
		return kv.first;
	}
};

set的比较类仿函数：

template<typename K>
struct SetValueOfT
{
	const K& operator()(const K& key) const
	{
		return key;
	}
};

那么在两者内部，红黑树都是这样的结构：

map的底层红黑树：

template<typename K, typename V> 
class map
{
public:
	typedef pair<K, V> valueType;
	typedef RBTree<K, valueType, MapValueOfT<K, V>> Tree;
	Tree _t;
}

set底层的红黑树：

template<typename K>
class set
{
public:
	typedef K valueType;
	typedef RBTree<K, valueType, SetValueOfT<K>> Tree;
	Tree _t;
}

红黑树的迭代器

begin() 和 end()

STL明确规定，begin()与end()代表的是一段前闭后开的区间，而对红黑树进行中序遍历后，可以得到一个有序的序列，因此：begin()可以放在红黑树中最小节点(即最左侧节点)的位置，end() 放在最大节点(最右侧节点)的下一个位置，关键是最大节点的下一个位置在哪块？

能否给成nullptr呢？答案是行不通的，因为对end()位置的迭代器进行–操作，必须要能找最后一个元素，此处就不行，因此最好的方式是将end()放在头结点的位置：

在这里插入图片描述

但是实现的红黑树的头结点是nullptr，我们只实现正向的迭代器：

operator++()

找迭代器的下一个节点，因为是中序遍历，所以分两种情况：

  1. 右子树存在

找右子树的最左节点

  1. 右子树不存在

右子树不存在，向上查找，直到 cur != parent->_right

Self& operator++()
{
	// 右子树不为空，就是找右子树中的最左节点
	if (_node->_right)
	{
		_node = _node->_right;
		while (_node->_left)
		{
			_node = _node->_left;
		}

	}
	else
	{
		// 右子树为空，找孩子不是父亲的右节点的父节点
		Node* parent = _node->_parent;
		while (parent && parent->_right == _node)
		{
			_node = parent;
			parent = parent->_parent;
		}
		_node = parent;
	}

	return *this;
}

operator–()

获取中序遍历的前一个节点，同样分两种情况：

  1. 左子树存在

在左子树中找最大的节点，即左子树中最右侧节点

  1. 左子树不存在

左子树不存在，向上查找，直到 cur != parent->_left

Self& operator--()
{
	// 左子树不为空，找左子树中的最右节点
	if (_node->_left)
	{
		_node = _node->_left;
		while (_node && _node->_left)
		{
			_node = _node->_left;
		}
	}
	else
	{
		// 左子树为空，找孩子不是父亲的左节点的父节点
		Node* parent = _node->_parent;
		while (parent && parent->_left == _node)
		{
			_node = parent;
			parent = parent->_parent;
		}
	}

	return *this;
}

map完整代码

template<typename K, typename V>
struct MapValueOfT
{
	const K& operator()(const pair<K, V>& kv) const
	{
		return kv.first;
	}
};

template<typename K, typename V> 
class map
{
public:
	typedef pair<K, V> valueType;
	typedef RBTree<K, valueType, MapValueOfT<K, V>> Tree;
	typedef typename RBTree<K, valueType, MapValueOfT<K, V>>::iterator iterator;

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

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



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

	void inorder()
	{
		_t.InOrder();
	}

	V& operator[](const K& key)
	{
		return (insert(make_pair(key, V())).first)->second;
	}

	Tree _t;
};

set完整代码

template<typename K>
struct SetValueOfT
{
	const K& operator()(const K& key) const
	{
		return key;
	}
};

template<typename K>
class set
{
public:
	typedef K valueType;
	typedef RBTree<K, valueType, SetValueOfT<K>> Tree;
	typedef typename RBTree<K, valueType, SetValueOfT<K>>::iterator iterator;

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

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


	pair<iterator, bool> insert(const K& key)
	{
		return _t.Insert(key);
	}

	void inorder()
	{
		_t.InOrder();
	}

	Tree _t;
};

改造后的红黑树代码

enum Color
{
	BLACK,
	RED
};
template<typename T>
struct RBNode
{
	RBNode(const T& data)
		: _data(data)
		, _left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _col(RED)
	{}

	RBNode<T>* _left;
	RBNode<T>* _right;
	RBNode<T>* _parent;
	Color _col;
	T _data;
};

template<typename T, typename Ref, typename Ptr>
class Iterator
{
public:
	typedef RBNode<T> Node;
	typedef Iterator<T, Ref, Ptr> Self;

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

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

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

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

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

	Self& operator++()
	{
		// 右子树不为空，就是找右子树中的最左节点
		if (_node->_right)
		{
			_node = _node->_right;
			while (_node->_left)
			{
				_node = _node->_left;
			}

		}
		else
		{
			// 右子树为空，找孩子不是父亲的右节点的父节点
			Node* parent = _node->_parent;
			while (parent && parent->_right == _node)
			{
				_node = parent;
				parent = parent->_parent;
			}
			_node = parent;
		}

		return *this;
	}

	Self& operator--()
	{
		// 左子树不为空，找左子树中的最右节点
		if (_node->_left)
		{
			_node = _node->_left;
			while (_node && _node->_left)
			{
				_node = _node->_left;
			}
		}
		else
		{
			// 左子树为空，找孩子不是父亲的左节点的父节点
			Node* parent = _node->_parent;
			while (parent && parent->_left == _node)
			{
				_node = parent;
				parent = parent->_parent;
			}
		}

		return *this;
	}

	Self operator++(int)
	{
		Self tmp(_node);
		this->operator++();
		return tmp;
	}

	Self operator--(int)
	{
		Self tmp(_node);
		operator--();
		return tmp;
	}

private:
	Node* _node;
};

template<typename Key, typename Value, typename ValueOfT = less<Key>>
class RBTree
{
public:
	typedef RBNode<Value> Node;
	typedef Iterator<Value, Value&, Value*> iterator;

	RBTree()
		: _root(nullptr)
	{}

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

		return iterator(cur);
	}

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



	pair<iterator, bool> Insert(const Value& data)
	{
		// 空树的插入
		if (_root == nullptr)
		{
			_root = new Node(data);
			_root->_col = BLACK;
			return make_pair(_root, true);
		} 

		// 非空树的插入
		Node* parent = nullptr;
		Node* cur = _root;

		// 寻找插入的位置
		while (cur)
		{
			parent = cur;

			if (cmp(data) > cmp(cur->_data))
			{
				cur = cur->_right;
			}
			else if (cmp(data) < cmp(cur->_data))
			{
				cur = cur->_left;
			}
			else	// 找到重复元素，插入失败
			{
				return make_pair(cur, false);
			}
		}

		// 开始插入
		cur = new Node(data);
		if (cmp(data) > cmp(parent->_data))
		{
			cur->_parent = parent;
			parent->_right = cur;
		}
		else
		{
			cur->_parent = parent;
			parent->_left = cur;
		}
		Node* newNode = cur;

		// 如果父节点是根节点，那么它的颜色一定是要黑色，不然在前面插入的时候已经出错了
		// 所以进入循环，就说明一定存在祖父节点
		while (parent && parent->_col == RED)
		{
			Node* grandfather = parent->_parent;
			if (parent == grandfather->_left)
			{
				Node* uncle = grandfather->_right;
				if (uncle && uncle->_col == RED)	// 叔叔存在且为红，继续往上更新
				{
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;
					cur = grandfather;
				}
				else	// 叔叔不存在或者叔叔为黑
				{
					if (cur == parent->_left)	// 右单旋
					{
						//       g
						//      / \
						//     p   u
						//    /
						//   c 
						RotateR(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else	// 左右双旋
					{
						//        g
						//       / \
						//      p   u
						// 		 \					   
						//        c
						//RotateL(parent);
						//RotateR(grandfather);
						RotateLR(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}
						

					break;
				}
			}
			else if (parent == grandfather->_right)
			{
				Node* uncle = grandfather->_left;
				if (uncle && uncle->_col == RED)	// 叔叔存在且为红，继续往上更新
				{
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;
					cur = grandfather;
				}
				else	// 叔叔不存在或者叔叔为黑
				{
					if (cur == parent->_right)	// 左单旋
					{
						//       g
						//      / \
						//     u   p
						//          \
						//           c
						RotateL(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else	// 右左双旋
					{
						//       g
						//      / \
						//     u   p
						//        /
						//       c
						//RotateR(parent);
						//RotateL(grandfather);
						RotateRL(grandfather);
						cur->_col =	 BLACK;
						grandfather->_col = RED;
					}

					break;
				}
			}
		}

		_root->_col = BLACK;

		return make_pair(newNode, true);
	}


	void InOrder()
	{
		_InOrder(_root);
	}

	// 根据黑色节点数量判断是否满足红黑树条件
	bool IsBalance()
	{
		if (_root && _root->_col == RED)
		{
			puts("root的颜色为红！！！");
			return false;
		}

		int balanceNum = 0;
		return Check(_root, balanceNum, 0);	
	}


private:
	// 前序遍历检查每天路径上的黑色节点数量
	bool Check(Node* root, int& balanceNum, int blackNum)
	{
		if (root == nullptr)
		{
			if (balanceNum == 0)
			{
				balanceNum = blackNum;
				return true;
			}
			else
			{
				if (blackNum == balanceNum)
					return true;
				else 
					return false;
			}
		}

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

		return Check(root->_left, balanceNum, blackNum)
			&& Check(root->_right, balanceNum, blackNum);
	}


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

		_InOrder(root->_left);
		cout << root->_data.first << " : " << root->_data.second << endl;
		_InOrder(root->_right);
	}

	// 左单旋
	void RotateL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
		Node* pparent = parent->_parent;

		parent->_right = subRL;
		if (subRL)
			subRL->_parent = parent;

		parent->_parent = subR;
		subR->_left = parent;

		subR->_parent = pparent;
		if (pparent)
		{
			if (pparent->_left == parent)
				pparent->_left = subR;
			else
				pparent->_right = subR;
		}
		else
			_root = subR;


	}

	// 右单旋
	void RotateR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		Node* pparent = parent->_parent;


		parent->_left = subLR;
		if (subLR)
			subLR->_parent = parent;

		parent->_parent = subL;
		subL->_right = parent;

		subL->_parent = pparent;
		if (pparent)
		{
			if (pparent->_left == parent)
				pparent->_left = subL;
			else
				pparent->_right = subL;
		}
		else
			_root = subL;


	}


	// 左右双旋
	void RotateLR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;

		RotateL(subL);
		RotateR(parent);	
	}

	// 右左双旋
	void RotateRL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;

		RotateR(subR);
		RotateL(parent);
	}

	ValueOfT cmp;
	Node* _root;
};
_featherbrain
关注
专栏目录
【C++】红黑树详解并封装实现map和set
love_guanghui的博客
03-18 3156
红黑树详解
使用红黑树封装map和set
qq_47406941的博客
06-07 878
红黑树和AVL树都是二叉搜索树，但是从效率以及实现方式等方面综合来看，红黑树比AVL树更优。也就是说，红黑树是一种更好的，适合搜索的数据结构。同时，红黑树的使用方面非常广泛，Java库、linux内核、c++ST ...
【C++】红黑树封装实现map和set
The porters of knowledge
04-01 1017
用一棵红黑树封装map和set，set表层迭代器底层均为红黑树的const迭代器，实现map的[ ]重载……
【C++进阶】红黑树封装实现map和set
m0_67077469的博客
03-20 454
红黑树封装实现map和set
用红黑树封装实现map和set
decade777555的博客
03-15 1026
map和set都是基于红黑树实现的。红黑树是一种自平衡的二叉搜索树，它保持着良好的平衡性能，插入、删除、查找的时间复杂度都是O(log n)。在C++ STL中，map和set都是使用红黑树作为底层数据结构来实现的。
_cpp利用红黑树封装实现map和set
Dingyuan0的博客
11-06 795
0. 前言 1. 改造红黑树 1.1 红黑树节点的定义 1.2 红黑树中的迭代器 1.2.1 模拟实现前置加加的方法 1.2.2 模拟实现前置减减的方法 1.2.3 红黑树迭代器代码 1.3 仿函数 1.4 红黑树整体改造完成后的代码 2. 封装实现map 3. 封装实现set 4. 测试案例 5. 测试结果
C++红黑树模拟实现map和set
~
04-01 3927
C++红黑树模拟实现map和set零、前言一、红黑树及其节点的设计1、树节点的设计2、红黑树的设计3、取值仿函数的使用二、红黑树的迭代器1、begin()与end()2、operator++()与operator--()3、正反迭代器的实现三、map和set的实现1、红黑树的实现2、map的封装3、set的封装 零、前言 本章是继红黑树的介绍和实现后，讲解使用红黑树来封装实现map和set 一、红黑树及其节点的设计 对于底层都是红黑树的map和set来说，他们之间存在的最大的区别就是：对于set是K模
【C++】红黑树封装实现 map 和 set
在平淡的日子里寻找存在的价值
04-03 700
红黑树封装实现 map 和 set
C++：红黑树封装实现map、set
rab1211764820的博客
04-07 1024
红黑树封装实现map、set
红黑树封装set和map
唐学长的博客
06-12 169
红黑树封装set和map
红黑树封装map&&set源代码
06-01
通过理解红黑树的工作原理，并结合上述关键部分，我们可以构建出自己的红黑树封装的Map和Set实现。这样的实现有助于深入理解数据结构和算法，同时也可以用于学习和教学目的。在实际开发中，直接使用Java提供的`...
Java企业面试题3
最新发布
m0_74972727的博客
09-15 316
1. break和continue的作用(智*图) break：用于完全退出一个循环（如 for, while）或一个 switch 语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。 continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在 for 循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。 2. if分支语句和switch分支语句的异同之处(智*图) 相同点：都是用来根据不同的条件执行不同的代码块。
上传文件到钉盘流程详解
jspyth的博客
09-14 570
本文详解如何通过钉钉的API实现上传文件到钉盘目录，代码通过JAVA实现。
【学习笔记】手写 Tomcat 三
LearnTech_123的博客
09-12 1090
响应动态资源不需要写文件名了，只需要写功能的名称即可。比如登录功能，可以定义名称为 doLogin
Gradle
xiaocaij_icai的博客
09-15 132
");
笔记：Centos Jdk Nginx 安装包安装命令
贰十六的博客
09-12 586
进入到usr中的src，把刚才下载的安装包拉进去。# ./configure 报错。# 将下面填写到配置最下方。# JDK 解压版 配置。# 进入环境变量配置。
计算机毕业设计 基于SpringBoot的课程教学平台的设计与实现 Java+SpringBoot+Vue 前后端分离 文档报告 代码讲解 安装调试
weixin_19164791635
09-12 885
本文介绍了一款基于Java、SpringBoot和Vue.js技术的课程教学平台。该平台服务于管理员、学生和教师，提供教学资源管理、课程信息浏览、作业提交与批改等功能，旨在优化教学流程，提升教育质量，促进教育资源的数字化共享，推动教育信息化发展。
spring security中几大组件的作用和执行顺序
阿信今天的代码没bug的博客
09-11 322
spirng security中的几大组件的差异和执行顺序
c++stl中红黑树的实现
09-14
在C++ STL中，红黑树的实现被封装在`std::map`和`std::set`这两个容器类中。这两个容器类都是基于红黑树实现的，它们提供了高效的查找、插入和删除操作，保证了元素的有序性。 STL中的红黑树实现与你提供的C++代码...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

_featherbrain

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

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

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

打赏作者

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

抵扣说明：

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

余额充值