C++进阶--mep和set的模拟实现

最新推荐文章于 2024-06-15 16:46:40 发布
最新推荐文章于 2024-06-15 16:46:40 发布
阅读量581 收藏 35
点赞数 38
分类专栏： C++进阶 文章标签： c++ 开发语言 map set
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74068921/article/details/136699510
版权

红黑树链接入口

底层容器

模拟实现set和map时常用的底层容器是红黑树。
红黑树是一种自平衡的搜索二叉树，通过对节点进行颜色标记来保持平衡。

在模拟实现set和map时，可以使用红黑树来按照元素的大小自动排序，并且保持插入和删除操作的高效性。set的每个节点只存储一个键值，不需要额外的值；而map每个节点存储的是一个键值对，值与键保持关联。通过红黑树的特性，可以根据快速查找，插入和删除对应的节点元素；

红黑树的改造

#pragma once
#include<vector>
enum Colour
{
	RED,
	BLACK
};

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

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

};


//红黑树的迭代器
  template<class T,class Ptr,class Ref>
  struct RBTreeIterator
  {
	  typedef RBTreeNode<T> Node;
	  typedef RBTreeIterator<T,Ptr,Ref> Self;

	  Node* _node;

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

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

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

	  Self& operator++()
	  {
		  if (_node->_right)
		  {
			  Node* subLeft = _node->_right;
			  while (subLeft->_left)
			  {
				  subLeft = subLeft->_left;
			  }
			  _node = subLeft;
		  }
		  else
		  {
			  Node* cur = _node;
			  Node* parent = cur->_parent;
			  while (parent&&cur==parent->_right)
			  {
				  cur = parent;
				  parent = parent->_parent;
			  }
			  _node = parent;
			  
		  }
		  return *this;
	  }

	  Self& operator--()
	  {
		  if (_node->_left)
		  {
			  Node* subRight = _node->_left;
			  while (subRight->_right)
			  {
				  subRight = subRight->_right;
			  }
			  _node = subRight;
		  }
		  else
		  {
			  Node* cur = _node;
			  Node* parent = cur->_parent;
			  while (parent && cur == parent->_left)
			  {
				  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,SetOfT>
//map->RBTree<K,pair<K,V>,MapKeyOfT>
template<class K,class T,class KeyOfT>
class RBTree
{
	typedef RBTreeNode<T> Node;
public:
	typedef RBTreeIterator<T,T*,T&> iterator;
	typedef RBTreeIterator<T, const T*, const T&> const_iterator;
	
	const_iterator begin() const
	{
		Node* subLeft = _root;
		while (subLeft && subLeft->_left)
		{
			subLeft = subLeft->_left;
		}
		return const_iterator(subLeft);
	}
	
	iterator begin()
	{
		Node* subLeft = _root;
		while (subLeft && subLeft->_left)
		{
			subLeft = subLeft->_left;
		}
		return iterator(subLeft);
	}

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

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

	iterator Find(const K& key)
	{
		KeyOfT kot;
		Node* cur = _root;
		//通过比较确定key节点的位置
		while (cur)
		{
			if (kot(cur->_data) < key)
			{
				cur = cur->_right;
			}
			else if (kot(cur->_data) > key)
			{
				cur = cur->_left;
			}
			else
			{
				return iterator(cur);
			}
		}
		//找不到返回最后的end
		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节点和p节点的位置关系
		cur = new Node(data);
		//要记住当前节点的位置
		Node* newnode = cur;
		if (kot(parent->_data )< kot(data))
		{
			parent->_right = cur;
		}
		else
		{
			parent->_left = cur;
		}
		cur->_parent = parent;

		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;
					parent = cur->_parent;
				}
				else//情况2
				{
					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);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}
					break;//旋转完的子树的根节点必为黑，这时就不用向上调整处理了

				}
			}
			else
			{
				Node* uncle = grandfather->_left;
				// 情况一：叔叔存在且为红
				if (uncle && uncle->_col == RED)
				{
					// 变色
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;

					// 继续往上处理
					cur = grandfather;
					parent = cur->_parent;
				}
				else//情况2
				{
					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);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}
					break;//旋转完的子树的根节点必为黑，这时就不用向上调整处理了

				}
			}
		}

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

	}

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

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

		subR->_left = parent;
		Node* ppnode = parent->_parent;
		parent->_parent = subR;

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

	void RotateR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;

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

		subL->_right = parent;

		Node* ppnode = parent->_parent;
		parent->_parent = subL;

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


private:
	Node* _root = nullptr;
};

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

红黑树的迭代器

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

map和set的模拟实现

Mymap.h

namespace fnc
{
	template<class K,class V>
	class map
	{
		struct MapKeyOfT
		{
			const K& operator()(const pair<K, V>& kv)
			{
				return kv.first;
			}
		};
	public:
		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();
		}

		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)
		{
			pair<iterator, bool> ret = insert(make_pair(key, V()));
			return ret.first->second;
		}

		iterator find(const K& key)
		{
			return _t.Find(key);
		}
	private:
		RBTree<K, pair<const K, V>, MapKeyOfT> _t;
	};
}

Myset.h

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

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

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

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

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

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

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

测试

void test_map1()
	{
		map<int, int> m;
		int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };
		for (auto e : a)
		{
			m.insert(make_pair(e,e));
		}

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

在这里插入图片描述
在这里插入图片描述

void test_set1()
	{
		set<int> s;
		int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };
		for (auto e : a)
		{
			s.insert(e);
		}

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

在这里插入图片描述

operator[]

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

void test_map2()
	{
		string arr[] = { "西瓜","草莓","香蕉","苹果","西瓜","草莓","香蕉" ,"西瓜","草莓","西瓜" };
		map<string, int> countmap;

		for (auto& e : arr)
		{
			countmap[e]++;
		}
		for (auto& kv : countmap)
		{
			cout << kv.first << ":" << kv.second << " ";
		}
		cout << endl;
	}

在这里插入图片描述

完善

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

验证

void test_map3()
	{
		 map<int, int> m;
		int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };
		for (auto e : a)
		{
			m.insert(make_pair(e, e));
		}

		const map<int, int> m1 = m;
		map<int, int>::const_iterator it = m1.begin();
		while (it != m1.end())
		{
			cout << it->first << "," << it->second << endl;
			++it;
		}
		cout << endl;

		map<int, int>::iterator it2 = m.find(15);
		--it2;
		cout << it2->first << "," << it2->second << endl;
	}

在这里插入图片描述
在这里插入图片描述

诡异森林。
关注
  • 38
    点赞
  • 踩
  • 35
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 35
    评论
专栏目录
利用jquery-ajax实现局部刷新
wr456wr的博客
11-28 2100
文章目录使用jquery实现局部刷新后端使用springMVC模式进行数据处理后端使用Servlet进行数据处理关于更具体的jquery的ajax方法和参数关于跨域访问 使用jquery实现局部刷新 后端使用springMVC模式进行数据处理 前端测试代码： <%@ page contentType="text/html; UTF-8" pageEncoding="UTF-8" %> <html> <body> 内容： <p id="pp" onmouseover
pyRevitMEP:PyRevitMEP-PyRevit的MEP扩展
05-09
pyRevitMEP PyRevitMEP-PyRevit的MEP扩展安装自动的 使用pyRevit软件包管理器（pyRevit>扩展>启用pyRevitMEP）手册（无需管理员权限）命令行（Cmder） 下载解压缩到您喜欢的任何位置使用git克隆存储库（如果已经安装...
WebService - MEP(信息交换模式)
小小默：进无止境
11-05 2224
【1】MEP简介MEP是Message Exchange Patterns的缩写，意思是”信息交换模式”。消息交换模式（Message Exchange Pattern：MEP）在SOA中是一个重要的概念。MEP定义了参与者进行消息交换的模板，这是一个很抽象的定义。实际上我们可以这样理解MEP：消息交换模式（MEP）代表一系列的模板，它们定义了消息的发送者和接收者相互进行消息传输的次序。消息交换模式
map和set
庖丁解牛，恢恢乎游刃有余
12-24 2208
map和set学了以后会非常舒服，我们今天重点讲它的使用。map有什么用？通过一个值就可以找另外一个值我们就可以用map,经典的场景就是字典，我们中文找英文，英文找中文。还有统计次数。map非常非常重要。学习map之前得先来认识一个结构。这个结构叫做pairmap是key和value的结构，它既要存一个value也要存一个key,它是key/value的搜索树。但它里面的数据不是存key和value,它是存value的变量。pair是库里面自己定义的结构。
关于Flume Agent内部原理-Flink进阶认识
程序员视野
12-16 261
Flume Agent内部原理 重要组件： 1 ChannelSelector ChannelSelector的作用就是选出Event将要被发往哪个Channel。其共有两种类型，分别是Replicating（复制）和Multiplexing（多路复用）。 ReplicatingSelector会将同一个Event发往所有的Channel，Multiplexing会根据相应的原则，将不同的Event发往不同的Channel。 2 SinkProcessor SinkProcessor共有三种类
Vue3 -- 基于Websocket实现简易聊天室
zhangdm的博客
06-10 3万+
聊天室
html--蛆
热门推荐
stqer的博客
05-23 4万+
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN"> <HTML> <HEAD> <TITLE> New Document </TITLE> <META NAME="Generator" CONTENT="EditPlus"> <META NAME="Author" CONTENT=""> <META NAME="Keywords
机器学习-预剪枝和后剪枝
qq_52233007的博客
11-22 4194
预剪枝 ， 即在生成决策树的过程中提前停止树的增长。核心思想是在树中结点进行扩展之前，先计算当前的划分是否能带来模型泛化能力的提升，如果不能，则不再继续生长子树。此时可能存在不同类别的样本同时存于结点中，按照多数投票的原则判断该结点所属类别。预剪枝对于何时停止决策树的生长有以下几种方法：( 1 ）当树到达一定深度的时候，停止树的生长。( 2 ）当到达当前结点的样本数量小于某个阈值的时候，停止树的生长。( 3 ）计算每次分裂对测试集的准确度提升，当小于某个阈值的时候 ，不再继续扩展。
Revit二次开发-如何实现管道打断
weixin_46563153的博客
12-20 1153
如何实现管道打断 分享一个学习二开的菜鸟笔记，实现一个功能一开始的想法很重要它能关乎到功能实现的效果和工作效率。接下来分享一下我的想法： 1.获取两个点 2.判断两点形成两端线（后面区分两根风管的位置） 3.复制一根风管，根据第2.修改它们的长度 4.将复制的风管连接回原来的管道系统去 这样管道就实现打断功能啦，详见下面代码 （本人是个做了挺久的BIMer，在二开是个菜鸟，一直在学习中，不是专业的IT人员，所以下面的代码可能有许多不必要的，请谅解重要的是方法和想法，在二开的道路上希望自己能坚持下去，以后为大
ACM学习笔记 - 概率DP
qq_74825516的博客
10-03 981
说来搞笑，重学一遍才发现概率DP有够简单，自己以前居然连反推都不会写，唉。概率 = 结果 * 概率概率DP其实无非三点：一是线性拆开，这个在状压不行的情况下优先考虑二是正反推，有多简单？只需要把枚举顺序反一下就行了三是后效性 + 高斯消元，偶尔会用约旦高斯，注意观察就行了，推起来不难，就是要记得背板子上题（直接在洛谷搜索题目就行）：1.「SCOI2008」奖励关 2.正推：CodeForces 148 D Bag of mice3.反推： POJ2096 Collecting Bugs4.CodeForce
Revitmep培训大纲-ISBIM-基础.pptx
04-14
Revitmep培训大纲-ISBIM-基础
901ME-GME-MES-GMEP-MEP(32位)利谱双硬盘隔离卡驱动-绝版
12-15
利谱隔离卡驱动-绝版
前端开源库-gulp-rollup-mep
08-29
前端开源库-gulp-rollup-mepGulp Rollup MEP，根据多个入口点使用Rollup制作单独的捆绑包
mep-100（mep-300）电路图
01-09
mep-100和mep-300电路图通用的，学习制作编程器的好教材，需要的下
6.15 c语言
jwh199694的博客
06-15 124
char类型的指针变量称为字符指针变量，字符指针变量与字符有着密切关系，他也被用来处理字符串。当一个字符指针指向一个字符串常量时，不能修改指针指向的对象的值。3、字符串常量//char *p = “welcome”;字符串常量不能被修改，因为存储在静态存储区//会发生段错误。初始化字符指针是把内存中字符串的首地址赋予指针。c语言通过使用字符数组来处理字符串。2、static局部变量。
c++ 6.11
Johan1111的博客
06-11 268
(5)另外， RMB 类还包含一个静态整型成员变量 count，用于记录当前已创建的 RMB 对象的数量。每当创建一个新的 RMB 对象时，count 应该自增 1；(1)重载算术运算符 + 和 -，使得可以对两个 RMB 对象进行加法和减法运算，并返回一个新的 RMB 对象作为结果。(2)重载关系运算符 >，判断一个 RMB 对象是否大于另一个 RMB 对象，并返回 true 或 false。(3)重载前置减减运算符 --，使得每次调用时 RMB 对象的 yuan、jiao 和 fen 分别减 1。
【C++提高编程-05】----C++之Deque容器实战
最新发布
一伦明悦的博客
06-15 800
Deque（双端队列）是C++ STL中的一种序列容器
【C++】——Stack与Queue（含优先队列（详细解读）
m0_74092462的博客
06-09 1021
优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。 队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。
MEP products是什么意思
08-12
MEP products（MEP 产品）指的是在建筑和工程项目中使用的与机械、电气和管道相关的产品和设备。 在建筑领域，MEP products 包括但不限于空调系统、电气设备、照明设备、暖通设备、给排水系统、消防系统等。这些...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

诡异森林。

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

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

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

打赏作者

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

抵扣说明：

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

余额充值