map和set的封装

已于 2024-04-21 16:53:27 修改
阅读量900 收藏 6
点赞数 21
文章标签： c++ 算法 数据结构
于 2024-04-21 15:27:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_75132460/article/details/137878712
版权
本文详细探讨了红黑树在C++Map和Set中的底层实现，包括泛型模板、迭代器的定义和操作、比较仿函数的应用以及读写权限的设计。重点讲解了如何使用红黑树实现Map的插入操作和Set的读写限制。
摘要由CSDN通过智能技术生成

文章目录

一. 底层原理

我们要知道：Map和Set的底层是由红黑树封装的；
红黑树的底层是：KV结构

泛型：RBTree.h

在这里插入图片描述

map

在这里插入图片描述

set

在这里插入图片描述
看到这里大家一定会对模板中的MapKeyOfT有一定的疑惑吧！下面就让我们了解一下；

二. 比较仿函数

问题：Insert()中结点的插入（由于搜索树左边大，右边小的原因）所以会出现比较；
在这里插入图片描述
** 解决方法：**
使用使用仿函数去除首元素进行比较；
在这里插入图片描述
应用：
在这里插入图片描述

四.迭代器

迭代器的普通迭代器和const迭代器这里使用模板类解决：
将使用到const迭代器和迭代器重叠的部分使用类模板参数来代替；
这里可以可以看下面的迭代器定义中的Ref和Ptr；ref是引用的意思；ptr是指针的意思；
在这里插入图片描述

4.1、迭代器的定义：

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;
	Node* _node;
 
	__RBTreeIterator(Node*node)
		:_node(node)
	{}
 
	//普通迭代器的时候，它是拷贝构造
	//const迭代器的时候，它是构造，支持用普通迭代器构造const迭代器
	__RBTreeIterator(const iterator& s)
		:_node(s._node)
	{}
}

4.2、*:解引用操作

返回对应结点数据的引用:

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

4.3、->:成员访问操作符

返回结点数据的引用：


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

4.4、!=、==

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

4.5 ++

++it的核心：找中序的下一个；
规律
1.it指向的结点，右子树不为空，下一个就是右子树的最左结点；
2.it指向的结点，右子树为空，则it的结点所在的右子树放问完了，往上找某个结点是其父节点的左结点；
代码实现：

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

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

			_node = parent;
		}

		return *this;
	}

应用
在这里插入图片描述

4.5 【】（该功能只有在map类中可以实现）

代码的前的修改
在这里插入图片描述
代码：

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

4.6！=

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

4.7.如何实现set和map的读写权限

set只有读权限，没有写的权限；
map有读和写的权限，但是写的权限仅仅在second上，first没有写的权限；
如何实现：
方法：将set类内的普通迭代器和const迭代器都用rbtree中的const_interator来定义；
map正常定义，但是使用rbtree模板时，将数据传为pair<const k，v>这样first就无法改变了；
map：
在这里插入图片描述
set：
在这里插入图片描述

五.完整代码：

RBTree

#pragma once

// set ->key
// map ->key/value

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

	Self& operator--();

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

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

			_node = parent;
		}

		return *this;
	}

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

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

// set->RBTree<K, K, SetKeyOfT> _t;
// map->RBTree<K, pair<const K, T>, MapKeyOfT> _t;
template<class K, class T, class KeyOfT>
class RBTree
{
	typedef RBTreeNode<T> Node;
public:
	typedef __TreeIterator<T, T&, T*> iterator;
	typedef __TreeIterator<T, const T&, const T*> const_iterator;

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

		return iterator(cur);
	}

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

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

		return const_iterator(cur);
	}

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

	//pair<iterator, bool> Insert(const T& data)
	pair<Node*, bool> Insert(const T& data)
	{
		if (_root == nullptr)
		{
			_root = new Node(data);
			_root->_col = BLACK;
			return make_pair(_root, true);
		}

		Node* parent = nullptr;
		Node* cur = _root;
		KeyOfT kot;

		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(cur, false);
			}
		}

		// 新增节点给红色
		cur = new Node(data);
		Node* newnode = cur;
		cur->_col = RED;
		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;
			if (parent == grandfather->_left)
			{
				//     g
				//   p   u
				// c
				Node* uncle = grandfather->_right;
				if (uncle && uncle->_col == RED)
				{
					// 变色
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;

					// 继续往上更新处理
					cur = grandfather;
					parent = cur->_parent;
				}
				else
				{
					if (cur == parent->_left)
					{    
						// 单旋
						//     g
						//   p
						// c
						RotateR(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else
					{
						// 双旋
						//     g
						//   p
						//     c
						RotateL(parent);
						RotateR(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}

					break;
				}
			}
			else  // parent == grandfather->_right
			{
				//     g
				//   u   p 
				//          c
				//
				Node* uncle = grandfather->_left;
				if (uncle && uncle->_col == RED)
				{
					// 变色
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;

					// 继续往上处理
					cur = grandfather;
					parent = cur->_parent;
				}
				else
				{
					if (cur == parent->_right)
					{
						RotateL(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else
					{
						//     g
						//   u   p 
						//     c
						//
						RotateR(parent);
						RotateL(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}

					break;
				}
			}
		}

		_root->_col = BLACK;

		return make_pair(newnode, true);
	}

	iterator Find(const K& key)
	{
		//...

		return end();
	}

	void RotateL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;

		parent->_right = subRL;
		subR->_left = parent;

		Node* parentParent = parent->_parent;

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

		if (_root == parent)
		{
			_root = subR;
			subR->_parent = nullptr;
		}
		else
		{
			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;

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

		Node* parentParent = parent->_parent;

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

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

			subL->_parent = parentParent;
		}
	}

	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}

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

		_InOrder(root->_left);
		cout << root->_kv.first << " ";
		_InOrder(root->_right);
	}

	// 根节点->当前节点这条路径的黑色节点的数量
	bool Check(Node* root, int blacknum, const int refVal)
	{
		if (root == nullptr)
		{
			//cout << balcknum << endl;
			if (blacknum != refVal)
			{
				cout << "存在黑色节点数量不相等的路径" << endl;
				return false;
			}

			return true;
		}

		if (root->_col == RED && root->_parent->_col == RED)
		{
			cout << "有连续的红色节点" << endl;

			return false;
		}

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

		return Check(root->_left, blacknum, refVal)
			&& Check(root->_right, blacknum, refVal);
	}

	bool IsBalance()
	{
		if (_root == nullptr)
			return true;

		if (_root->_col == RED)
			return false;

		//参考值
		int refVal = 0;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_col == BLACK)
			{
				++refVal;
			}

			cur = cur->_left;
		}

		int blacknum = 0;
		return Check(_root, blacknum, refVal);
	}

	int Height()
	{
		return _Height(_root);
	}

	int _Height(Node* root)
	{
		if (root == nullptr)
			return 0;

		int leftHeight = _Height(root->_left);
		int rightHeight = _Height(root->_right);

		return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
	}

	size_t Size()
	{
		return _Size(_root);
	}

	size_t _Size(Node* root)
	{
		if (root == NULL)
			return 0;

		return _Size(root->_left)
			+ _Size(root->_right) + 1;
	}

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

		return NULL;
	}

private:
	Node* _root = nullptr;
};

myset.h

#pragma once
#include"RBTree.h"

namespace bit
{
	template<class K>
	class set
	{
	public:
		struct SetKeyOfT
		{
			const K& operator()(const K& key)
			{
				return key;
			}
		};

		typedef typename RBTree<K, K, SetKeyOfT>::const_iterator iterator;
		typedef typename RBTree<K, K, SetKeyOfT>::const_iterator const_iterator;


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

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

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

	private:
		RBTree<K, K, SetKeyOfT> _t;
	};
}

mymap.h

#pragma once
#include"RBTree.h"

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

		// 对类模板取内嵌类型，加typename告诉编译器这里是类型
		typedef typename RBTree<K, pair<const K, V>, MapKeyOfT>::iterator iterator;
		typedef typename RBTree<K, pair<const K, V>, MapKeyOfT>::const_iterator const_iterator;


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

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

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

		pair<iterator, bool> insert(const pair<K, V>& kv)
		{
			return _t.Insert(kv);
		}
	private:
		RBTree<K, pair<const K, V>, MapKeyOfT> _t;
	};
}
嘉城401
关注
  • 21
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
map和set的模拟实现
06-06
本文将深入探讨如何通过封装红黑树来模拟实现Map和Set。 红黑树是一种自平衡二叉查找树，它的主要特性是每个节点都带有颜色属性（红色或黑色），并且遵循以下性质： 1. 每个节点要么是黑色，要么是红色。 2. 根节点...
哈希map以及set的封装
04-05
在这个场景中，我们讨论的是C++中的哈希表实现，即`哈希map`和`哈希set`的封装，它们是STL（标准模板库）的一部分，由`unordered_map`和`unordered_set`两个容器来表示。 首先，我们来看`哈希map`。`std::unordered...
c++——map和set的封装
Britney_dark的博客
11-20 768
如果结果不如你所愿，就在尘埃落定前奋力一搏！
c++ map，set封装
2301_78323041的博客
05-12 859
map 是一个 kv 结构， set 是 k结构。我们前面模拟实现了 红黑树，但是我们实现的红黑树把 kv 结构写死了，怎么样才能用泛型编程的思想来实现map和set呢我们先简单看一下原码中是怎么实现的。
map和set 的封装
潜心钻研技术
03-03 752
这些问题在没有学习map和set之前并没有很好的解决方法（但是map和set并不是唯一的解决方法），第二个问题：之前我们解决的方法一般就开辟一个新数组tmp，遍历arr中所有元素，对于arr中任意元素遍历tmp数组如果元素在tmp中未出现就插入。这时就会报错，因为是非const对象，调用的begin是非const成员函数，返回的是普通迭代器，所以报错的原因是缺乏普通迭代器到const迭代器的转化！我们对于map和set封装始终是在红黑树的基础上进行封装的，红黑树的代码可以参考blog。
C++进阶之map与set
cls的博客
05-23 2381
stl中将数据结构叫做容器。 容器分为 序列式容器：vector/list... 就类似线性表 关联史容器：map/set.. 数据之间有强烈的关联性，底层是搜索树 栈和队列是适配器 set底层就是搜索树。 void test_set1() { //排序＋去重 set<int> s; s.insert(3); s.insert(1); s.insert(8); s.insert(2); s.insert(5); s.insert(5); s.insert(5)
C++之map和set 的封装
qq_74732628的博客
05-13 899
文章详细讲解了map和set 的封装过程和底层原理
红黑树封装实现map和set
06-20
封装红黑树实现map和set解决方案
c++容器list、vector、map、set区别与用法详解
08-19
"c++容器list、vector、map、set区别与用法详解" c++容器是c++标准模板库（STL）中的一个重要组件，提供了多种数据结构的实现，包括list、vector、map、set等。这些容器的使用可以大大提高开发效率和代码可读性。 ...
红黑树封装map&&set源代码
06-01
封装红黑树的Map和Set源代码通常会包括以下关键部分： 1. **节点定义**：首先，需要定义红黑树的节点结构，包括键、值、颜色属性、左子节点和右子节点。例如： ```java class Node { Key key; Value value; ...
C++初探究（2）
最新发布
Frenemy__的博客
07-09 713
public:// 成员函数private:// 成员变量int* array;size_t top;而我们如果想要对函数定义，则需要专门使用类域来定义函数.
C++发票识别接口轻松管理财务、发票识别sdk、增值税发票识别
weixin_49544544的博客
07-09 163
众所周知，计算机在办公中的普及大大提高了工作效率，但财务人员还是逃脱不了被发票淹没的命运，数量可观的发票还是需要财务人员手工录入，然后再进行核对。翔云发票识别API是专门针对发票数据开发的一款自动识别发票信息的接口，运用领先的图像处理技术和OCR技术，可高效识别扫描的发票图片并返回票面信息。可是对于企业的财务人员来说需要面对两大问题：首先，增值税发票数量激增，导致发票管理、录入的工作量大涨，财务人员经常要加班加点才能完成；// 创建 HTTP 客户端。
C++(week11): C++基础 第五章: 运算符重载、友元
Edward2022的博客
07-09 458
友元、运算符重载、类型转换函数、嵌套类、单例模式的自动释放、std::string的三种底层实现
C++ 入门03：函数与作用域
LF__plus的博客
07-09 622
今天的学习内容则是C++中的函数与作用域。这部分内容是编写模块化代码和管理变量范围的关键。函数，作为任何一门编程的基石之一，它允许我们将代码分割成可重用的独立块，每个块都执行特定的任务。
数学系C++ 继承派生多态 （十四十三）
m0_68339197的博客
07-08 220
可以使得派生类具有父类的各种属性和功能，而不需要再次编写相同的代码。类的继承：派生类继承了父类的特性（数据和函数）► 继承是可传递的：从父类继承的特性可以传递给新的子类► 继承方式：规定了如何访问从父类继承的成员► 继承方式有三种：public、protected、private► 派生类成员：从父类继承的成员+新增加的成员继承方式不同，访问控制不同 父类成员函数访问父类成员：正常访问 派生类成员函数访问派生类新增成员：正常访问 父类成员函数访问派生类新增成员：不能访问。
C++：CV::Point函数简介
Ethan_Rich的博客
07-08 255
cv::Point是 OpenCV 库中用于表示二维坐标系下点的一个基本数据类型。它提供了在图像处理、计算机视觉等领域中定位和操作点的能力。以下是关于cv::Point。
Python的异常处理（与C++对比学习）
2302_76941579的博客
07-09 403
通过C++的基础来学习Python的异常处理
LIUNX /SYS/CLASS/GPIO捕获IO输入状态 C语言
星羽空间
07-09 100
LIUNX /SYS/CLASS/GPIO捕获IO输入状态 C语言
探索C嘎嘎的奇妙世界:第十九关---STL(list的模拟实现)
2401_84006021的博客
07-05 744
探索C嘎嘎的奇妙世界:第十九关---STL(list的模拟实现)
SolrTemplate query 返回结果封装为map集合
03-25
在上面的代码中，我们先定义了一个List<Map, Object>>类型的结果集，然后创建了一个Query对象，设置了查询条件、返回结果数量、排序方式和返回字段等参数。通过调用solrTemplate.query方法执行查询操作，得到...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值