【C++进阶】RBTree封装map与set

news2024/11/27 10:22:19

1.红黑树的迭代器

1.1 begin()

begin()就是红黑树的开头，那么对于红黑树来说按照中序序列是该树的最左节点。

	Iterator Begin()
	{
		Node* leftMin = _root;
		while (leftMin->_left)
		{
			leftMin = leftMin->_left;
		}
		return Iterator(leftMin);
	}

1.2 end()

begin()就是红黑树的结尾的下一个，那么对于红黑树来说按照中序序列应该是该树的最右节点的下一个位置，但下一个位置是nullptr（这里库中源码写的是使用了一个哨兵位的头节点作为End,我们可以简单来写，以nullptr作为End）。

Iterator End()
{
	return Iterator(nullptr);
}

1.3 operator++

Self& operator++()
{
	//1.右不为空，下一个是右子树最左节点
	if (_node->_right)
	{
		Node* leftMin = _node->_right;
		while (leftMin->_left)
		{
			leftMin = leftMin->_left;
		}
		_node = leftMin;
	}
	//2.右为空，下一个倒着在祖先中找孩子是父亲的左的祖先节点
	else
	{
		Node* cur = _node;
		Node* parent = cur->_parent;
		while (parent && cur == parent->_right)
		{
			cur = parent;
			parent = cur->_parent;
		}
		_node = parent;
	}
	return *this;
}

2.改造红黑树

因为我们之前写的红黑树是不能同时满足set和map的使用，如果需要还必须再写一份来满足另一个，那么我们可不可以把红黑树改造成能同时满足set和map呢？

答案是可以的，我们实质上是偷了个懒，把写另一个的事情交给编译器去做，这也是能体现面向对象中封装的特性的！

#pragma once
#include<vector>

enum Color
{
	RED,
	BLACK
};
template<class T>
struct RBTreeNode
{
	RBTreeNode<T>* _left;	//该节点的左孩子
	RBTreeNode<T>* _right;	//该节点的右孩子
	RBTreeNode<T>* _parent;	//该节点的双亲

	Color _col;
	T _data;	//存放Key或者pair

	RBTreeNode(const T& data)	//该节点初始化
		:_left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _data(data)
		, _col(RED)
	{}
};

template<class T, class Ref, class Ptr>
struct __RBTreeIterator
{
	typedef RBTreeNode<T> Node;
	typedef __RBTreeIterator<T, Ref, Ptr> Self;
	Node* _node;

	__RBTreeIterator(Node* node)
		:_node(node)
	{}
	Ref operator*() 
	{
		return _node->_data;
	}
	Ptr operator->()
	{
		return &_node->_data;
	}
	bool operator!=(const Self& s)
	{
		return _node != s._node;
	}
	Self& operator++()
	{
		//1.右不为空，下一个是右子树最左节点
		if (_node->_right)
		{
			Node* leftMin = _node->_right;
			while (leftMin->_left)
			{
				leftMin = leftMin->_left;
			}
			_node = leftMin;
		}
		//2.右为空，下一个倒着在祖先中找孩子是父亲的左的祖先节点
		else
		{
			Node* cur = _node;
			Node* parent = cur->_parent;
			while (parent && cur == parent->_right)
			{
				cur = parent;
				parent = cur->_parent;
			}
			_node = parent;
		}
		return *this;
	}
};

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*> ConstIterator;

	RBTree() = default;

	//t2(t1)
	RBTree(const RBTree<K, T, KeyOfT>& t)
	{
		_root = Copy(t._root);
	}
	~RBTree()
	{
		Destroy(_root);
		_root = nullptr;
	}
	//t2 = t1
	RBTree<K, T, KeyOfT>& operator=(const RBTree<K, T, KeyOfT> t)
	{
		swap(_root, t._root);
		return *this;
	}
	Iterator Begin()
	{
		Node* leftMin = _root;
		while (leftMin->_left)
		{
			leftMin = leftMin->_left;
		}
		return Iterator(leftMin);
	}
	Iterator End()
	{
		return Iterator(nullptr);
	}
	ConstIterator Begin() const
	{
		Node* leftMin = _root;
		while (leftMin->_left)
		{
			leftMin = leftMin->_left;
		}
		return ConstIterator(leftMin);
	}
	ConstIterator End() const
	{
		return ConstIterator(nullptr);
	}
	Iterator Find(const K& key)
	{
		Node* cur = _root;
		while (cur)
		{
			if (cur->_key < key)
			{
				cur = cur->_right;
			}
			else if (cur->_key > key)
			{
				cur = cur->_left;
			}
			else
			{
				return 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* newnode = cur;
		cur->_col = RED;	//新增节点给红色
		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 = BLACK;
					uncle->_col = BLACK;
					grandfather->_col = RED;

					//继续往上调整
					cur = grandfather;
					parent = cur->_parent;
				}
				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);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}

					break;
				}

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

					//继续往上调整
					cur = grandfather;
					parent = cur->_parent;
				}
				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);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}

					break;
				}
			}
		}

		_root->_col = BLACK;//无论是否调整到根节点都让根节点始终是黑色

		return make_pair(Iterator(newnode), true);
	}
	void RotateR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		parent->_left = subLR;
		if (subLR)	//subLR有可能为空，不为空时才能调整subLR的父节点
			subLR->_parent = parent;
		subL->_right = parent;
		//parent不一定就是根节点，也可能是子树，所以要设置一个ppNode来标记parent的父节点
		Node* ppNode = parent->_parent;
		parent->_parent = subL;

		if (parent == _root)
		{
			_root = subL;
			_root->_parent = nullptr;
		}
		else
		{
			if (ppNode->_left == parent)
			{
				ppNode->_left = subL;
			}
			else
			{
				ppNode->_right = subL;
			}
			subL->_parent = ppNode;
		}
	}
	void RotateL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
		parent->_right = subRL;
		if (subRL)	//subRL有可能为空，不为空时才能调整subRL的父节点
			subRL->_parent = parent;
		subR->_left = parent;
		//parent不一定就是根节点，也可能是子树，所以要设置一个ppNode来标记parent的父节点
		Node* ppNode = parent->_parent;
		parent->_parent = subR;

		if (parent == _root)
		{
			_root = subR;
			_root->_parent = nullptr;
		}
		else
		{
			if (ppNode->_left == parent)
			{
				ppNode->_left = subR;
			}
			else
			{
				ppNode->_right = subR;
			}
			subR->_parent = ppNode;
		}
	}
	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}
	bool IsBalance()
	{
		//检查规则1
		if (_root->_col == RED)
		{
			return false;
		}
		int refNum = 0;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_col == BLACK)
				++refNum;
			cur = cur->_left;
		}
		return Check(_root, 0, refNum);
	}
private:
	Node* Copy(Node* root)
	{
		if (root == nullptr)
			return nullptr;
		Node* newroot = new Node(root->_data);
		newroot->_col = root->_col;

		newroot->_left = Copy(root->_left);
		if (newroot->_left)
			newroot->_left->_parent = newroot;
		newroot->_right = Copy(root->_right);
		if (newroot->_right)
			newroot->_right->_parent = newroot;
		return newroot;
	}
	void Destroy(Node* root)
	{
		if (root == nullptr)
			return;
		Destroy(root->_left);
		Destroy(root->_right);
		delete root;
		root = nullptr;
	}
	bool Check(Node* root, int blackNum, const int refNum)
	{
		if (root == nullptr)
		{
			//检查规则4
			if (blackNum != refNum)
			{
				cout << "存在黑色节点不相等的路径" << endl;
				return false;
			}
			return true;
		}

		//检查规则3
		if (root->_col == RED && root->_parent->_col == RED)
		{
			cout << root->_kv.first << "存在连续的红色节点" << endl;
			return false;
		}

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

		return Check(root->_left, blackNum, refNum)
			&& Check(root->_right, blackNum, refNum);
	}
	void _InOrder(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}

		_InOrder(root->_left);
		cout << root->_kv.first << ":" << root->_kv.second << endl;
		_InOrder(root->_right);
	}
	Node* _root = nullptr;
	//size_t size = 0;	//可以用来记录节点个数
};

3.set的模拟实现

set的底层为红黑树，因此只需在set内部封装一棵红黑树，即可将该容器实现出来。

#pragma once

namespace bit
{
	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>::ConstIterator 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();
		}
		iterator find(const K& key)
		{
			return _t.Find(key);
		}
		pair<iterator, bool> insert(const K& key)
		{
			return _t.Insert(key);
		}
	private:
		RBTree<K, const K, SetKeyOfT> _t;
	};
	void PrintSet(const set<int>& s)
	{
		for (auto e : s)
		{
			cout << e << endl;
		}
	}
	void test_set()
	{
		set<int> s;
		s.insert(4);
		s.insert(2);
		s.insert(5);
		set<int>::iterator it = s.begin();
		while (it != s.end())
		{
			//*it += 5;

			cout << *it << " ";
			++it;
		}
		cout << endl;

		for (auto e : s)
		{
			cout << e << endl;
		}
		PrintSet(s);
	}
}

4.map的模拟实现

map的底层结构就是红黑树，因此在map中直接封装一棵红黑树，然后将其接口包装下即可

#pragma once

namespace bit
{
	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>::ConstIterator 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();
		}
		iterator find(const K& key)
		{
			return _t.Find(key);
		}
		pair<iterator, bool> insert(const pair<K, V>& kv)
		{
			return _t.Insert(kv);
		}

		V& operator[](const K& key)
		{
			pair<iterator, bool> ret = _t.Insert(make_pair(key, V()));
			return ret.first->second;
		}
	private:
		RBTree<K, pair<const K, V>, MapKeyOfT> _t;
	};
	void test_map1()
	{
		map<string, int> m;
		m.insert({"苹果", 1});
		m.insert({ "香蕉", 2});
		m.insert({ "梨子",3});

		map<string, int>::iterator it = m.begin();
		while (it != m.end())
		{
			//it->first += 'x';
			it->second += 1;

			//cout << it.operator->()->first << ":" << it->second << endl;
			cout << it->first << ":" << it->second << endl;
			++it;
		}
		cout << endl;
	}

	void test_map2()
	{
		string arr[] = { "草莓", "香蕉", "梨子", "苹果", "梨子", "苹果", "香蕉",
"草莓", "苹果", "苹果", "梨子","梨子","草莓", "苹果","苹果" };
		map<string, int> countMap;
		for (auto& e : arr)
		{
			countMap[e]++;
		}

		for (auto& kv : countMap)
		{
			cout << kv.first << ":" << kv.second << endl;
		}
		cout << endl;
	}
}

5.test.cpp

#include<iostream>
using namespace std;

#include"RBTree.h"
#include"Myset.h"
#include"Mymap.h"

int main()
{
	bit::test_map1();
	bit::test_set();
	bit::test_map2();
	return 0;
}

 依次展开头文件就可正常使用set与map了。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1816354.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

阅文集团CEO侯晓楠：建立10亿生态扶持基金，为好内容搭建舞台

阅文集团CEO侯晓楠：建立10亿生态扶持基金，为好内容搭建舞台

6月12日&#xff0c;由安徽省文化和旅游厅、安徽省文学艺术界联合会、黄山市人民政府指导&#xff0c;阅文集团、黄山旅游发展股份有限公司主办的2024阅文创作大会在黄山召开。 据「TMT星球」了解&#xff0c;大会总结了过去一年阅文在“AIIP”业务升级思路下创作生态和IP领域…
阅读更多...
写给大数据开发：好的指标定义、特性与业务价值

写给大数据开发：好的指标定义、特性与业务价值

在大数据时代&#xff0c;数据的质量对于业务决策和数据分析至关重要。好的数据不仅丰富&#xff0c;而且准确、及时&#xff0c;为业务提供有力支撑。 文章目录 数据定义与特性数据对业务的价值指标展示与规范化定义一些指标的定义好的数据是业务成功的关键 数据定义与特性 好…
阅读更多...
pycharm终端pip安装模块成功但还是显示找不到 ModuleNotFoundError: No module named

pycharm终端pip安装模块成功但还是显示找不到 ModuleNotFoundError: No module named

报错信息&#xff1a; ModuleNotFoundError: No module named 但是分明已经安装过此模块&#xff1a; 在cmd运行pip list 查看所有安装过的包找到了安装过&#xff1a; 如果重新安装就是这样&#xff1a;显示已经存在了 问题排查&#xff1a; 直接根据重新安装的显示已存在的…
阅读更多...
什么是APS计划排程？ 企业产能与效率提升的智能引擎

什么是APS计划排程？ 企业产能与效率提升的智能引擎

快节奏和愈发激烈的现代工业环境中&#xff0c;如何提升生产效率、降低生产成本、最大化的满足订单交期、实现企业的降本增效&#xff0c;已成为众多企业关注的焦点。而APS系统——作为高级生产计划和调度系统的代表&#xff0c;正以其卓越的生产过程实时监控、产品加工过程优化…
阅读更多...
初级网络工程师之从入门到入狱（三）

初级网络工程师之从入门到入狱（三）

本文是我在学习过程中记录学习的点点滴滴&#xff0c;目的是为了学完之后巩固一下顺便也和大家分享一下&#xff0c;日后忘记了也可以方便快速的复习。 中小型网络系统综合实战实验 前言一、详细拓扑图二、LSW2交换机三、LSW3交换机四、LSW1三层交换机4.1、4.2、4.3、4.4、4.5、…
阅读更多...
【电子通识】为何焊接时要使用助焊剂？常用的助焊剂类型有哪些？

【电子通识】为何焊接时要使用助焊剂？常用的助焊剂类型有哪些？

在工作中&#xff0c;我们会接触到板卡的焊接&#xff0c;会使用到助焊剂&#xff0c;如常常使用的就有松香。如下所示为焊接芯片时使用的拖焊&#xff0c;如果没有助焊剂&#xff0c;很有可能导致管脚连锡或有毛刺等现象出现。 那么助焊剂是什么&#xff1f;为什么它对焊接项目…
阅读更多...
深度学习模型调试的9个方法

深度学习模型调试的9个方法

第一个计算机漏洞实际上是一个 bug。1947 年&#xff0c;一只飞蛾飞进哈佛大学的一台计算机&#xff0c;导致计算中断。当工程师打开计算机机箱时&#xff0c;他们很快就发现了导致问题的 bug。如今&#xff0c;bug 不太可能爬进我们的计算机并破坏计算流程。但是&#xff0c;原…
阅读更多...
RedHat9 | 防火墙配置与管理

RedHat9 | 防火墙配置与管理

RedHat9中默认安装Firewalld&#xff0c;也可安装iptables。但是两者不可同时运行。 软件或程序主要作用firewalld、iptables策略限制MAC、IP、PORT、ARPSELinux上下文、布尔值、端口软件权限读写执行权限文件系统rwx、隐藏权限、ACL 1、Netfilter 包过滤防火墙工作在TCP/IP的…
阅读更多...
【Java】JDBC+Servlet+JSP实现搜索数据和页面数据呈现

【Java】JDBC+Servlet+JSP实现搜索数据和页面数据呈现

目录 1 .功能介绍 2. 实现流程 3. 项目环境 4. 相关代码 4.1 Maven配置 4.2 SQL语句 4.3 Java代码 4.4 HTML代码 4.5 JSP代码 5. 结果展示 &#xff08;原创文章&#xff0c;转载请注明出处&#xff09; 博主是计算机专业大学生&#xff0c;不定期更新原创优质文章&…
阅读更多...
服务架构的设计原则

服务架构的设计原则

墨菲定律与康威定律 在系统设计的时候&#xff0c;可以依据于墨菲定律 任何事情都没有表面上看起来那么简单所有的事情都会比你预计的时间长可能出错的事总会出错担心的某一个事情的发送&#xff0c;那么它就更有可能发生 在系统划分的时候&#xff0c;可以依据康威定律 系…
阅读更多...
0604 集成电路运算放大器

0604 集成电路运算放大器

6.4.1 集成电路运算放大器CMOS MC14573 6.4.2 集成运算放大器741
阅读更多...
搭建社区团购系统，广泛应用便捷高效新体验

搭建社区团购系统，广泛应用便捷高效新体验

前言 在数字化浪潮的推动下&#xff0c;社区团购系统如雨后春笋般崭露头角&#xff0c;为小区居民们带来了前所未有的便捷与实惠。如今&#xff0c;搭建社区团购系统已成为一种新趋势&#xff0c;其广泛应用正逐渐改变着人们的购物方式&#xff0c;让便捷高效的新体验深入人心…
阅读更多...
ADS基础教程19 - 电磁仿真（EM）基本概念和实操

ADS基础教程19 - 电磁仿真（EM）基本概念和实操

EM介绍 一、引言二、基本概念1.EM介绍2.Momentum介绍3.FEM介绍4.Substrate介绍 三、创建Layout并进行Momentum仿真1.创建Layout2.添加Microtrip&#xff08;微带线&#xff09;3.添加Substrate4.Momentum仿真 四、总结 一、引言 本章节开始介绍EM的基本概念、内容以及实现具体…
阅读更多...
简单脉冲动画效果实现

简单脉冲动画效果实现

简单脉冲动画效果实现 效果展示 CSS 知识点 CSS 变量的灵活使用CSS 动画使用 页面整体结构实现 <div class"pulse"><span style"--i: 1"></span><span style"--i: 2"></span><span style"--i: 3"…
阅读更多...
IntelliJ IDEA 2024.1最新安装 亲测有效2099年

IntelliJ IDEA 2024.1最新安装 亲测有效2099年

标题一&#xff1a;IDEA官方下载 ①如题&#xff0c;先到IDEA官方下载&#xff0c;简简单单 ②IDEA官方&#xff1a;IntelliJ IDEA – the Leading Java and Kotlin IDE 标题二&#xff1a;获取脚本 点这里获取 &#x1f31f;获取完后压缩&#xff0c;推荐与IDEA放在同一目…
阅读更多...
Spring框架是如何查找方法上的异步任务注解@Async

Spring框架是如何查找方法上的异步任务注解@Async

结论先行 Spring框架层面&#xff0c;查找方法上的注解的原理与机制是一样的。 在方法层面&#xff0c;Spring框架已经找到子类的Async注解&#xff0c;原因是查找注解会搜索整棵类型继承树&#xff0c;包括超类和实现的接口。 异步任务代码示例 Async注解&#xff0c;在父类…
阅读更多...
⌈ 传知代码 ⌋ ERA-CoT: 实体关系推理

⌈ 传知代码 ⌋ ERA-CoT: 实体关系推理

&#x1f49b;前情提要&#x1f49b; 本文是传知代码平台中的相关前沿知识与技术的分享~ 接下来我们即将进入一个全新的空间&#xff0c;对技术有一个全新的视角~ 本文所涉及所有资源均在传知代码平台可获取 以下的内容一定会让你对AI 赋能时代有一个颠覆性的认识哦&#x…
阅读更多...
48【Aseprite 作图】荷塘月色——拆解

48【Aseprite 作图】荷塘月色——拆解

1 荷叶&#xff0c;不要完全对称&#xff0c;下面是深色的&#xff0c;上面是浅色的&#xff0c;加一点高光 2 鱼的轮廓 上色彩&#xff0c;主要用三种颜色&#xff0c;修改透明度&#xff0c;叠加颜色
阅读更多...
快捷键专栏 IDEA、Navicat、电脑、Excle、Word等

快捷键专栏 IDEA、Navicat、电脑、Excle、Word等

标题 电脑篇windowsR 配合以下常用命令连上公司网线WiFi速度变慢问题解决Windows10 设置鼠标右键在此处打开cmd和Powershell窗口、关机打开电脑诊断工具系统设置常用设置查看电脑出场日期 systeminfo删除文件显示已在另一个程序打开&#xff1f;找回回收站删除的文件WindowsR输…
阅读更多...
RUOYI集成手机短信登录

RUOYI集成手机短信登录

背景&#xff1a; 工作过程中遇到需求&#xff0c;需要将短信验证码登录集成到RUOYI框架中。框架中使用的用户认证组件为Security&#xff0c;由于没有怎么研究过这个组件&#xff0c;这个功能不太会搞。所以这是一篇抄作业记录。参考文章如下 若依RuoYi整合短信验证码登录_若…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023