用一棵红黑树同时封装出set和map

最新推荐文章于 2023-01-27 09:55:49 发布
最新推荐文章于 2023-01-27 09:55:49 发布
阅读量1.3k 收藏 11
点赞数 47
分类专栏： C++从初阶到进阶 文章标签： c++ map set
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45599288/article/details/122621870
版权

一棵红黑树同时封装set和map

🔒快速导航和本篇相关的文章🔒

set和map的基本使用点击直达文章
红黑树点击直达文章

红黑树代码

我们要对KV模型的红黑树进行封装，模拟实现set和map,用到的代码如下

#include<iostream>
using namespace std;

enum Color
{
	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;
	Color _color;//该结点的颜色
	RBTreeNode(const pair<K,V>& kv)
		:_left(nullptr)
		,_right(nullptr)
		,_parent(nullptr)
		,_kv(kv)
		,_color(RED)
	{}
};
template<class K, class V>
class RBTree
{
	typedef RBTreeNode<K, V> Node;
public:
	RBTree()
		:_root(nullptr)
	{}

	pair<Node*, bool> insert(const pair<K, V>& kv)
	{
		//1.树为空
		if (_root == nullptr)
		{
			_root = new Node(kv);
			_root->_color = BLACK;//根结点为黑色
			return make_pair(_root, true);
		}
		//树不为空
		Node* cur = _root;
		Node* parent = nullptr;
		while (cur)
		{
			//新结点key大于当前结点往右边
			if (cur->_kv.first < kv.first)
			{
				parent = cur;
				cur = cur->_right;
			}
			//新结点key小于当前结点往左边
			else if (cur->_kv.first > kv.first)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return make_pair(cur, false);
			}
		}
		cur = new Node(kv);
		Node* newnode = cur;
		newnode->_color = RED;
		if (parent->_kv.first < kv.first)
		{
			parent->_right = newnode;
			newnode->_parent = parent;
		}
		else
		{
			parent->_left = newnode;
			newnode->_parent = parent;
		}

		//开始调整颜色
		//父亲存在且为红
		while (parent && parent->_color == RED)
		{
			Node* grandParent = parent->_parent;		
			//parent是grandParent左孩子
			if (grandParent->_left == parent)
			{
				Node* uncle = grandParent->_right;
				//叔叔存在且为红色,父亲和叔叔都调为黑色
				//祖先调为红色，如果不调那每条路径的黑结点变了
				if (uncle && uncle->_color == RED)
				{
					parent->_color = BLACK;
					uncle->_color = BLACK;
					grandParent->_color = RED;
					//继续往上调
					cur = grandParent;
					parent = cur->_parent;
				}
				else//叔叔不存在或叔叔存在且为黑
				{
					if (parent->_left == cur)
					{    //右单旋
						RotateR(grandParent);
						parent->_color = BLACK;
						grandParent->_color = RED;
					}
					else //parent->_right == cur
					{
						RotateL(parent);
						RotateR(grandParent);
						grandParent->_color = RED;
						cur->_color = BLACK;
					}
					break;
				}
			}
			else //parent是grandParent左孩子
			{
				Node* uncle = grandParent->_left;
				if (uncle && uncle->_color == RED)
				{
					uncle->_color = BLACK;
					parent->_color = BLACK;
					grandParent->_color = RED;
					cur = grandParent;
					parent = cur->_parent;
				}
				else
				{
					if (parent->_right == cur)
					{
						RotateL(grandParent);
						parent->_color = BLACK;
						grandParent->_color = RED;
					}
					else
					{
						RotateR(parent);
						RotateL(grandParent);
						cur->_color = BLACK;
						grandParent->_color = RED;
					}
					break;
				}	
			}
		}
		_root->_color = BLACK;
		return make_pair(newnode, true);
	}
	void RotateL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
		Node* parentParent = parent->_parent;
		//先旋转
		parent->_right = subRL;
		subR->_left = parent;

		parent->_parent = subR;
		//在改父亲结点
		if (subRL)
			subRL->_parent = parent;
		if (_root == parent)
		{
			_root = subR;
			_root->_parent = nullptr;
		}

		else
		{
			//subR旋转后可能是左右子树2种情况
			if (parentParent->_left == parent)
				parentParent->_left = subR;
			else
				parentParent->_right = subR;
			subR->_parent = parentParent;
		}
	}
	void RotateR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		Node* parentParent = parent->_parent;//记录parent的父亲结点
		//subLR做parent->_left
		parent->_left = subLR;
		subL->_right = parent;
		//同时更新动的2个节点的parent
		//注意subLR还可能是空结点
		if (subLR)
			subLR->_parent = parent;
		parent->_parent = subL;
		//parent可能是单独的树，或者子树,分情况
		if (_root == parent)
		{
			_root = subL;
			_root->_parent = nullptr;
		}

		else
		{
			//还有可能parent是子树，可能是左子树
			if (parentParent->_left == parent)
				parentParent->_left = subL;
			else
				//也可能是右子树
				parentParent->_right = subL;
			//调整subL的父亲结点
			subL->_parent = parentParent;
		}
	}
	void Destory(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}

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

	~RBTree()
	{
		Destory(_root);
		_root = nullptr;
	}

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

		return nullptr;
	}
private:
	Node* _root;
};

红黑树的模板参数

通过前面set和map的使用后我们知道set是K模型的，map是KV模型的，那要怎么用一棵红黑树实现set和map呢？

set容器，它传入底层红黑树的模板参数就是Key和Key:

template<class K>
class set
{	
public:
//...			
private:
	RBTree<K, K> _t;
};

map容器传入就是Key和键值对：

template<class K, class V>
class set
{	
public:
//...			
private:
	RBTree<K, pair<K,V> _t;
};

所以我们的红黑树原来的模板参数由V变成T。

template<class K, class T>
class RBTree
{}

红黑树能不能不要第一个模板参数，答案是不能的。

对于set容器是没有问题的，它的2个参数都是Key。但是map就行了，map的find和erase接口只提供Key的，没有第一个模板参数就出问题了。

红黑树结点的数据存储

我们可以先看看源码是怎么实现的：
在这里插入图片描述
我们可以看到源码中结点是存了Value。set的key,key传给了Key和value_type,而map的Key和pair<>传给了value_type。Value中是Key那结点中存的就是Key，是pair那结点中存的就是pair。
那我们自己实现就用T即可。

更新后的代码：

enum Color
{
	RED,
	BLACK
};
template<class T>
struct RBTreeNode
{
	RBTreeNode<T>* _left;//结点的左孩子
	RBTreeNode<T>* _right;//结点的右孩子
	RBTreeNode<T>* _parent;//结点的双亲		
	T _data;//存储的数据
	Color _color;//该结点的颜色
	RBTreeNode(const T& x)
		:_left(nullptr)
		,_right(nullptr)
		,_parent(nullptr)
		,_data(x)
		,_color(RED)
	{}
};

这样就不用管你是K还是KV，你是啥我就是啥了。

仿函数的增加

还有问题没有解决，红黑树中T存的可能是K，也可能是pair<>。那我们插入的时候该怎么比较结点的大小呢？对于set是没有问题的，直接可以用T比较，但是map就不行了，我们要取出pair<>的first来进行比较。这是就要实现一个仿函数。

仿函数就是重载了operator(),这个类就可像函数一样的使用了。

template<class K, class V>
class map
{
  struct MapKeyOfT
 {
	const K& operator()(const pair<const K, V>& kv)
		{
			return kv.first;
		}
 };
private:
	RBTree<K,pair<const K, V>, MapKeyOfT> _t;
  };
}

但是底层的红黑树不知道是Key还是pair<>,所以红黑树都会通过仿函数来获取Key值来进行比较。所以set也需要增加仿函数。对于set好像多此一举但是底层的红黑树不知道啊，所以仿函数必不可少。

template<class K>
class set
{
	struct SetKeyOfT
	{
	  const K& operator()(const K& key)
		{
			return key;
		}
};
private:
	RBTree<K, K, SetKeyOfT> _t;
  };
}

set传入底层就是set的仿函数，map传入底层就是map的仿函数。
在这里插入图片描述

正向迭代器的实现

迭代器就是对一个结点的指针进行了封装，里面只有一个成员变量，就是结点的指针。

template<class T,class Ref,class Ptr>
struct _TreeIterator
{
	typedef RBTreeNode<T> Node;//结点的类型
	typedef _TreeIterator<T, Ref, Ptr> Self;//正向迭代器的类型
	Node* _node;//封装的指针
};

所以我们通过一个结点的指针就可以构造出一个迭代器

    //构造函数
	_TreeIterator(Node* node)
		:_node(node)
	{}

当迭代器解引用操作，我们就返回结点数据的引用

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

当迭代器进行->操作，我们就返回结点数据的指针

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

还需要实现==和!=来判断结点是不是同一个。

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

operator++

重头戏就是实现++。
在这里插入图片描述

红黑树中的迭代器的begin和end:

  • begin返回中序的第1个结点的迭代器，就是最左结点
  • end返回中序最后一个结点的下一个位置的迭代器，这里就用空指针即可。
template<class K, class T, class KeyOfT>
class RBTree
{
	typedef RBTreeNode<T> Node;
public:
	RBTree()
		:_root(nullptr)
	{}
	typedef _TreeIterator<T, T&, T*> iterator;
	
	iterator begin()
	{
		Node* left = _root;
		while (left && left->_left)
		{
			left = left->_left;
		}

		return iterator(left);
	}

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

我们进行++就是找到中序的下一个结点，具体逻辑如下：

1.当前结点的右子树不为空，那么++就要找到右子树的最左结点
2.当前结点的右子树为空，++则要找孩子不在父亲右的那个祖先

	Self& operator++()
	{
		if (_node->_right)
		{
			// 下一个访问就是右树中，中序的第一个节点
			Node* left = _node->_right;
			while (left->_left)
			{
			    left = left->_left;
			}
				_node = left;//++后变成该结点
			}
			else  //右子树为空
			{ 
		        //找孩子不在父亲右的祖先
				Node* cur = _node;
				Node* parent = cur->_parent;
				while (parent && cur == parent->_right)
				{
					cur = cur->_parent;
					parent = parent->_parent;
				}
				_node = parent;//++后变成该结点
			}
		return *this;
	}

operator–

一个结点的正向迭代器进行--操作后，就是红黑树中序遍历找到的结点的前一个结点。也就是跟++反过来。
具体逻辑如下：
1.当前结点的左子树不为空，--后找到左子树中的最右结点
2.当前结点的左子树为空，--找到孩子不在父亲左的祖先

Self& operator--()
	{
		if (_node->_left)
		{
			// 下一个访问就是右树中，中序的第一个节点
			Node* left = _node->_left;
			while (right->_right)
			{
				right = right->_right;
			}
			_node = right;
		}
		else
		{
			Node* cur = _node;
			Node* parent = cur->_parent;
			while (parent && cur == parent->_left)
			{
				cur = cur->_parent;
				parent = parent->_parent;
			}
			_node = parent;
		}
		return *this;
	}

封装后的set和map

set的代码

下面就可以直接调用红黑树的插入，查找了。博主没有实现红黑树的删除。

namespace p
{
	template<class K>
	class set
	{
		struct SetKeyOfT
		{
			const K& operator()(const K& key)
			{
				return key;
			}
		};
	public:
		typedef typename RBTree<K, K, SetKeyOfT> ::iterator iterator;
		iterator begin()
		{
			return _t.begin();
		}
		iterator end()
		{
			return _t.end();
		}
		//插入
		bool insert(const K& k)
		{
			_t.insert(k);
			return true;
		}
		//查找
		iterator find(const K& k)
		{
			return _t.Find(key);
		}
	private:
		RBTree<K, K, SetKeyOfT> _t;
	};
}

map的代码

namespace g
{
	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>::iterator iterator;
		iterator begin()
		{
			return _t.begin();
		}
		iterator end()
		{
			return _t.end();
		}
		//插入
		pair<iterator,bool> insert(const pair<const K, V>& kv)
		{
			return _t.insert(kv);
		}
		//operator[]
		V& operator[](const K& key)
		{
			pair<iterator, bool> ret = Insert(make_pair(key, V()));
			iterator it = ret.first;
			return it->second;
		}
        //查找
		iterator find(const K& k)
		{
			return _t.Find(key);
		}
	private:
		RBTree<K,pair<const K, V>, MapKeyOfT> _t;
	};
}

封装的红黑树代码点击即可

测试set和map的迭代器

这里博主只测试迭代器

void Test_set()
{
    p::set<int> s;
    s.insert(1);
    s.insert(10);
    s.insert(5);
    s.insert(20);
    s.insert(1);
    p::set<int>::iterator it = s.begin();
    while (it != s.end())
    {
        cout << *it << " ";
        ++it;
    }
    cout << endl;
}

在这里插入图片描述
map的迭代器测试：
在这里插入图片描述
模拟实现并不是要自己造轮子，可以更深的知道底层结构，以后在用的时候会得心应手。本篇博客到就结束了。

_End丶断弦
关注
  • 47
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 49
    评论
专栏目录
使用红黑树封装map和set
qq_47406941的博客
06-07 772
红黑树和AVL树都是二叉搜索树，但是从效率以及实现方式等方面综合来看，红黑树比AVL树更优。也就是说，红黑树是一种更好的，适合搜索的数据结构。同时，红黑树的使用方面非常广泛，Java库、linux内核、c++ST ...
C++_用红黑树实现关联容器map和set
hello呀！
08-21 317
template <class K,class V> class Map { private: struct MapKeyOfValue { const K& operator()(const pair<K, V>& data) { return data.first; } }; public: typedef typename ...
STL关联式容器之红黑树
handsomeKyne
07-12 1405
这一节我们来学习红黑树，如果你能够自己实现一个红黑树，那么对它的理解将会更加深刻。 1、树的总览 根节点到任何节点之间有一条唯一路径。 路径长度：指路径所经过的边数。 节点的深度：根节点至该节点的路径长度。根节点的深度为0。 节点的高度：该节点到其最深叶节点的高度。根节点的高度最大。 注意高度和深度的区别。可以这么理解，高度是向上变大的，而深度是向下变大的。 节点大小：该节点所有子代
C++面试题集锦
qq_34501451的博客
10-14 825
引用和指针的区别？ 指针是一个实体，需要分配内存空间。引用只是变量的别名，不需要分配内存空间。 引用在定义的时候必须进行初始化，并且不能够改变。指针在定义的时候不一定要初始化，并且指向的空间可变。（注：不能有引用的值不能为NULL） 有多级指针，但是没有多级引用，只能有一级引用。 指针和引用的自增运算结果不一样。（指针是指向下一个空间，引用时引用的变量值加1） siz...
STL关联容器-红黑树
常思考->有目标->重实践->善反思
07-01 956
关联式容器分为set(集合）和map(映射)两大类，以及这两大类衍生体multiset(多键集合)和multimap（多键映射）。这些容器的底层机制均以RB-tree（红黑树）完成。RB-tree是一个独立的容器，并不开放给外界使用。 此外SGI STL还提供了一个不再标准规格之列的关联式容器：hash table(散列表)，以及以此hash table为底层机制而完成的hash_set(散列集...
红黑树封装实现map和set
06-20
封装红黑树实现map和set解决方案
红黑树封装map&&set源代码
06-01
通过理解红黑树的工作原理，并结合上述关键部分，我们可以构建出自己的红黑树封装的Map和Set实现。这样的实现有助于深入理解数据结构和算法，同时也可以用于学习和教学目的。在实际开发中，直接使用Java提供的`...
map和set的模拟实现
最新发布
06-06
在IT领域，数据结构是编程的基础，...总之，通过封装红黑树并结合C++的面向对象特性，我们可以构建出高性能的Map和Set模拟实现。这不仅可以加深对数据结构和算法的理解，也有助于在实际项目中构建高效的数据处理机制。
c++容器list、vector、map、set区别与用法详解
12-17
c++容器list、vector、map、set区别 list 封装链表，以链表形式实现，不支持[]运算符。 对随机访问的速度很慢(需要遍历整个链表)，插入数据很快(不需要拷贝和移动数据，只需改变指针的指向)。 新添加的元素，...
【C++】-- STL之用红黑树模拟实现map和set
局部变量和全局变量
09-08 1020
用红黑树同时封装出set和map时，set传给value的是一个value，map传给value的是一个pair，set和map传给红黑树的value决定了这棵树里面存的节点值类型。上层容器不同，底层红黑树的Key和T也不同。
STL—— 用一棵红黑树同时封装出map和set
裙下的霸气的博客
01-27 545
STL——红黑树封装....
13 set和map以及用红黑树模拟实现set和map
精致的灰的博客
01-13 653
文章目录序列容器和关联式容器树形结构与哈希结构setset的成员函数构造方法set当中常用的成员函数multisetmapmap的成员函数构造方法map的插入insertmap的查找findmap的删除erasemap的[ ]运算符重载map的其他成员函数统计出现次数的三种方式对统计的次数进行排序multimap用红黑树模拟实现map和set参数的控制使用仿函数比较参数大小迭代器的实现 序列容器和关联式容器 C++STL中的部分容器，比如：vector、list、deque、forward_list(C+
红黑树封装实现树形结构的关联式容器（map，set）
qq_50408340的博客
06-13 184
目录红黑树的改造节点问题插入问题迭代器红黑树的迭代器改造红黑树map简单模拟set简单模拟 红黑树的改造 节点问题 map和set不同，map存放的是pair<K,V>键值对，而set中只有Key，我们要对红黑树节点进行改造，是她既能存放键值对，又能存放K值。 改造的节点结构体如下 template<class T> struct tree { tree<T> *left; tree<T> *right; tree<T> *parent;
数据结构学习——RBT（红黑树）以及实现Map和Set
现从事游戏开发领域 | 团队项目be_with开发进行中 web方向感兴趣者私 ——We can do all things.
06-27 1005
       我们知道，二叉搜索树是个很好的数据结构，可以快速地找到一个给定关键字的数据项，并且可以快速地插入和删除数据项。但是二叉搜索树有个很麻烦的问题，如果树中插入的是随机数据，则执行效果很好，但如果插入的是有序或者逆序的数据，那么二叉搜索树的执行速度就变得很慢。因为当插入数值有序时，二叉树就是非平衡的了，排在一条线上，其实...
C++红黑树模拟实现map和set
~
04-01 3901
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模
map和set有什么区别，分别又是怎么实现的？
热门推荐
qq_41007781的博客
06-25 1万+
map和set都是C++的关联容器，***其底层实现都是红黑树（***RB-Tree）。由于 map 和set所开放的各种操作接口，RB-tree 也都提供了，所以几乎所有的 map 和set的操作行为，都只是转调 RB-tree 的操作行为。 map和set区别在于： （1）map中的元素是key-value（关键字—值）对：关键字起到索引的作用，值则表示与索引相关联的数据；Set与之相对就是关...
用红黑树模拟实现map和set
qq_57283958的博客
05-22 357
今天我们用红黑树来模拟实现map和set，我们可以参考STL源码，不用自己造轮子。 一下是STL源码中的片段，它定义节点的颜色是用const的全局变量，同样需要三个指针left,right,parent.还用了一个继承，我也不知道大佬当时是怎么想的，其实不用继承也是一样可以搞，那么我们模拟实现就不搞继承了。大佬当时可能是出于某种原因吧。 typedef bool __rb_tree_color_type; const __rb_tree_color_type __rb_tree_red = fa.
17.集合Set,HashSet,TreeSet及其底层实现HashMap和红黑树;Collection总结
kazei2073的博客
03-30 4491
ONE.Set集合 one.Set集合的特点 无序,唯一 TWO.HashSet集合 1.底层数据结构是哈希表(是一个元素为链表的数组) 2.那么HashSet如何来实现元素的唯一性的呢？ 通过一HashSet添加字符串的案例查看HashSet中add()的源码，看为什么相同的字符串没有被加入HashSet中 interface Collection { ... } int...
c++stl中红黑树的实现
09-14
在C++ STL中，红黑树的实现被封装在`std::map`和`std::set`这两个容器类中。这两个容器类都是基于红黑树实现的，它们提供了高效的查找、插入和删除操作，保证了元素的有序性。 STL中的红黑树实现与你提供的C++代码...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 49
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

_End丶断弦

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

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

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

打赏作者

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

抵扣说明：

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

余额充值