C++ map和set模拟实现

最新推荐文章于 2024-10-28 21:09:56 发布
最新推荐文章于 2024-10-28 21:09:56 发布
阅读量896 收藏 12
点赞数 9
分类专栏： C++修炼之路 文章标签： c++ 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_77934192/article/details/137741499
版权
本文详细介绍了如何改造红黑树以适应map和set的需求，包括添加仿函数处理键比较、改造插入函数以支持set和map的K/V操作，以及实现迭代器的++和--操作。
摘要由CSDN通过智能技术生成

💓博主CSDN主页:麻辣韭菜💓
 
⏩专栏分类：C++知识分享⏪
 
🚚代码仓库:C++高阶🚚
 
🌹关注我🫵带你学习更多C++知识
  🔝🔝

 

目录

前言

改造红黑树节点

 改造红黑树

仿函数

 插入函数改造

迭代器 

 ++ -- 重载

​编辑

迭代器再次改造插入函数 

 map【】重载

 

前言

前面我们实现了红黑树，本篇就讲map和set的底层是怎么用红黑树来进行封装的！！！

我们要模拟实现map和set需要改造之前的红黑树，因为set只有一个K，而我们的红黑树模板参数是2个一个T和一个V。

改造红黑树节点

enum Color
{
	RED,
	BLACK,
};

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

	RBTreeNode(const T& data)
		:_left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _data(data)
		, _col(RED) //为什么默认是红色？根节点必须是黑色，这就意味着默认给黑色那么调整次数就会变多。
	{}
};

 改造红黑树

我们先来看看stl源码中map和set是怎么定义的 

 

这样设计就很完美 你用set 两个都是K，我们只需要拿第一个K，你用map 第一个是K，第二个是V。

这里就问题了，插入比较大小时，按照原来的红黑树来说，只能是map兼容。set不行。

我们可以加仿函数，set返回它的K，map返回它的first。 当然这里插入函数也是要改造的。

仿函数

#pragma once
#include "RBTree.h"

namespace gx
{
	template <class K, class V>
	class map
	{
		struct MapKeyofT
		{
			const K& operator()(const pair<const K, V>& kv)
			{
				return kv.first;
			}
		};
    private:
	RBTree<K, pair<const K, V>, MapKeyOfT> _t;
	};
}

#pragma once
#include "RBTree.h"


namespace gx
{
	template<class K>
	class set
	{
		struct SetKeyofT
		{	
			const K& operator()(const K& key)
			{
				return  key;
			}
		};
	private:
		RBTree<K, K, SetKeyofT> _t;
	};
}

template <class K, class T, class KeyofT>
class RBTree
{
	typedef RBTreeNode<T> Node;
private:
	Node* _root = 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);
		//判断k的值是大于还是小于父亲的k值
		if (kot(parent->_data) > kot(data))
		{
			parent->_left = cur;
		}
		else
		{
			parent->_right = cur;
		}
		cur->_parent = parent;

		while (parent && parent->_col == RED)
		{
			Node* grandfather = parent->_parent;
			if (grandfather->_left == parent)
			{
				Node* uncle = grandfather->_right;
				// 情况1：u存在且为红，变色处理，并继续往上处理
				if (uncle && uncle->_col == RED)
				{
					parent->_col = BLACK;
					uncle->_col = BLACK;
					grandfather->_col = RED;

					// 继续往上调整
					cur = grandfather;
					parent = cur->_parent;
				}
				else // 情况2+3：u不存在/u存在且为黑，旋转+变色
				{
					//     g
					//   p   u
					// c 
					if (cur == parent->_left)
					{
						RotateR(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else
					{
						//     g
						//   p   u
						//     c
						RotateL(parent);
						RotateR(grandfather);
						cur->_col = BLACK;
						//parent->_col = RED;
						grandfather->_col = RED;
					}

					break;
				}
			}
			else // (grandfather->_right == parent)
			{
				//    g
				//  u   p
				//        c
				Node* uncle = grandfather->_left;
				// 情况1：u存在且为红，变色处理，并继续往上处理
				if (uncle && uncle->_col == RED)
				{
					parent->_col = BLACK;
					uncle->_col = BLACK;
					grandfather->_col = RED;

					// 继续往上调整
					cur = grandfather;
					parent = cur->_parent;
				}
				else // 情况2+3：u不存在/u存在且为黑，旋转+变色
				{
					//    g
					//  u   p
					//        c
					if (cur == parent->_right)
					{
						RotateL(grandfather);
						grandfather->_col = RED;
						parent->_col = BLACK;
					}
					else
					{
						//    g
						//  u   p
						//    c
						RotateR(parent);
						RotateL(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}

					break;
				}
			}
		}

		_root->_col = BLACK;

		return true;
	}

运行没有问题，同时兼容set和map问题解决了，接下来就是要实现迭代器。我们先实现红黑树的迭代器。 

迭代器 

我们构建一个迭代器的类 然后再红黑树这个类里面 typedef 这个迭代器类

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

* 、->、 ！= 这三个运算符重载很好写关键是++和-- 这个两个有点复杂，直接给代码cpu直接干烧。我们画图理解 

 

 ++ -- 重载

 这里以++举例 

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 && parent->_right == cur) //当条件不满足的时候说明父亲就是爷爷左子树
			{
				cur = parent;
				parent = parent->_parent;
			}
			//循环结束说明我们已经找到了这时在把值赋值给_node
			_node = parent;
		}
	}
};
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 && parent->_left == cur) //当条件不满足的时候说明父亲就是爷爷右子树
			{
				cur = parent;
				parent = parent->_parent;
			}
			//循环结束说明我们已经找到了这时在把值赋值给_node
			_node = parent;
		}
	}

我们先用封装set


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;
	iterator begin()
	{
		Node* cur = _root;
		while (cur && cur->_left)
		{
			cur = cur->_left
		}
		return iterator(cur);
	}
	iterator end()
	{
		return iterator(nullptr);
	}

 验证一下写的对不对

我们再封装map

namespace gx
{
	template <class K, class V>
	class map
	{
		struct MapkeyofT
		{
			const K& operator()(const pair<const K, V>& kv)
			{
				return kv.first;
			}
		};
	public:
		typedef typename RBTree<K, pair<const K, V>, MapkeyofT>::iterator iterator;
		
		iterator begin()
		{
			return _t.begin();
		}
		iterator end()
		{
			return _t.end();
		}
		bool insert(const pair<const K,V>& kv)
		{
			return _t.Insert(kv);
		}

	private:
		RBTree<K, pair<const K, V>, MapkeyofT> _t;
	};
	void test_map1()
	{
		int a[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };
		map<int, int> m;
		for (auto e : a)
		{
			m.insert(make_pair(e, e));
		}
		map<int, int>::iterator it = m.begin();
		while (it != m.end())
		{
			cout << it->first << ":" << it->second << endl;
			++it;
		}
		cout << endl;
	}
}

但是这里就有个问题 set 我们是可以修改的，我们需要再对迭代器再进行优化，让set不能修改。

我们来看看源码是怎么写的 

 

 我们可以看到源码的set 普通迭代器和const迭代器都是用的红黑树的const的迭代器。

 那我们也把自己set迭代器都改成const迭代器

namespace gx
{
	template<class K>
	class set
	{

		struct SetKeyofT
		{	
			const K& operator()(const K& key)
			{
				return  key;
			}
		};
	public:
		typedef typename RBTree<K, K, SetKeyofT>::const_iterator iterator;
		typedef typename RBTree<K, K, SetKeyofT>::const_iterator const_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;
	};

 

这时就出问题了，普通迭代器的参数没有办法转换成const迭代器。怎么解决？

 在迭代器类 加上这段代码

_RBTreeiterator(const _RBTreeiterator<T,  T&,  T*>& it)
		:_node(it._node)
	{}

 如何理解这段代码


1、typedef __RBTreeIterator<T, T&, T*> itertaor; 拷贝构造

2、 typedef __RBTreeIterator<T, const T&, const T*> const_itertaor;支持普通迭代器构造const迭代器的构造函数

迭代器再次改造插入函数 

源码的map和set是支持迭代器插入，而我们的之前的返回类型是bool明显不支持

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;
		//判断k的值是大于还是小于父亲的k值
		if (kot(parent->_data) > kot(data))
		{
			parent->_left = cur;
		}
		else
		{
			parent->_right = cur;
		}
		cur->_parent = parent;

		while (parent && parent->_col == RED)
		{
			Node* grandfather = parent->_parent;
			if (grandfather->_left == parent)
			{
				Node* uncle = grandfather->_right;
				// 情况1：u存在且为红，变色处理，并继续往上处理
				if (uncle && uncle->_col == RED)
				{
					parent->_col = BLACK;
					uncle->_col = BLACK;
					grandfather->_col = RED;

					// 继续往上调整
					cur = grandfather;
					parent = cur->_parent;
				}
				else // 情况2+3：u不存在/u存在且为黑，旋转+变色
				{
					//     g
					//   p   u
					// c 
					if (cur == parent->_left)
					{
						RotateR(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else
					{
						//     g
						//   p   u
						//     c
						RotateL(parent);
						RotateR(grandfather);
						cur->_col = BLACK;
						//parent->_col = RED;
						grandfather->_col = RED;
					}

					break;
				}
			}
			else // (grandfather->_right == parent)
			{
				//    g
				//  u   p
				//        c
				Node* uncle = grandfather->_left;
				// 情况1：u存在且为红，变色处理，并继续往上处理
				if (uncle && uncle->_col == RED)
				{
					parent->_col = BLACK;
					uncle->_col = BLACK;
					grandfather->_col = RED;

					// 继续往上调整
					cur = grandfather;
					parent = cur->_parent;
				}
				else // 情况2+3：u不存在/u存在且为黑，旋转+变色
				{
					//    g
					//  u   p
					//        c
					if (cur == parent->_right)
					{
						RotateL(grandfather);
						grandfather->_col = RED;
						parent->_col = BLACK;
					}
					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);;
	}

 这时set插入函数也是需要改

 

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

 map【】重载

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

 

 封装到这里就结束了，其他的插入和删除4个默认函数都是比较简单的，这里博主就不在细讲了，我们理解底层原理就行不要较真 前人已经给我们造好轮子了，我们就不要深究了。

代码 为了方面大家阅读，我做了拆分，完整代码大家可以去看我码云，码云在顶页有链接

下期预告：

哈希

 

 

 

 

麻辣韭菜
关注
专栏目录
c++ - 模拟实现set、map
2302_79539362的博客
08-02 769
c++ - 模拟实现set、map
C++ Map Set的模拟实现
m0_52420323的博客
07-23 1175
摘要：C++，数据结构，Map，Set
C++之STLmap和set的模拟实现
小赵小赵福星高照的博客
03-21 1080
模拟实现map和set 文章目录模拟实现map和set源码中红黑树的结构模板参数中的仿函数红黑树的迭代器的模拟实现迭代器的基本结构红黑树的迭代器的整体代码map的模拟实现set的模拟实现 我们首先来看一下源码当中的set和map的结构： template <class Key,class Compare = less<Key>, class Alloc = alloc> class set { public: typedef Key key_type; typedef
C++红黑树模拟实现map和set
~
04-01 3950
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
一只小卷毛的博客
04-11 734
基于之前的红黑树和map、set的相关知识，本节我们使用红黑树来模拟实现STL中的map和set。
【C++】map和set的模拟实现
EWIAW_ilove的博客
07-09 842
在本篇博客中，作者将会带领你C++STL库中的，其中我只实现一些比较重要的成员函数，在进行之前，你需要先懂得，因为map和set的。
C++学习进阶：map和set的实现
weixin_73234157的博客
12-14 1066
我们知道set和map的底层其实是红黑树，在学习完红黑树这个数据结构之后，我们开始简单模拟实现一下这两个STL容器。
【C++】map 和 set
在平淡的日子里寻找存在的价值
03-24 1150
map/multimap 的使用以及 set/multiset 的使用
【C++】Map、Set 模拟实现
m0_65679465的博客
05-28 1214
map、set 是 C++ 中的关联式容器，由于 map 和set所开放的各种操作接口，RB-tree 也都提供了，所以几乎所有的 map 和set的操作行为，都只是转调红黑树的操作行为。本文对 Map、Set 进行模拟实现，可以深入的理解这两个关联式容器的底层原理！
map和set的模拟实现
06-06
在IT领域，数据结构是编程的基础，...总之，通过封装红黑树并结合C++的面向对象特性，我们可以构建出高性能的Map和Set模拟实现。这不仅可以加深对数据结构和算法的理解，也有助于在实际项目中构建高效的数据处理机制。
C++红黑树封装实现map和set模拟
本资源将通过封装红黑树来模拟实现map和set。红黑树是一种自平衡的二叉搜索树，通过对插入和删除操作的特定处理，它可以保证最坏情况下的时间复杂度为O(log n)，这对于需要高效搜索和插入操作的场景非常有用。 在...
模拟实现unordered_map和unordered_set超详解（C++）
m0_67430750的博客
05-19 2268
模拟实现unordered_map、unordered_set超详解，包括哈希表以及unordered_map、unordered_set完整代码，迭代器封装、功能测试等。
【C++】map/set
knous
08-01 293
map、set的一些理解
C++ 使用哈希表封装模拟实现unordered_map unordered_set
TPON的博客
11-17 886
C++实现哈希表封装unordered_map unordered_set
C++：文件存储
weixin_44110080的博客
10-23 209
这是 fstream 最常见的使用方式。当我们使用 << 运算符或 write() 函数写入文件时,数据首先会被写入到缓冲区中,等缓冲区满或者程序结束时,缓冲区的内容才会一次性写入到磁盘文件中。这种方式可以提高写入效率,减少与磁盘的交互次数。如果是windows系统可以直接使用自带的WriteFile接口写文件。
【最新华为OD机试E卷-支持在线评测】二叉树计算 (200分)多语言题解-(Python/C/JavaScript/Java/Cpp)
春秋招笔试突围
10-28 7
🍭 大家好这里是，一枚热爱算法的程序员💻 ACM金牌🏅️团队 ｜ 大厂实习经历 ｜ 多年算法竞赛经历✨ 本系列打算持续跟新的多语言AC题解🧩 大部分包含PythonCJavascriptJavaCpp多语言代码。
C++模板、STL
一+一加1的博客
10-24 621
C++模板、STL
「C/C++」C++17 之 std::optional 值管理器（判断值存不存在）
何曾参静谧的博客
10-24 1139
std::optional是C++17引入的一个非常有用的工具，它提供了一种优雅的方式来表示可能存在，也可能不存在的值。它避免了使用特殊值（如NULL或-1）来表示“无值”状态所带来的类型不安全、语义不明确和错误处理复杂等问题。std::optional的使用场景广泛，包括但不限于函数返回值、配置项可能未设置时、缓存结果可能不存在时等。
「C/C++」C/C++标准库之#include＜cstdlib＞通用工具库
最新发布
何曾参静谧的博客
10-28 261
是C++标准库中的一个头文件，它提供了各种通用工具函数，这些函数最初来源于C标准库中的，并在C++中进行了标准化和扩展。在C++编程中，头文件具有重要地位，它涵盖了字符串转换、类型转换、随机数生成、内存管理和系统调用等多个方面的功能。通过这些实例，我们可以看到头文件在C++编程中的广泛应用。它提供了一系列功能强大的函数，使得开发者能够方便地处理字符串转换、随机数生成、内存管理等任务。在实际开发中，合理利用这些函数可以大大提高编程效率和代码质量。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值