红黑树封装map和set（模拟实现）

最新推荐文章于 2024-07-21 22:27:18 发布
最新推荐文章于 2024-07-21 22:27:18 发布
阅读量827 收藏 27
点赞数 19
分类专栏： C++进阶 文章标签： java 开发语言 数据库 数据结构 c语言 算法 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73802195/article/details/138127769
版权

troop主页
临近五一放假，祝大家节日快乐，我们的学习还在路上！！
在前面一章我们已经实现出了红黑树的基本框架，现在我们要有这个底层结构去封装map和set。

一 红黑树的迭代器

但在这之前我们要先把红黑树的迭代器实现出来，因为map和set也是有迭代器的。
迭代器常用的有这么几个"-> * ++ == !="这个几个中++的实现是重点，其他的较为简单。

1.2 operator++

在这里插入图片描述

要理解++首先我们要知道++后下一个节点是谁。当然红黑树走的是中序遍历，
举两个例子，假如it现在是在13的位置上，那么++it下一个点是谁？
在这里插入图片描述

中序：左子树+根+右子树。所以当it在13的位置时说明他的左子树已经全部遍历完成了，现在就要到右子树的最左节点也就是15.
那如果it现在在15的位置时，++it呢？可以看见，15的右子树为空，那就要寻找他的父亲节点也就是17.
分析完毕，我们来总结一下。

  1. 当it指向的当前节点的右子树不为空，那就去寻找此节点右子树的最左节点。
  2. 当it指向的当前节点的右子树为空，说明这个节点的中序遍历已经结束了，要向上返回了，下一个节点就是孩子=父亲的左，这个节点。
    这里还有一些细节问题。当我们在向上返回的时候，如果cur走到了根节点，那么parent这个节点就会出现越界访问的问题，所以在写条件的时候要加上这一点。
Self& operator++()
	{
		if (_node->_right && _node)//右子树不为空
		{
			Node* subLeft = _node->_left;
			while (subLeft->_left)
			{
				subLeft = subLeft->_left;
			}
			_node = subLeft;
		}
		else//右子树为空
		{
			Node* cur = _node;
			Node* parent = cur->_parent;
			while (cur == parent->_right && parent)
			{
				cur = parent;
				parent = cur->_parent;
			}
			_node = parent;
		}
		return *this;
	}

1.3 迭代器完整代码

template<class T>
struct RBTreeIterator
{
	typedef RBTreeNode<T> Node;
	typedef RBTreeIterator<T> Self;
	Node* _node;

	T* operator->()
	{
		return &_node->_data;
	}
	T& operator*()
	{
		return _node->_data;
	}
	Self& operator++()
	{
		if (_node->_right && _node)//右子树不为空
		{
			Node* subLeft = _node->_left;
			while (subLeft->_left)
			{
				subLeft = subLeft->_left;
			}
			_node = subLeft;
		}
		else//右子树为空
		{
			Node* cur = _node;
			Node* parent = cur->_parent;
			while (cur == parent->_right && parent)
			{
				cur = parent;
				parent = cur->_parent;
			}
			_node = parent;
		}
		return *this;
	}
	bool operator!=(const Self& s)
	{
		return _node != s._node;
	}

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

二 封装

这一部分刚开始看可能会有些晕，因为我们要在三个文件中来回的更改代码。

2.1改造红黑树

因为关联式容器中存储的是<key,value>的键对值，因此我们不能单纯的写K和V。
这里的value对于map和set来说是完全不一样的。

对于set来说value就是K
对于map来说value就是pair<K,V>

那么对于模板来说set就是<K,K>
对于map就是<K,pair<K,V>>

//template<class K, class V>
template<class T>
struct RBTreeNode
{
	RBTreeNode<T>* _left;
	RBTreeNode<T>* _right;
	RBTreeNode<T>* _parent;
	//pair<K, V> _kv;
	T _data;
	Colour _col;

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

这里改造前的代码我搞成了注释，方便大家观察。下面有K，V的也都改成了T。

现在我们把map和set写出来，再梳理一遍
在这里插入图片描述
但此时又产生了一个新的问题，我们的比较大小怎么办？我们预期的比较大小是只有first比较也就是K比较，而seco是不参与比较的。我们先来看一看库里面的pair有没有比较。
在这里插入图片描述
库里面的pair还有second的比较这是不符合我们的预期的，那么我们要怎么做呢？
我们可以自己写一个仿函数来进行比较。写一个仿函数
1.如果是set就取出key

		struct setKeyOfT
		{
			const K& operator()(const K& key)
			{
				return key;
			}
		};

2.如果是map取出pair里面的key

		struct mapKeyOfT
		{
			const K& operator()(const pair<K, V>& kv)
			{
				return kv.first;
			}
		};

我们在红黑树的类型中加入这个仿函数，并且在每个需要用到key的位置上加入这个仿函数。

三 代码全

1 RBTree

#pragma once
#include<vector>
#include<iostream>
using namespace std;
enum Colour
{
	RED,
	BLACK
};

//template<class K, class V>
template<class T>
struct RBTreeNode
{
	RBTreeNode<T>* _left;
	RBTreeNode<T>* _right;
	RBTreeNode<T>* _parent;
	//pair<K, V> _kv;
	T _data;
	Colour _col;

	RBTreeNode(const T data)
		:_left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _data(data)
		, _col(RED)
	{}
};
template<class T>
struct RBTreeIterator
{
	typedef RBTreeNode<T> Node;
	typedef RBTreeIterator<T> Self;
	Node* _node;

	T* operator->()
	{
		return &_node->_data;
	}
	T& operator*()
	{
		return _node->_data;
	}
	Self& operator++()
	{
		if (_node->_right && _node)//右子树不为空
		{
			Node* subLeft = _node->_left;
			while (subLeft->_left)
			{
				subLeft = subLeft->_left;
			}
			_node = subLeft;
		}
		else//右子树为空
		{
			Node* cur = _node;
			Node* parent = cur->_parent;
			while (cur == parent->_right && parent)
			{
				cur = parent;
				parent = cur->_parent;
			}
			_node = parent;
		}
		return *this;
	}
	bool operator!=(const Self& s)
	{
		return _node != s._node;
	}

	bool operator == (const Self & s)
	{
		return _node == s._node;
	}
};
template<class K, class T, class KeyOfT>
class RBTree
{
	typedef RBTreeNode<T> Node;
	
public:
	typedef RBTreeIterator<T> iterator;
	iterator begin()
	{
		Node* subLeft = _root;
		while (subLeft && subLeft->_left)
		{
			subLeft = subLeft->_left;
		}
		return iterator(subLeft);
	}
	iterator end()
	{
		return iterator(nullptr);
	}
	
	bool Insert(const T& data)
	{
		if (_root == nullptr)
		{
			_root = new Node(data);
			_root->_col = BLACK;
			return 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 false;
			}
		}

		cur = new Node(data); // 红色的
		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
				{
					// 情况二：叔叔不存在或者存在且为黑
					// 旋转+变色
					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
				{
					// 情况二：叔叔不存在或者存在且为黑
					// 旋转+变色
					//      g
					//   u     p
					//            c
					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 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;
		}
	}

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

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

	void InOrder()
	{
		_InOrder(_root);
	}

	bool Check(Node* cur, int blackNum, int refBlackNum)
	{
		if (cur == nullptr)
		{
			if (refBlackNum != blackNum)
			{
				cout << "黑色节点的数量不相等" << endl;
				return false;
			}

			//cout << blackNum << endl;
			return true;
		}

		if (cur->_col == RED && cur->_parent->_col == RED)
		{
			cout << cur->_kv.first << "存在连续的红色节点" << endl;
			return false;
		}

		if (cur->_col == BLACK)
			++blackNum;

		return Check(cur->_left, blackNum, refBlackNum)
			&& Check(cur->_right, blackNum, refBlackNum);
	}

	bool IsBalance()
	{
		if (_root && _root->_col == RED)
			return false;

		int refBlackNum = 0;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_col == BLACK)
				refBlackNum++;

			cur = cur->_left;
		}

		return Check(_root, 0, refBlackNum);
	}

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

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

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

	//int GetRotateSize()
	//{
	//	return rotateSize;
	//}

private:
	Node* _root;
	//int rotateSize = 0;
};

//void TestRBTree1()
//{
//	//int a[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };
//	int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14,16, 3, 7, 11, 9, 26, 18, 14, 15 };
//	RBTree<int, int> t;
//	for (auto e : a)
//	{
//		t.Insert(make_pair(e, e));
//
//		// 1、先看是插入谁导致出现的问题
//		// 2、打条件断点，画出插入前的树
//		// 3、单步跟踪，对比图一一分析细节原因
//		//cout << e << "->" << t.IsBalance() << endl;
//	}
//
//	t.InOrder();
//	cout << t.IsBalance() << endl;
//}

2 map

#pragma once
#include"RBTree.h"
namespace yjt
{
	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<K, V>, mapKeyOfT>::iterator iterator;

		iterator begin()
		{
			return _t.begin();
		}
		iterator end()
		{
			return _t.end();
		}
		bool insert(const pair<K,V>& kv)
		{
			return _t.Insert(kv);
		}
	private:
		RBTree<K, pair<K, V>, mapKeyOfT> _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())
		{
			//if(*it % 2 == 0)
			//	*it += 100;

			cout << it->first << ":" << it->second << endl;
			++it;
		}
		cout << endl;
	}
}

3 set

#pragma once
#include"RBTree.h"
namespace yjt
{
	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& key)
		{
			return _t.Insert(key);
		}
	private:
		RBTree<K, K, setKeyOfT> _t;
	};
	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())
		{
			//if(*it % 2 == 0)
			//	*it += 100;

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

四 总结

这个就需要多写代码去理解，因为代码都普遍比价大一些。

tpoog
关注
  • 19
    点赞
  • 踩
  • 27
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 6
    评论
专栏目录
使用红黑树封装map和set
qq_47406941的博客
06-07 772
红黑树和AVL树都是二叉搜索树，但是从效率以及实现方式等方面综合来看，红黑树比AVL树更优。也就是说，红黑树是一种更好的，适合搜索的数据结构。同时，红黑树的使用方面非常广泛，Java库、linux内核、c++ST ...
红黑树封装实现map和set
06-20
封装红黑树实现map和set解决方案
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模
【C++】红黑树封装实现map和set
The porters of knowledge
04-01 1002
用一棵红黑树封装map和set，set表层迭代器底层均为红黑树的const迭代器，实现map的[ ]重载……
【 C++ 】用一颗红黑树封装map和set
bit_zyx的博客
09-04 361
目录 1、前言 2、红黑树模板参数的控制 3、模板参数中仿函数的增加 4、红黑树迭代器的实现 5、红黑树的begin()和end() 6、红黑树的Find查找函数 7、红黑树源码链接 8、set的代码 9、map的代码
红黑树封装map&&set源代码
06-01
通过理解红黑树的工作原理，并结合上述关键部分，我们可以构建出自己的红黑树封装的Map和Set实现。这样的实现有助于深入理解数据结构和算法，同时也可以用于学习和教学目的。在实际开发中，直接使用Java提供的`...
map和set的模拟实现
06-06
这将帮助我们更好地理解和实现红黑树，从而有效地模拟出Map和Set。 总之，通过封装红黑树并结合C++的面向对象特性，我们可以构建出高性能的Map和Set模拟实现。这不仅可以加深对数据结构和算法的理解，也有助于在...
c++容器list、vector、map、set区别与用法详解
08-19
map容器是一个基于红黑树的平衡检索二叉树，存储结构为键值对,value>。map容器的特点是： * 采用平衡检索二叉树，存储结构为键值对,value>。 * 支持快速查找、插入和删除元素。 * 查找、插入和删除元素的时间复杂度...
redis+spring面试题
github_36510643的博客
07-21 147
redis+spring面试题
Java-Lambda
最新发布
lizhiwei21的博客
07-21 137
lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的面向对象思想 :强调的是用对象去完成某些功能函数式编程思想 :强调的是结果 , 而不是怎么去做。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 486
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
接口防刷！利用redisson快速实现自定义限流注解
架构师小吴的博客
07-18 1123
如登录接口，当用户使用手机号+验证码登录时，一般我们会生成6位数的随机验证码，并将验证码有效期设置为1-3分钟，如果对登录接口不加以限制，理论上，通过技术手段，快速重试100000次，即可将验证码穷举出来。解决思路：对登录接口加上限流操作，如限制一分钟内最多登录5次，登录次数过多，就返回失败提示，或者将账号锁定一段时间。在日常开发中，一些重要的对外接口，需要加上访问频率限制，以免造成资��损失。ok，通过以上两步，即可完成我们的限流注解了，下面通过一个接口验证下效果。
JVM-垃圾回收与内存分配
m0_50846237的博客
07-19 1121
JVM-垃圾回收与内存分配
java算法day19
TOMOT77的博客
07-20 174
我第一时间想到的方法是遍历二叉树+哈希。哈希用来统计数字出现的次数。之后遍历map收集结果。利用了BST的性质，即BST的中序序列是有序序列。
【Java算法】前缀和 下
2302_79806056的博客
07-18 1047
这段代码实现了一个寻找数组中具有相等数量的0和1的最长子数组长度的算法。具体来说，它使用了前缀和（prefix sum）的概念以及哈希映射（HashMap）来优化查找过程。初始化哈希映射：计算前缀和：检查相等数量的0和1：更新哈希映射：返回结果：这种方法的时间复杂度为O(n)，因为我们只遍历数组一次，并且对每个元素执行常数时间的操作。空间复杂度也是O(n)，最坏情况下需要存储n个前缀和值。 初始化阶段:开始遍历数组:继续
华为OD机试 - 分披萨 - 递归（Java 2024 D卷 200分）
学Java，找哪吒
07-21 499
递归算法通过函数调用自身解决问题，每次递归调用都处理问题的一个子部分，直到达到基准条件，从而构建最终解。
【Java并发编程之美 | 第三篇】Java 并发包中锁原理剖析之AQS、ReentrantLock独占可重入锁
踢桃的成长之路
07-21 536
Java 并发包中锁原理剖析之AQS、ReentrantLock独占可重入锁
对androidTestDebug 产物进行重新签名
shuizhizhiyin的专栏
07-19 467
在运行 gradle assembleAndroidTestDebug 任务后，自定义的 reSignAndroidTestDebug 任务将会被执行，并对子模块的 androidTestDebug 产物进行重新签名。your_keystore_path.jks、your_keystore_password、your_key_alias 和 your_key_password 需要替换为你的实际路径和密码。如果需要对其他子模块的产物进行重新签名，可以根据需要创建不同的自定义任务。// 设置密钥库密码。
c++stl中红黑树的实现
09-14
在C++ STL中，红黑树的实现被封装在`std::map`和`std::set`这两个容器类中。这两个容器类都是基于红黑树实现的，它们提供了高效的查找、插入和删除操作，保证了元素的有序性。 STL中的红黑树实现与你提供的C++代码...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

tpoog

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

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

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

打赏作者

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

抵扣说明：

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

余额充值