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

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了。

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

flstudio怎么调中文

flstudio怎么调中文

FL Studio设置中文的步骤如下&#xff1a; 打开FL Studio&#xff1a;首先&#xff0c;需要打开FL Studio编曲软件。 进入常规设置&#xff1a;在软件顶部菜单栏中&#xff0c;选择“OPTIONS”&#xff0c;然后点击“General setting”&#xff0c;进入常规设置窗口。 切换语言…
阅读更多...
51【Aseprite 作图】酒坛——拆解

51【Aseprite 作图】酒坛——拆解

1、框架
阅读更多...
一个基于大模型的多功能的本地网页语音合成工具

一个基于大模型的多功能的本地网页语音合成工具

ChatTTS-ui 是一个开源项目&#xff0c;这是一个利用 ChatTTS 技术将文本转换为语音的本地网页界面工具。它不仅支持中英文和数字的混合输入&#xff0c;还提供了丰富的API接口&#xff0c;为开发者和用户提供了极大的便利。 项目地址&#xff1a;https://github.com/jianchang…
阅读更多...
CPP多线程

CPP多线程

什么是多线程&#xff1f; 多线程是一种允许程序同时运行多个线程的技术。每个线程可以执行不同的任务&#xff0c;这在处理需要并发执行的操作时&#xff08;例如&#xff0c;处理多个客户端的网络服务器&#xff0c;或者图形用户界面应用程序&#xff09;非常有用。多线程能够…
阅读更多...
20. mediasoup服务器的布署与使用

20. mediasoup服务器的布署与使用

Mediasoup Demo部署 架构服务分析 服务端提供3个服务&#xff1a; 1.www服务&#xff0c;浏览器通过访问服务器目录获取客户端代码&#xff0c;通过V8引擎&#xff0c;启动底层WebRTC 2.nodejs提供websocket服务和http服务&#xff0c;用于信令交互 3.Mediasoup C提供的流媒体…
阅读更多...
分类预测 | Matlab实现基于Transformer多特征分类预测/故障诊断

分类预测 | Matlab实现基于Transformer多特征分类预测/故障诊断

分类预测 | Matlab实现基于Transformer多特征分类预测/故障诊断 目录 分类预测 | Matlab实现基于Transformer多特征分类预测/故障诊断分类效果基本介绍程序设计参考资料 分类效果 基本介绍 1.Matlab实现Transformer多特征分类预测/故障诊断&#xff0c;运行环境Matlab2023b及以…
阅读更多...
代码随想录——组合总数Ⅲ（Leetcode216）

代码随想录——组合总数Ⅲ（Leetcode216）

题目链接 回溯 class Solution {List<List<Integer>> res new ArrayList<List<Integer>>();List<Integer> list new ArrayList<Integer>();public List<List<Integer>> combinationSum3(int k, int n) {backtracking(k, …
阅读更多...
【数字化转型，从BI开始】论BI在数字化转型的作用

【数字化转型，从BI开始】论BI在数字化转型的作用

引言&#xff1a;在新的市场和用户需求、传统经济增长缓慢、疫情黑天鹅事件等多重因素的影响下&#xff0c;企业遭遇了集体性的困境&#xff0c;而数字化转型就是各领域企业寻找出的应对方式。数字化转型包含的三维度之一数据力&#xff0c;就包含数据治理和数据分析&#xff0…
阅读更多...
ubuntu搭建java开发环境IDEA版

ubuntu搭建java开发环境IDEA版

一.安装 OpenJDK 更新包列表&#xff1a; sudo apt update安装 OpenJDK&#xff1a; 你可以选择安装不同版本的 OpenJDK&#xff0c;例如 11 或 17&#xff0c;这个是安装 OpenJDK 11 的命令&#xff1a; sudo apt install openjdk-11-jdk验证安装&#xff1a; 安装完成后…
阅读更多...
DETR开篇之作

DETR开篇之作

1. 论文背景和动机 背景&#xff1a; 传统的物体检测方法&#xff08;如Faster R-CNN等&#xff09;通常依赖复杂的多阶段 pipeline&#xff0c;包括区域候选生成、特征提取和后处理步骤。这些方法尽管有效&#xff0c;但复杂度高且难以端到端训练。 动机&#xff1a; DETR的提…
阅读更多...
头歌资源库（7）汉诺塔（循环）

头歌资源库（7）汉诺塔（循环）

一、 问题描述 二、算法思想 初始化三个柱子A、B、C&#xff0c;初始时所有的盘子都在柱子A上。对于从1到N&#xff08;N表示盘子的数量&#xff09;的每一个数字i&#xff0c;执行以下循环&#xff1a; a. 如果i是偶数&#xff0c;则将柱子B视为目标柱子&#xff0c;柱子C视为…
阅读更多...
三分钟带你手把手安装 GoldWave

三分钟带你手把手安装 GoldWave

goldwave绿色版是一款非常不错的数字音频编辑处理软件&#xff0c;绿色制作&#xff0c;无需安装即可使用&#xff0c;拥有录制、编辑、音频处理、恢复、增强和转换等多种功能&#xff0c;不管是最简单的录制、编辑&#xff0c;还是复杂的的音频处理、恢复、增强和转换&#xf…
阅读更多...
如何看懂SparkUI?

如何看懂SparkUI?

Jobs页面 Stage页面 显示额外的指标和摘要指标&#xff1a; 摘要指标&#xff08;Summary Metrics&#xff09;统计了所有完成的任务的执行行为&#xff0c;包括执行时间、GC时间、输入输出信息等&#xff0c;并提供了最小值&#xff08;Min&#xff09;、第25百分位数&#xf…
阅读更多...
计算机组成原理之浮点四则运算

计算机组成原理之浮点四则运算

文章目录 浮点加减运算浮点乘法运算浮点除法运算浮点运算器的流水原理习题 浮点加减运算 总的来说&#xff0c;分为四个步骤&#xff1a; &#xff08;1&#xff09;0操作数检查 &#xff08;2&#xff09;比较阶码大小并完成对阶 &#xff08;3&#xff09;尾数进行加或者减操…
阅读更多...
扫地机LiDAR形态之美

扫地机LiDAR形态之美

石头扫地机V20 LiDAR: Flash光源和Spot光源切换 图来自 Robot森 LiDAR（Light Detection and Ranging，激光雷达）技术在扫地机器人中的应用，不仅提升了机器的智能性和实用性，还展现了一种科技与艺术的融合之美。 一、外观设计的精致性 紧凑与轻巧：扫地机器人的LiDAR传感器…
阅读更多...
【学习笔记】centos7安装mysql相关事项

【学习笔记】centos7安装mysql相关事项

究极恶心的体验 依赖要按照顺序安装&#xff0c;有些依赖安装位置也不同 非常细节 mysql安装包&#xff1a;mysql官网下载地址 centos7选择Red Hat Enterprise Linux 7 / Oracle Linux 7 (x86, 64-bit), RPM Bundle 下载版本自选 安装视频教程&#xff1a;centos7.5安装mysql …
阅读更多...
板凳----《Linux/Unix系统编程手册》读书笔记24章

板凳----《Linux/Unix系统编程手册》读书笔记24章

D 24章　进程的创建　425 24.1 fork()、exit()、wait()以及execve()的简介 425 . 系统调用fork()允许父进程创建子进程 . 库函数exit(status)终止进程&#xff0c;将进程占用的所有资源归还内核&#xff0c;交其进行再次分配。库函数exit()位于系统调用_exit()之上。在调用fo…
阅读更多...
2024上半年软考---江苏考区最先公布成绩

2024上半年软考---江苏考区最先公布成绩

经历了考试之后&#xff0c;最期待的就是考试成绩的公布了&#xff0c;最好的成绩是45、45、45.只要过了分数线就满足了。下面我们来看看各大考区的分数的公布时间。 提前说下江苏考区的时间比较早&#xff0c;我就是江苏考区的&#xff0c;希望本次可以顺利通过考试。 2024年…
阅读更多...
【全栈实战】大模型自学：从入门到实战打怪升级，20W字总结（一）

【全栈实战】大模型自学：从入门到实战打怪升级，20W字总结（一）

&#x1f60a;你好&#xff0c;我是小航&#xff0c;一个正在变秃、变强的文艺倾年。 &#x1f514;本栏讲解【全栈实战】大模型自学&#xff1a;从入门到实战打怪升级。 &#x1f514;专栏持续更新&#xff0c;适合人群&#xff1a;本科生、研究生、大模型爱好者&#xff0c;期…
阅读更多...
React 中的事件处理

React 中的事件处理

React 中是如何处理事件的&#xff0c;现在下面简单的一段代码&#xff1a; export default function App() {const AList lazy(()>import(./List.js))const r useRef(null) const [show, setShow] useState(false);return (<><button onFocus{()>{setShow…
阅读更多...
最新文章

Copyright @ 2022~2023