红黑树实现map，set封装

最新推荐文章于 2024-07-25 11:43:17 发布
最新推荐文章于 2024-07-25 11:43:17 发布
阅读量222 收藏 3
点赞数 5
文章标签： 数据结构 c++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_64404343/article/details/129639524
版权

目录

红黑树改造

 红黑树正向迭代器

 结构

operator*和operator-> 

operator++ 

operator-- 

operator！=和==

红黑树反向迭代器 

红黑树封装源码

map封装源码

set封装源码

红黑树改造

为了实现复用，我们将红黑树模板参数进行改造。 

T表示节点中所存储的数据类型 

template<class T>
struct RBNode
{
	RBNode<T>* _left;
	RBNode<T>* _right;
	RBNode<T>* _parent;
	T _data;
	Color _col;
	RBNode(const T& data)
		:_left(nullptr)
		,_right(nullptr)
		,_parent(nullptr)
		,_data(data)
		,_col(RED)
	{

	}
};

K表示key的类型，而T表示节点中所存储的数据类型 

template<class K,class T,class KeyofT>
class RBTree
{
	typedef RBNode<T> Node;
private:
    Node* _root;
};

那么第三个模板参数又是什么呢？

我们通过KeyofT实现仿函数，对其operator()运算符进行重载

struct MapKeyofT
		{
			const K& operator()(const pair<K, V>& kv)
			{
				return kv.first;
			}
		};
struct SetKeyofT
		{
			const K& operator()(const K& k)
			{
				return k;
			}
		};

 

如果是set，kot(data)取出来的就是key

如果是map，kot(data)取出来的就是pair<K,V>.first，也就是key的值

通过它我们可以在红黑树中实现key值的比较

map结构：

private:

		RBTree<K, pair<K,V>, MapKeyofT> _t;

 

set结构： 

private:
RBTree<K, K, SetKeyofT> _t;

 红黑树正向迭代器

 结构

template<class T, class Ref, class Ptr>
struct RBTreeIterator
{
	typedef RBNode<T> Node;
	typedef RBTreeIterator<T, Ref, Ptr> self;
	Node* _node;
	RBTreeIterator(Node* node)
		:_node(node)
	{

	}
};

operator*和operator-> 

 

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

operator++ 

++就是要寻找中序遍历的下一个值，如果寻找呢？

如果右子树为空，那么就找孩子是父亲左的那个祖先节点

如果右子树不为空，那么就找右子树的最左节点 

self& operator++()
	{
		if (_node->_right)
		{
			//找右子树的最左节点
			Node* min = _node->_right;
			while (min->_left)
			{
				min = min->_left;
			}
			_node = min;
		}
		else
		{
			//找孩子是父亲左的那个祖先节点
			Node* cur = _node;
			Node* parent = cur->_parent;//父亲可能不存在
			while (parent && parent->_right == cur)
			{
				cur = parent;
				parent = parent->_parent;
			}
			_node = parent;
		}
		return *this;
	}
	self operator++(int)
	{
		self tmp(*this);
		++(*this);
		return tmp;
	}

 

operator-- 

--的思路与++正好相反

如果左子树为空，那么就找孩子是父亲右的那个祖先节点

如果左子树不为空，那么就找左子树的最右节点 

self& operator--()
	{
		if (_node->_left)
		{
			//找左子树的最右节点
			Node* max = _node->_left;
			while (max->_right)
			{
				max = max->_right;
			}
			_node = max;
		}
		else
		{
			//找孩子是父亲右的那个祖先节点
			Node* cur = _node;
			Node* parent = cur->_parent;
			while (parent && parent->_left == cur)
			{
				cur = parent;
				parent = parent->_parent;
			}
			_node = parent;
		}
	}
	self operator--(int)
	{
		self tmp(*this);
		--(*this);
		return tmp;
	}

operator！=和==

 直接使用节点地址比较

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

红黑树反向迭代器 

template<class Iterator, class Ref, class Ptr>
class _reverse_iterator
{
public:
	typedef _reverse_iterator<Iterator, Ref, Ptr> self;
	_reverse_iterator(Iterator it)
		:_it(it)
	{}
	Ref operator*()
	{
		return *_it;
	}
	Ptr operator->()
	{
		return &(operator*());
	}
	bool operator==(const _reverse_iterator& rit)const
	{
		return _it == rit._it;
	}
	bool operator!=(const _reverse_iterator& rit)const
	{
		return _it != rit._it;
	}
	self& operator++()
	{
		--_it;
		return *this;
	}
	self operator++(int)
	{
		self tmp(*this);
		--_it;
		return tmp;
	}
	self& operator--()
	{
		_it++;
		return *this;
	}
	self operator--(int)
	{
		self tmp(*this);
		_it++;
		return tmp;
	}
private:
	Iterator _it;
};

红黑树封装源码

template<class K,class T,class KeyofT>
class RBTree
{
	typedef RBNode<T> Node;
public:
	typedef RBTreeIterator<T, T&, T*> iterator;
	typedef RBTreeIterator<T, const T&, const T*> const_iterator;
	typedef _reverse_iterator<iterator, T&, T*> reverse_iterator;
	typedef _reverse_iterator<const_iterator, const T&,const T*> const_reverse_iterator;
	reverse_iterator rbegin()
	{
		//寻找最右节点
		Node* max = _root;
		while (max && max->_right)
		{
			max = max->_right;
		}
		return reverse_iterator(iterator(max));
	}
	reverse_iterator rend()
	{
		return reverse_iterator(iterator(nullptr));
	}
	const_reverse_iterator rbegin()const
	{
		Node* max = _root;
		while (max && max->_right)
		{
			max = max->_right;
		}
		return const_reverse_iterator(const_iterator(max));
	}
	const_reverse_iterator rend()const
	{
		return const_reverse_iterator(const_iterator(nullptr));
	}
	iterator begin()
	{
		Node* min = _root;
		while (min&&min->_left)
		{
			min = min->_left;
		}
		return iterator(min);
	}
	iterator end()
	{
		return iterator(nullptr);
	}
	const_iterator begin()const
	{
		Node* min = _root;
		while (min&&min->_left)
		{
			min = min->_left;
		}
		return const_iterator(min);
	}
	const_iterator end()const
	{
		return const_iterator(nullptr);
	}
	RBTree()
		:_root(nullptr)
	{

	}
	RBTree(const RBTree<K, T, KeyofT>& t)
	{
		_root = Copy(t._root);
	}
	RBTree<K, T, KeyofT>& operator=(RBTree<K, T, KeyofT> t)
	{
		swap(_root, t._root);
		return *this;
	}
	~RBTree()
	{
		Destory(_root);
		_root = nullptr;
	}
	iterator 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 iterator(cur);
			}
		}
		return end();
	}
	const_iterator Find(const K& key)const
	{
		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 const_iterator(cur);
			}
		}
		return end();
	}
	pair<iterator,bool> Insert(const T& data)
	{
		if (_root == nullptr)
		{
			_root = new Node(data);
			_root->_col = BLACK;
			return make_pair(iterator(_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(iterator(cur), false);
			}
		}
		cur = new Node(data);
		Node* ret = cur;
		if (kot(parent->_data) < kot(data))
		{
			parent->_right = cur;
			cur->_parent = parent;
		}
		else
		{
			parent->_left = cur;
			cur->_parent = parent;
		}
		//开始调整
		while (parent && parent->_col==RED)//当父亲为红才需要调整
		{
			Node* grandfather = parent->_parent;//grandfather一定存在
			if (grandfather->_left == parent)
			{
				Node* uncle = grandfather->_right;
				//1.uncle存在且为红，p，u变黑，g变红，向上调整
				if (uncle && uncle->_col == RED)
				{
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;
					cur = grandfather;
					parent = cur->_parent;
				}
				//2.uncle不存在或为黑，此时进行旋转
				else
				{
					Node* uncle = grandfather->_right;
					//单纯左边高
					//     g
					//  p
					//cur
					//此时对g进行右旋，p变黑，g变红
					if (parent->_left == cur)
					{
						RoateR(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					//   g
					//p
					//   cur
					//此时先对p进行左旋，再对g进行右旋
					//cur变黑，g变红
					else
					{
						RoateL(parent);
						RoateR(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}
					break;
				}
			}
			else
			{
				Node* uncle = grandfather->_left;
				//1.uncle存在且为红，p，u变黑，g变红，向上调整
				if (uncle && uncle->_col == RED)
				{
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;
					cur = grandfather;
					parent = cur->_parent;
				}
				//2.uncle不存在或为黑
				else
				{
					//单纯右边高
					//   g
					//      p
					//        cur
					//对g进行左旋，g变红，p变黑
					if (parent->_right == cur)
					{
						RoateL(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					//
					//   g
					//      p
					//   cur
					// 此时先对p进行右旋，再对g进行左旋，cur变黑，g变红
					else
					{
						RoateR(parent);
						RoateL(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}
					break;
				}
			}
		}
		_root->_col = BLACK;
		return make_pair(iterator(ret), true);
	}
private:
	Node* Copy(Node* root)
	{
		if (root == nullptr)
		{
			return nullptr;
		}
		Node* newroot = new Node(root->_data);
		newroot->_left = Copy(root->_left);
		newroot->_right = Copy(root->_right);
		if (newroot->_left)
		{
			newroot->_left->_parent = newroot;
		}
		if (newroot->_right)
		{
			newroot->_right->_parent = newroot;
		}
		return newroot;
	}
	void Destory(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}
		Destory(root->_left);
		Destory(root->_right);
		delete root;
	}
	void RoateL(Node* parent)
	{
		//更改链接关系
		Node* parentparent = parent->_parent;
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
		parent->_right = subRL;
		if (subRL)
		{
			subRL->_parent = parent;
		}
		subR->_left = parent;
		parent->_parent = subR;
		if (parentparent == nullptr)
		{
			_root = subR;
			subR->_parent = nullptr;
		}
		else
		{
			if (parentparent->_left == parent)
			{
				parentparent->_left = subR;
				subR->_parent = parentparent;
			}
			else
			{
				parentparent->_right = subR;
				subR->_parent = parentparent;
			}
		}
	}
	void RoateR(Node* parent)
	{
		//更改链接关系
		Node* parentparent = parent->_parent;
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		parent->_left = subLR;
		if (subLR)
		{
			subLR->_parent = parent;
		}
		subL->_right = parent;
		parent->_parent = subL;
		if (parentparent == nullptr)
		{
			_root = subL;
			subL->_parent = nullptr;
		}
		else
		{
			if (parentparent->_left == parent)
			{
				parentparent->_left = subL;
				subL->_parent = parentparent;
			}
			else
			{
				parentparent->_right = subL;
				subL->_parent = parentparent;
			}
		}
	}
	Node* _root;
};

map封装源码

 

template<class K,class V>
	class map
	{
	public:
		struct MapKeyofT
		{
			const K& operator()(const pair<K, V>& kv)
			{
				return kv.first;
			}
		};
		typedef typename RBTree<K, pair<K, V>, MapKeyofT>::iterator iterator;
		typedef typename RBTree<K, pair<K, V>, MapKeyofT>::const_iterator const_iterator;
		typedef typename RBTree<K, pair<K, V>, MapKeyofT>::reverse_iterator reverse_iterator;
		typedef typename RBTree<K, pair<K, V>, MapKeyofT>::const_reverse_iterator const_reverse_iterator;
		reverse_iterator rbegin()
		{
			return reverse_iterator(end());
		}
		reverse_iterator rend()
		{
			return reverse_iterator(begin());
		}
		const_reverse_iterator rbegin()const
		{
			return const_reverse_iterator(end());
		}
		const_reverse_iterator rend()const
		{
			return const_reverse_iterator(begin());
		}
		iterator begin()
		{
			return _t.begin();
		}
		iterator end()
		{
			return _t.end();
		}
		const_iterator begin()const
		{
			return _t.begin();
		}
		const_iterator end()const
		{
			return _t.end();
		}
		pair<iterator,bool> insert(const pair<K,V> kv)
		{
			return _t.Insert(kv);
		}
		V& operator[](const K& key)
		{
			auto ret = _t.Insert(make_pair(key, V()));
			return ret.first->second;
		}
		iterator Find(const K& key)
		{
			return _t.Find(key);
		}
		const_iterator Find(const K& key)const
		{
			return _t.Find(key);
		}
	private:

		RBTree<K, pair<K,V>, MapKeyofT> _t;
	};

set封装源码

set的key值不能改变，所以使用const_iterator作为set的iterator 

template<class K>
	class set
	{
	public:
		struct SetKeyofT
		{
			const K& operator()(const K& k)
			{
				return k;
			}
		};
		typedef typename RBTree<K, K, SetKeyofT>::const_iterator iterator;
		typedef typename RBTree<K, K, SetKeyofT>::const_reverse_iterator reverse_iterator;
		reverse_iterator rbegin()const
		{
			return _t.rbegin();
			
		}
		reverse_iterator rend()const
		{
			return _t.rend();
		}
		iterator begin()const
		{
			return _t.begin();
		}
		iterator end()const
		{
			return _t.end();
		}
		pair<iterator, bool> Insert(const K& key)
		{
			auto ret= _t.Insert(key);
			return pair<iterator, bool>(iterator(ret.first._node), ret.second);
		}
		iterator Find(const K& key)const
		{
			return _t.Find(key);
			
		}
	private:
		RBTree<K, K, SetKeyofT> _t;
	};

 

 

嚞譶
关注
  • 5
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
【C++】红黑树详解并封装实现map和set
love_guanghui的博客
03-18 2738
红黑树详解
使用红黑树封装map和set
qq_47406941的博客
06-07 774
红黑树和AVL树都是二叉搜索树，但是从效率以及实现方式等方面综合来看，红黑树比AVL树更优。也就是说，红黑树是一种更好的，适合搜索的数据结构。同时，红黑树的使用方面非常广泛，Java库、linux内核、c++ST ...
C++红黑树模拟实现map和set
~
04-01 3904
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模
红黑树封装set和map
唐学长的博客
06-12 146
红黑树封装set和map
红黑树实现map、set基本功能
qq_52145272的博客
06-27 269
了解使用红黑树封装形成map、set的基本过程
【C++】红黑树封装实现map和set
The porters of knowledge
04-01 1004
用一棵红黑树封装map和set，set表层迭代器底层均为红黑树的const迭代器，实现map的[ ]重载……
用同一棵红黑树实现map和set【STL】
Man9o
11-25 553
反向迭代器的成员变量是一个正向迭代器，而它接收的模板参数是一个正向迭代器（被typedef的iterator），但是在正向迭代器的实现中，它能接收三种类型参数，即，但是反向迭代器不知道传入的结点是引用还是指针类型，所以还需要再正向迭代器的实现中对引用和指针类型再定义迭代器类型。// 结点指针 typedef Ref reference;// 结点指针的引用// 结点指针的引用 typedef typename iterator :: pointer Ptr;// 结点指针。
C++STL详解(九)--使用红黑树封装实现set和map
清欢Allen的技术博客
04-19 628
如果我们用一棵KV模型的红黑树同时实现map和set,我们就需要控制map和set中的所传入红黑树中的模板参数,其中,封装过程中,为了与红黑树的模板参数区分,我们将红黑树中模板参数由V改成T.在插入中,结点中存储的类型T可能为Set容器中的key,也有可能是Map中的pair键值对,底层红黑树如何针对不同类型的容器进行比较呢?所以,当容器为set时,红黑树中的仿函数就实例化为set容器中的仿函数,当容器为map时,红黑树中的仿函数就实例化为map中的仿函数.正向迭代器还包括了==,!
红黑树+红黑树模拟实现map/set
cxy_zjt的博客
11-07 617
红黑树 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
【 C++ 】用一颗红黑树封装map和set
bit_zyx的博客
09-04 364
目录 1、前言 2、红黑树模板参数的控制 3、模板参数中仿函数的增加 4、红黑树迭代器的实现 5、红黑树的begin()和end() 6、红黑树的Find查找函数 7、红黑树源码链接 8、set的代码 9、map的代码
红黑树封装实现map和set
06-20
封装红黑树实现map和set解决方案
红黑树封装map&&set源代码
06-01
5. **接口封装**：将红黑树的内部实现包装在`Map`或`Set`接口下，提供如`put`、`get`、`remove`、`containsKey`等方法，使得用户可以按照标准的Map或Set接口进行操作。 6. **遍历方法**：实现`iterator`方法，用于...
map和set的模拟实现
06-06
本文将深入探讨如何通过封装红黑树来模拟实现Map和Set。 红黑树是一种自平衡二叉查找树，它的主要特性是每个节点都带有颜色属性（红色或黑色），并且遵循以下性质： 1. 每个节点要么是黑色，要么是红色。 2. 根节点...
c++容器list、vector、map、set区别与用法详解
08-19
map容器是一个基于红黑树的平衡检索二叉树，存储结构为键值对,value>。map容器的特点是： * 采用平衡检索二叉树，存储结构为键值对,value>。 * 支持快速查找、插入和删除元素。 * 查找、插入和删除元素的时间复杂度...
STL.rar_hash stl_stl 封装_搜索树
09-24
在STL中，搜索树主要通过`<set>`和`<map>`容器实现，它们基于红黑树这一自平衡二叉查找树。`<set>`用于存储唯一整数，而`<map>`则用于存储键值对，两者都支持快速的查找、插入和删除操作，其时间复杂度通常为O(log ...
数据结构(5.3_3)——由遍历序列构造二叉树
m0_65240792的博客
07-25 162
若只给出一棵二叉树的前/中/后/层 序遍历序列中的一种，不能唯一确定一棵二叉树 例：前序遍历序列：DAEFBCHGI 中序遍历序列：DAEFBCHGI
学习记录day19——数据结构 查找算法
最新发布
weixin_64918301的博客
07-25 213
在给定数据元素的某个值，在查找表中确定一个其关键字等于给定值的数据元素的操作，叫做查找。
数据结构---二叉树
weixin_47808575的博客
07-22 292
参考：二叉树遍历方法——前、中、后序遍历（图解）_二叉树遍历前序中序后序-CSDN博客
数据结构——二叉树性质
鲸落博客
07-23 412
这个性质很好记忆，观察一下图6-5-5。第一层是根结点，只有一个，所以2^(1-1)=2^0=1。第二层有两个，2^(2-1)=2=2。第三层有四个，2^(3-1)=2^2=4。第四层有八个，2^(4-1)=2^3=8。通过数据归纳法的论证，可以很容易得出在二叉树的第i层上至多有2^(i-1)个结点(i≥1)的结论。
c++stl中红黑树的实现
09-14
在C++ STL中，红黑树的实现被封装在`std::map`和`std::set`这两个容器类中。这两个容器类都是基于红黑树实现的，它们提供了高效的查找、插入和删除操作，保证了元素的有序性。 STL中的红黑树实现与你提供的C++代码...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

嚞譶

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

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

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

打赏作者

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

抵扣说明：

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

余额充值