STL —— map、set模拟实现

已于 2023-03-15 20:02:35 修改
阅读量396 收藏
点赞数
文章标签： c++ 算法 leetcode
于 2023-03-15 20:02:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_59913110/article/details/129550969
版权

目录

1.map和set的应用

2.红黑树的封装(部分功能)

3.map的封装(部分功能)

4.set的封装(部分功能)

5.完成代码

1.map和set的应用

map和set的使用通过查找相关文档即可熟悉。这里给出几道习题用于熟悉map和set的用法：

692. 前K个高频单词        使用map解题

KY264 单词识别        使用map解题

160. 相交链表        使用set解题

138. 复制带随机指针的链表        使用map解题

class Solution {
public:
    Node* copyRandomList(Node* head) {
        map<Node*,Node*> m;//map映射旧节点和新节点
        Node* cur = head;
        while(cur)
        {
            m[cur] = new Node(cur->val);//新节点使用旧节点的val值创建
            cur = cur->next;
        }

        cur = head;
        while(cur)
        {
            m[cur]->next = m[cur->next];//新节点的next指针是旧节点对应的v模型
            m[cur]->random = m[cur->random];//新节点的random指针是旧节点对应的v模型
            cur = cur->next;
        }
        return m[head];
    }
};

2.红黑树的封装(部分功能)

namespace ly
{
	enum Corlor	//枚举颜色
	{
		RED, BLACK
	};

	template <class KV>	//红黑树的节点并不知道KV到底是什么
	struct RBTreeNode
	{
		RBTreeNode<KV>* _left;
		RBTreeNode<KV>* _right;
		RBTreeNode<KV>* _parent;
		KV _data;
		Corlor _cor;

		RBTreeNode(const KV& data)
			:_left(nullptr), _right(nullptr), _parent(nullptr),
			_data(data), _cor(RED)
		{}
	};

	template<class KV,class Ref,class Ptr>//迭代器是指向某一节点的，所以其模板参数为KV
	struct RBTreeIterator//也就说迭代器也不知道指向的KV是什么
	{
		typedef RBTreeNode<KV> Node;
		typedef RBTreeIterator<KV, Ref, Ptr> Self;
		Node* _node;

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

		Ref operator*()//解引用就是返回一个KV的引用。至于怎么用，由调用的用户决定
		{
			return _node->_data;
		}

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

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

		// 如何实现迭代器++?
		Self& operator++()
		{
			if (_node->_right)//情况1，如果当前节点的右子树不为空
			{
				//很明显，下一个节点将是右子树中最左节点
				Node* min = _node->_right;
				while (min && min->_left)
				{
					min = min->_left;
				}
				_node = min;
			}
			else//情况2，当前节点的右子树为空
			{
				//那么迭代器就要往上找
				//中序遍历的顺序为 左 根 右
				//也就是说，如果当前节点是其父节点的左孩子
				//那么下一个位置其父节点
				//如果当前节点是其父节点的右孩子
				//说明中序遍历已经走完了，需要重复遍历

				Node* cur = _node;
				Node* parent = cur->_parent;
				while (parent && parent->_right == cur)
				{
					cur = parent;
					parent = cur->_parent;
				}
				_node = parent;
			}
			return *this;
		}
	};

	//使用三个参数兼容set和map使用一份红黑树
	//第一个参数可用作查找
	//第二个参数才是红黑树真正放的节点(要不为K，要不为KV)
	//第三个参数是从KV提取K的仿函数
	template <class K, class KV, class KOfKV>
	class RBTree
	{
	public:
		typedef RBTreeNode<KV> Node;
		typedef RBTreeIterator<KV, KV&, KV*> iterator;//普通迭代器
		typedef RBTreeIterator<KV, const KV&, const KV*> const_iterator;//const迭代器
		   
		iterator begin()
		{
			//最左节点便是第一个节点
			//也就是begin指向的节点
			Node* cur = _root;
			while (cur && cur->_left)
			{
				cur = cur->_left;
			}
			return iterator(cur);
		}
		iterator end()
		{
			//以空作为end迭代器
			return iterator(nullptr);
		}

		const_iterator begin() const
		{
			Node* cur = _root;
			while (cur && cur->_left)
			{
				cur = cur->_left;
			}
			return const_iterator(cur);
		}
		const_iterator end() const
		{
			return const_iterator(nullptr);
		}


		//insert返回键值对
		//注意，这里返回的迭代器都是普通迭代器
		pair<iterator,bool> insert(const KV& data)
		{
			KOfKV kof;//仿函数对象,负责提取KV中的K
			if (_root == nullptr)
			{
				_root = new Node(data);
				_root->_cor = BLACK;	//根节点的颜色必须是黑色
				return make_pair(_root, true);//插入成功second设为true
			}

			Node* parent = nullptr;
			Node* cur = _root;
			while (cur)
			{
				if (kof(data) < kof(cur->_data))
				{
					parent = cur;
					cur = cur->_left;
				}
				else if (kof(data) > kof(cur->_data))
				{
					parent = cur;
					cur = cur->_right;
				}
				else
				{
					return make_pair(cur,false);//存在则设为false
				}
			}

			cur = new Node(data);
			Node* ret = cur;//因为等会cur的位置会变，这里先记录一下
			cur->_cor = RED;	//新插入的节点颜色为红色
			if (kof(data) < kof(parent->_data))
			{
				parent->_left = cur;
				cur->_parent = parent;
			}
			else if (kof(data) > kof(parent->_data))
			{
				parent->_right = cur;
				cur->_parent = parent;
			}

			// 此时如果新插入的节点破坏了红黑树的性质，就必须做一些微调
			while (parent && parent->_cor == RED)
			{
				// 调整动作
				Node* grandfather = parent->_parent;
				if (grandfather->_left == parent)
				{
					Node* uncle = grandfather->_right;
					if (uncle && uncle->_cor == RED)
					{
						// 情况1

						parent->_cor = uncle->_cor = BLACK;
						grandfather->_cor = RED;

						cur = grandfather;
						parent = cur->_parent;
					}
					else	// unle不存在或uncle存在且为黑
					{
						if (parent->_left == cur)
						{
							// 情况2
							RotateR(grandfather);
							parent->_cor = BLACK;
							grandfather->_cor = RED;
						}
						else if (parent->_right == cur)
						{
							// 情况3
							RotateL(parent);
							RotateR(grandfather);
							cur->_cor = BLACK;
							grandfather->_cor = RED;
						}

						break;	//关键
					}
				}
				else if (grandfather->_right == parent)	//镜像即可
				{
					Node* uncle = grandfather->_left;
					if (uncle && uncle->_cor == RED)
					{
						parent->_cor = uncle->_cor = BLACK;
						grandfather->_cor = RED;

						cur = grandfather;
						parent = cur->_parent;
					}
					else
					{
						if (parent->_right == cur)
						{
							// 情况2
							RotateL(grandfather);
							parent->_cor = BLACK;
							grandfather->_cor = RED;
						}
						else if (parent->_left == cur)
						{
							// 情况3
							RotateR(parent);
							RotateL(grandfather);
							cur->_cor = BLACK;
							grandfather->_cor = RED;
						}
						break;	//关键
					}
				}
			}

			_root->_cor = BLACK;	//确保根节点颜色为黑色
			return make_pair(ret,true);
		}
	private:
		Node* _root = nullptr;


		void RotateL(Node* parent)
		{
			Node* cur = parent->_right;
			Node* curL = cur->_left;	//cur的左树

			parent->_right = curL;	//cur的左树变成parent的右树
			if (curL)
			{
				curL->_parent = parent;
			}

			Node* oldParent = parent->_parent;	//记录parent的父节点
			parent->_parent = cur;	//cur作为parent的父节点
			cur->_left = parent;	//parent作为cur的左树

			if (oldParent == nullptr)
			{
				_root = cur;	//直接让cur作为根节点(因为parent的旧父节点为空)
				cur->_parent = nullptr;
			}
			else
			{
				if (oldParent->_left == parent)
				{
					oldParent->_left = cur;
					cur->_parent = oldParent;
				}
				else if (oldParent->_right == parent)
				{
					oldParent->_right = cur;
					cur->_parent = oldParent;
				}
			}
		}

		void RotateR(Node* parent)
		{
			Node* cur = parent->_left;
			Node* curR = cur->_right;


			parent->_left = curR;	//cur的右树作为parent的左树
			if (curR)
			{
				curR->_parent = parent;
			}

			Node* oldParent = parent->_parent;
			parent->_parent = cur;
			cur->_right = parent;	//parent作为cur的右树

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

解析：迭代器的++算法。这里也有一道对应力扣的题：面试题 04.06. 后继者

3.map的封装(部分功能)

#include "RBTree.h"
namespace ly
{
	template<class K, class V>
	class map
	{
	public:
		struct KeyOfMap//提供给红黑树的仿函数
		{
			K operator()(const pair<const K, V>& kv)
			{
				return kv.first;
			}
		};

		//加上typename表示是某类中的类型而非静态变量
		typedef typename RBTree<K, pair<const K, V>, KeyOfMap>::iterator iterator;
		typedef typename RBTree<K, pair<const K, V>, KeyOfMap>::const_iterator const_iterator;

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

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

		const_iterator begin() const
		{
			return _rb.begin();
		}

		const_iterator end() const
		{
			return _rb.end();
		}

		pair<iterator, bool> insert(const pair<const K, V>& kv)
		{
			return _rb.insert(kv);
		}

		V& operator[](const K& k)
		{
			//只通过insert接口实现[]运算符重载
			//1.先使用临时变量接收insert的返回值
			pair<iterator, bool> p = insert(make_pair(k, V()));
			//2.p中的first就是迭代器，指向了insert的节点
			return p.first->second;
		}

	private:
		RBTree<K, pair<const K, V>, KeyOfMap> _rb;//红黑树对象
	};
}

4.set的封装(部分功能)

#include "RBTree.h"
namespace ly
{
	template<class K>
	class set
	{
	public:
		struct KeyOfSet//提供给红黑树的仿函数
		{
			K operator()(const K& k)
			{
				return k;
			}
		};

		//加上typename表示是某类中的类型而非静态变量
		//需要注意，通常我们不希望改变set中K值
		//所以set使用的迭代器都是const迭代器
		typedef typename RBTree<K, K, KeyOfSet>::const_iterator iterator;
		typedef typename RBTree<K, K, KeyOfSet>::const_iterator const_iterator;

		iterator begin() const
		{
			return _rb.begin();
		}

		iterator end() const
		{
			return _rb.end();
		}

		pair<iterator, bool> insert(const K& k)
		{
			/*又因为set使用的const迭代器
			而底层红黑树的insert接口返回的是普通迭代器
			而普通迭代器是不能类型转换成const迭代器的*/
			//return _rb.insert(k);

			//所以需要在底层的迭代器上做更改
			//使得普通迭代器能够构造出const迭代器
			//所以，第一步：先使用普通迭代器的pair对象接收返回值
			pair<typename RBTree<K, K, KeyOfSet>::const_iterator, bool> p = _rb.insert(k);
			//第二步：再用普通迭代器构造出const迭代器
			return pair<iterator, bool>(p.first, p.second);
		}


	private:
		RBTree<K, K, KeyOfSet> _rb;//红黑树对象
	};
}

修改后的迭代器模块：

template<class KV,class Ref,class Ptr>//迭代器是指向某一节点的，所以其模板参数为KV
	struct RBTreeIterator//也就说迭代器也不知道指向的KV是什么
	{
		typedef RBTreeNode<KV> Node;
		typedef RBTreeIterator<KV, Ref, Ptr> Self;
		
		//普通迭代器
		typedef RBTreeIterator<KV, KV&, KV*> iterator;
		Node* _node;

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

		//构造函数接收一个普通迭代器作为参数
		RBTreeIterator(const iterator& it)
			:_node(it._node)
		{}

		//...............省略.............

		
	};

5.完成代码

https://gitee.com/AVine/AVine_Code/tree/master/3_15%20%E5%B0%81%E8%A3%85map%E5%92%8Cset

小龙向钱进
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
windbg导出stl map和set的插件
07-28
可以在windbg导出stl map和set的插件，使用方法参考我csdn的博客http://blog.csdn.net/yichigo/article/details/38232511
LeetCode 复杂链表的复制
qq_62829518的博客
06-16 202
请实现 copyRandomList 函数，复制一个复杂链表。在复杂链表中，每个节点除了有一个 next 指针指向下一个节点，还有一个 random 指针指向链表中的任意节点或者 null。
LC第十天
weixin_44747789的博客
03-08 179
深拷贝！ 暴力法 直接AC ，而且效率还不错 哈希表 map用的太妙了 /* // Definition for a Node. class Node { public: int val; Node* next; Node* random; Node(int _val) { val = _val; next = NULL; random = NULL; } }; */ class...
leetcode复杂链表的复制
天启的博客
04-08 308
1.使用map 如果按照正常的链表复制那样做，由于存在随机节点，可能会出现环， 所以，使用map存在每一个节点与其随机指针的指向， 然后遍历map，复制链表 代码如下： /* // Definition for a Node. class Node { public: int val; Node* next; Node* random; N...
复杂链表的复制
weixin_39889618的博客
02-22 738
复杂链表的复制的难点就是如何把random节点的复制出来，正常链表的复制就是遍历链表，复制节点，但是这里有乱序节点，有可能当指针指向时还未生成该链表，所以可以用哈希表来存储节点，第一次遍历链表，将每个节点放入哈希表，同时，存入一个新的节点newNode(cur->val)，此时他作为value值只是一个单节点，没有next也没有random，而原来cur作为key，这里没一个节点包含一个完整的链表结构，拥有他的next和random，第一次遍历相当于，图1，构建原链表和新未连接的链表节点，第二次...
剑指 Offer 35. 复杂链表的复制
Wolf_xujie的博客
03-30 103
请实现 copyRandomList 函数，复制一个复杂链表。在复杂链表中，每个节点除了有一个 next 指针指向下一个节点，还有一个 random 指针指向链表中的任意节点或者 null。 示例 1： 输入：head = [[7,null],[13,0],[11,4],[10,2],[1,0]] 输出：[[7,null],[13,0],[11,4],[10,2],[1,0]] 示例 2： 输入：head = [[1,1],[2,1]] 输出：[[1,1],[2,1]] 示例 3： 输入：he
STL——map和set模拟实现
smx_dd的博客
01-26 325
map和set的底层是使用红黑树来实现的，接下来我利用红黑树来模拟实现一下map和set。 map详解博客链接：https://blog.csdn.net/smx_dd/article/details/86531881 set详解博客链接：https://blog.csdn.net/smx_dd/article/details/86555973 红黑树详解与实现博客链接：https://blog....
【C++】STL —— map和set的模拟实现
M的博客
11-29 806
【C++】STL —— map和set的模拟实现。
STL中vector类模拟实现
08-06
vector的模拟实现，非常适合初学者学习
STL中string类模拟实现源码
08-06
内容简介，涵盖内容广泛。源码实现参照STL源码。
STL.zip_Map 排序_STL_Table_stl map实现
09-24
源码之前了无秘密，你将看到vector的实现、list的实现、heap的实现、deque的实现、Red Black tree的实现、hash table的实现、set/map的实现;你将看到各种算法(排序、查找、排列组合、数据移动与复制技术)的实现;你...
浅析stl序列容器(map和set)的仿函数排序
09-05
有序的stl容器在工程中应用什么方便和广泛，但是当我们需要自己的排序的时候，可以用仿函数来设置它
初识C语言——第二十一天
硬件菜鸟的成长之路
05-15 622
1.rand()函数是只能生成伪随机数，并且无返回值，使用前需调用srand()伪随机数生成器作为起点2.time（）函数是结构体函数，返回值是64为整数类型，可以通过time函数生成时间戳时间戳-函数调用的时间点和计算机的初始时间点之间的时间间隔3.void（）函数-无返回值类型函数4.while(1)-一直循环，直到break跳出。
C语言.动态内存管理
Joseit的博客
05-16 591
栈区（stack）：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。堆区（heap）：一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS(操作系统)回收。分配方式类似于链表。数据段（静态区）：（static）存放全局变量、静态数据。程序结束后由系统释放。
【C++风云录】打破边界：心理学与情绪识别
记录我的学习历程
05-16 706
本文主要探讨了六种开发软件工具包，包括但不限于面部表情分析、心理学实验设计、图像处理、数据挖掘、情绪识别以及生物识别技术等各类关键功能，同时也涵盖了其在各自领域的应用。
【CCF-CSP】202312-4 宝藏
whaoe_m的博客
05-14 408
对于所有类型为 2的事件，输出一行四个非负整数 C1,1​,C1,2​,C2,1​,C2,2​，表示该时刻的密码 C。西西艾弗岛上埋藏着一份宝藏，小 C 根据藏宝图找到了宝藏的位置。由于小 C 并不会这个问题，他向你发起了求助。你需要帮助小 C 求出所有类型为 22 的事件所对应的密码。小 C 将所有的时刻发生的事件均记录了下来。输入的第一行包含两个正整数n,m。从标准输入读入数据。
C++ 11
qq_65112813的博客
05-17 658
对于类类型，如果定义了接受。
【C++】＜知识点＞ 类的大小计算
最新发布
致力于Linux的博客
05-18 118
C++中使用sizeof计算类大小的内在说明。
stl中map和set的原理
04-05
STL中的map和set都是基于红黑树实现的。 红黑树是一种自平衡二叉搜索树，它具有以下特点： 1. 每个节点要么是红色，要么是黑色。 2. 根节点是黑色的。 3. 每个叶子节点（NIL节点）是黑色的。 4. 如果一个节点是...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

小龙向钱进

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

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

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

打赏作者

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

抵扣说明：

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

余额充值