c++ map set底层模拟实现

最新推荐文章于 2024-07-05 16:01:52 发布
最新推荐文章于 2024-07-05 16:01:52 发布
阅读量438 收藏 7
点赞数 6
文章标签： c++ 算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/l23456789mmmmm/article/details/139811721
版权

关于这两个数据结构的insert接口实现 请看这篇文章  https://blog.csdn.net/l23456789mmmmm/article/details/139500413?spm=1001.2014.3001.5501

map::operator[]底层实现请看这篇文章 c++map类operator[]详解_c++ map operator-CSDN博客

红黑树模拟实现

#pragma once
#include <vector>
#include <iostream>
#include <queue>

namespace mystl {
	enum COLOR {
		RED,
		BLACK
	};

	template<class K,class V>
	struct ListNode {				// 节点
		//typedef ListNode<K, V> node;
		using Node = ListNode<K, V>;
		ListNode(std::pair<K,V> kv):_kv(kv) {
			_parent = _left = _right = nullptr;
			_color = RED;
		}
		Node* _parent;
		Node* _left;
		Node* _right;
		std::pair<K, V> _kv;
		COLOR _color;
	};
	template<class K,class V,class Ref = V& ,class Ptr = V*>
	struct RBTree_Iterator {			//迭代器
		using Node = ListNode<K, V>;
		using iterator = RBTree_Iterator<K, V>;
		RBTree_Iterator(Node* node) {
			_node = node;
		}
		Ref operator*() {
			return _node->_kv.second;
		}
		Ptr operator->() {
			//return &(this->operator*());
			return &(_node->_kv.second);
		}
		bool operator!=(iterator it) {
			return _node != it._node;
		}
		iterator operator++() {
			if (_node->_right) {
				Node* leftMin = _node->_right;
				while (leftMin->_left) {
					leftMin = leftMin->_left;
				}
				_node = leftMin;
			}
			else
			{
				Node* cur = _node;
				Node* parent = cur->_parent;
				while (parent && cur == parent->_right)
				{
					cur = parent;
					parent = parent->_parent;
				}

				_node = parent;
			}

			return *this;
		}
		Node* _node;
	};
	template<class K,class V,class Compare = std::less<K>> // class Alloc = std::allocator<pair<const K, V> > > 这个是空间适配器,先不理他
	class RBTree {						// 红黑树
		using Node = ListNode<K, V>;
	public:
		using iterator = RBTree_Iterator<K, V, V&, V*>;
		using const_iterator = RBTree_Iterator<K, V, const V&, const V*>;
		Node* GetRoot() {
			return _root;
		}
		size_t Size() {
			return _size;
		}
		void print() {
			std::queue<Node*> s1 ,s2;
			s1.push(_root);
			while (!s1.empty()) {
				while (!s1.empty()) {
					if (s1.front()) {
						s2.push(s1.front()->_left);
						//std::cout << s1.front()->_kv.first <<' ';
						printf("   %d : %d   ", s1.front()->_kv.first, s1.front()->_color);
						s2.push(s1.front()->_right);
					}
					else {
						printf("   #   ");
					}

					s1.pop();
				}
				std::swap(s1, s2);
				std::cout << std::endl;
			}
		}
		std::pair<iterator,bool> insert(const std::pair<K, V>& kv) {
			Node* new_node = new Node(kv);
			_size++;
			if (_root == nullptr) {
				new_node->_color = BLACK;
				_root = new_node;
				return std::make_pair(iterator(new_node), true);
			}
			Node* child = _root;
			Node* father = _root;	// 父子交替,找 新节点应该插入的地方
			while (child) {			//儿子不是空
				father = child;
				if (child->_kv.first > kv.first) {
					child = child->_left;
				}
				else if (kv.first > child->_kv.first) {
					child = child->_right;
				}
				else {
					
					_size--;
					return std::make_pair(iterator(child), false);
				}
			}
			//此处儿子是空,代表新节点应该插入的地方
			add_node(father, new_node);
			//对插入的节点进行检查,不合理的地方重构
			reconstitution(new_node);
			return std::make_pair(iterator(new_node), true);

		}
		bool IsValidRBTree()
		{
			Node* pRoot = GetRoot();
			// 空树也是红黑树
			if (nullptr == pRoot)
				return true;
			// 检测根节点是否满足情况
			if (BLACK != pRoot->_color)
			{
				std::cout << "违反红黑树性质二：根节点必须为黑色" << std::endl;
				return false;
			}
			// 获取任意一条路径中黑色节点的个数
			size_t blackCount = 0;
			Node* pCur = pRoot;
			while (pCur)
			{
				if (BLACK == pCur->_color)
					blackCount++;
				pCur = pCur->_left;
			}
			// 检测是否满足红黑树的性质，k用来记录路径中黑色节点的个数
			size_t k = 0;
			return _IsValidRBTree(pRoot, k, blackCount);
		}
		V& operator[](const K key) {
			return insert({ key,V() }).first->second;
		}
		iterator begin() {
			Node* tmp = _root;
			while (tmp && tmp->_left) {
				tmp = tmp->_left;
			}
			return tmp;
		}
		iterator end() {
			return nullptr;
		}
		const_iterator cbegin() {
			Node* tmp = _root;
			while (tmp && tmp->_left) {
				tmp = tmp->_left;
			}
			return tmp;
		}
		const_iterator cend() {
			return nullptr;
		}
	protected:
		void add_node(Node* father, Node* new_node) {
			if (new_node->_kv.first > father->_kv.first) {
				father->_right = new_node;
			}
			else {
				father->_left = new_node;
			}
			new_node->_parent = father;
		}
		void reconstitution(Node* new_node) {
			/*
			1. 每个结点不是红色就是黑色 
			2. 根节点是黑色的  
			3. 如果一个节点是红色的，则它的两个孩子结点是黑色的  
			4. 对于每个结点，从该结点到其所有后代叶结点的简单路径上，均 包含相同数目的黑色结点  
			5. 每个叶子结点都是黑色的(此处的叶子结点指的是空结点)
			*/
			if (new_node == _root) {
				return;
			}
			if (new_node->_parent->_color == BLACK)	
				// 父亲是黑色,插入红色节点,符合红黑树要求,不做处理
				return;
			// 父亲是红色,此时不符合条件三,需要发生重构
			Node* parent = new_node->_parent;				// 新节点的父节点
			Node* grandparent = new_node->_parent->_parent; // 爷爷节点
			Node* uncle = nullptr;							// 叔叔节点
			if (grandparent->_left == parent) {				// 叔叔节点需要通过父亲节点与爷爷节点的关系来判断
				uncle = grandparent->_right;			
			}
			else {
				uncle = grandparent->_left;
			}
			

			// 判断情况
			if (uncle == nullptr || uncle->_color == BLACK) {							// 叔叔为空,需要发生旋转
				Node* tmp = revorve(new_node, parent, grandparent);
				if (tmp == _root) {
					tmp->_color = BLACK;
				}
				else {
					reconstitution(tmp);
				}
			}
			else if (uncle->_color == RED) {
				// 叔叔为红色 需要改变颜色,并继续向上重构,因为新的爷爷节点被强制改为红色,需要继续向上重构
				uncle->_color = parent->_color = BLACK;
				if (grandparent != _root) {
					// 爷爷节点不为root的话
					grandparent->_color = RED;
					reconstitution(grandparent);
				}
			}
			//else {	// 叔叔节点为黑色
			//	// 旋转
			//	reconstitution(revorve(new_node, parent, grandparent));
			//}
		}
		Node* revorve(Node* node,Node* parent,Node* grandparnt) {
			if (node == parent->_left && parent == grandparnt->_left) {
				// 子为父左，父为爷左，右旋父
				revorveR(parent);
				node->_color = BLACK;
				return parent;
			}
			else if(node == parent->_left && parent == grandparnt->_right) {
				// 子为父左，父为爷右，右旋子，左旋子
				revorveR(node);
				revorveL(node);
				parent->_color = BLACK;
				return node;
			}
			else if (node == parent->_right && parent == grandparnt->_right) {
				// 子为父右，父为爷右，左旋父
				revorveL(parent);
				node->_color = BLACK;
				return parent;

			}
			else {
				// 子为父右，父为爷左，左旋子，右旋子
				revorveL(node);
				revorveR(node);
				parent->_color = BLACK;
				return node;

			}
		}
		void revorveL(Node* node)
		{
			// 左旋需要改变node节点的 1.本身 2.父节点 3.爷爷节点 4.左孩子节点 共计四个节点
			// 记录四个节点的值，防止等下修改时混乱
			Node* parent = node->_parent;
			Node* grandparent = parent->_parent;
			Node* leftchild = node->_left;
			// 1.修改本身节点
			node->_parent = grandparent;
			node->_left = parent;

			// 2.修改父节点
			parent->_parent = node;
			parent->_right = leftchild;
			if (parent == _root)
				_root = node;

			// 3. 修改爷爷节点
			if (grandparent != nullptr) {
				if (grandparent->_left == parent)
					grandparent->_left = node;
				else {
					grandparent->_right = node;
				}
			}

			// 4. 修改左孩子节点
			if(leftchild != nullptr)
				leftchild->_parent = parent;
		}
		void revorveR(Node* node)
		{
			// 右旋需要改变node节点的 1.本身 2.父节点 3.爷爷节点 4.右孩子节点 共计四个节点
			// 记录四个节点的值，防止等下修改时混乱
			Node* parent = node->_parent;
			Node* grandparent = parent->_parent;
			Node* rightchild = node->_right;
			// 1.修改本身节点
			node->_parent = grandparent;
			node->_right = parent;

			// 2.修改父节点
			parent->_parent = node;
			parent->_left = rightchild;

			// 3. 修改爷爷节点
			if (grandparent != nullptr) {
				if (grandparent->_left == parent)
					grandparent->_left = node;
				else {
					grandparent->_right = node;
				}
			}

			// 4. 修改右孩子节点
			if(rightchild!=nullptr)
				rightchild->_parent = parent;
		}
		bool _IsValidRBTree(Node* pRoot, size_t k, const size_t blackCount) {
			//走到null之后，判断k和black是否相等
			if (nullptr == pRoot)
			{
				if (k != blackCount)
				{
					std::cout << "违反性质四：每条路径中黑色节点的个数必须相同" << std::endl;
					return false;
				}
				return true;
			}
			// 统计黑色节点的个数
			if (BLACK == pRoot->_color)
				k++;
			// 检测当前节点与其双亲是否都为红色
			Node* pParent = pRoot->_parent;
			if (pParent && RED == pParent->_color && RED == pRoot->_color)
			{
				std::cout << "违反性质三：没有连在一起的红色节点" << std::endl;
				return false;
			}
			return _IsValidRBTree(pRoot->_left, k, blackCount) &&
				_IsValidRBTree(pRoot->_right, k, blackCount);
		}
		
	private:
		Node* _root = nullptr;
		size_t _size = 0;
	};
}

set封装

#pragma once
#include "RBTree.h"
namespace mystl {
	template<class K>
	class set {
	public:
		using RBT = RBTree< const K, K>;
		using iterator = RBTree_Iterator<const K, K, K&, K*>;
		using const_iterator = RBTree_Iterator<const K, K, const K&, const K*>;
		iterator begin() {
			return _Tree.begin();
		}
		iterator end() {
			return _Tree.end();
		}
		const_iterator cbegin() const {
			return _Tree.cbegin;
		}
		const_iterator cend() const {
			return _Tree.cend();
		}
		bool operator != (set<K>& newset) {
			return _Tree != newset._Tree;
		}
		std::pair<iterator, bool>& insert(const K k) {
			return _Tree.insert(std::make_pair(k,k));
		}
		iterator find(const K& key) {
			return insert({ key,key }).first;
		}
		size_t size() {
			return _Tree.Size();
		}
		bool IsRBTree() {
			return _Tree.IsValidRBTree();
		}

	private:
		RBT _Tree;
	};
}

map封装

#pragma once
#include "RBTree.h"
namespace mystl {
	template<class K,class V>
	class map { 
		
	public:
		using RBT = RBTree< const K, std::pair<const K, V>>;
		using iterator = RBTree_Iterator<const K, std::pair<const K, V>, std::pair<const K,V>&,std::pair<const K, V> *>;
		using const_iterator = RBTree_Iterator<const K, std::pair<const K, V>, const std::pair<const K, V>&,const std::pair<const K, V>*>;
		
		iterator begin() {
			return _Tree.begin();
		}
		iterator end() {
			return _Tree.end();
		}
		const_iterator cbegin() const {
			return _Tree.cbegin;
		}
		const_iterator cend() const {
			return _Tree.cend();
		}
		std::pair<iterator, bool> insert(const std::pair<K, V> &kv) {
			return _Tree.insert({ kv.first,kv });
		}
		iterator find(const K& key) {
			return insert({key,V()}).first;
		}
		bool operator != (const map<K,V>& newmap) {
			return _Tree != newmap._Tree;
		}
		V& operator[](const K& key) {
			//_Tree.insert(std::pair<key,std::pair<key,V()> >);
			iterator ret = _Tree.insert({key,{key,V()}}).first;
			//iterator ret = _Tree.insert({ key,{key,V()} }).first;

			//std::pair<iterator, bool> ret = _Tree.insert(std::make_pair(key, V()));
			return ret._node->_kv.second.second;
		}
		size_t size() {
			return _Tree.Size();
		}
		bool IsRBTree() {
			return _Tree.IsValidRBTree();
		}

	private:
		RBT _Tree;
	};
}

好好学习O(∩_∩)O
关注
  • 6
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
map和set的模拟实现
06-06
在IT领域，数据结构是编程的基础，...总之，通过封装红黑树并结合C++的面向对象特性，我们可以构建出高性能的Map和Set模拟实现。这不仅可以加深对数据结构和算法的理解，也有助于在实际项目中构建高效的数据处理机制。
面试题_编程面试_C++_
10-02
5. **STL（Standard Template Library）**：C++的STL包含容器（如vector, list, set, map等）、算法（如排序、查找）和迭代器。熟悉STL能提高代码效率。 6. **异常处理**：理解try-catch-finally语句块，以及何时...
数据结构的C++算法实现
02-24
C++的`std::unordered_set`和`std::unordered_map`提供哈希表实现，具有O(1)的平均查找时间。 5. **排序与查找**： - **排序算法**：快速排序、归并排序、堆排序、冒泡排序、选择排序等是常见的排序算法，C++的`...
C++入门大礼包-入门版-FreeVersion
02-17
标准模板库（STL）是C++中的一个强大工具，包括容器（如vector、list、set和map）、迭代器、算法和函数对象。STL可以帮助编写简洁、高效且易于维护的代码。例如，vector提供了动态数组的功能，而list则是一个双向...
C++课设大学生
06-19
4. **STL（Standard Template Library）**：STL是C++的标准库，包含了容器（如vector、list、set、map等）、算法和迭代器等工具，为程序员提供了丰富的数据结构和算法，极大地提高了编程效率。 5. **异常处理**：...
C++初学者指南-3.自定义类型(第一部分)-析构函数
silencestarsky的博客
07-02 592
本文介绍了C++初学者指南中关于自定义类型和析构函数的重要内容。主要涵盖了特殊的成员函数如构造函数和析构函数的作用，RAII资源管理的重要性以及避免编写特殊成员函数的建议。
19.【C语言】初识指针（重难点）
2401_85828611的博客
07-02 338
不同数据类型的指针的大小是相同的，因为指针存放地址，指针的大小取决于地址的大小。如F8的地址为00BCB900+08,所以是00BCB908(偏移)&a:取变量a在内存中的地址（实际上取的是a的第一个字节的地址）结果全是4-->4byte=32bit（32位选的是x86）显然一个F8占用8bit（1111 1000）是一个byte。指针变量名称=&变量名称;//指针变量用于存放地址。想要定位某个数字 ，需要知道地址(类比二维坐标)内存：所有程序的运行在内存中。如果是64位结果全是8。
C++ | Leetcode C++题解之第207题课程表
Ddddddd_158的博客
07-01 356
C++ | Leetcode C++题解之第207题课程表
关键路径——C语言（理论）
2302_80790488的博客
06-28 790
关键路径，是项目网络中从起始事件到终止事件的最长路径，决定了项目的最短完成时间。 关键路径中的任务没有任何可调整的余地，如果任何一个任务被延迟，整个项目的完成时间也会被延迟。
C++ 成员模板类
qq_40135848的博客
06-30 465
C++ 成员模板类
c++函数（三）习题讲解
m0_62681656的博客
07-01 401
ave 函数传递了两个数据类型的参数，一个是 int 类型，一个是 float 类型，在进行运算的时候会发生类型转换，而 float 类型的优先级要大于 int 类型，所以返回的是 float 类型，那为什么不是引用类型呢？解析：这道题考察预处理指令，#define _H_ 定义了一个 宏，#ifdef _H_判断宏存在，之后 执行 a++ ，之后又执行 a++ ，结果 a = 102，选C。解析：这道题考查的是 当模板函数和 重载函数同时存在时，他俩的优先级的高低，更快，但同样不支持可变数量的参数。
vector：：C++
qq_68308828的博客
07-02 171
是一个非常灵活和高效的容器，适用于需要动态数组功能的场景。它提供了丰富的操作函数，可以方便地进行元素的插入、删除和访问。熟悉并掌握的用法是 C++ 编程的重要技能之一。
机器人运动范围检测 c++
m0_61862494的博客
07-02 723
地上有一个m行n列的方格，一个机器人从坐标（0，0）的格子开始移动，它每次可以向上下左右移动一个格子，但不能进入行坐标和列坐标的位数之和大于k的格子，请问机器人能够到达多少个格子。这个算法的时间复杂度为O(mn)，其中m和n分别是网格的行数和列数。空间复杂度也是O(mn)，主要用于存储visited数组和BFS队列。这个实现使用了广度优先搜索（BFS）算法来解决问题。
区间动态规划——最长回文子序列长度（C++）
m0_73962294的博客
07-01 589
把夜熬成粥，然后喝了它。
C语言 求最大公约数和最小公倍数
Random_N1的博客
06-30 617
这个程序定义了两个函数，一个用于计算两个正整数的最大公约数 (GCD)，另一个用于计算最小公倍数 (LCM)。在主函数中读取用户输入的两个正整数，并调用这两个函数输出结果。
C++怎么解决不支持字符串枚举？
m0_59680769的博客
07-02 288
首先，有两种方法：使用命名空间和字符串常量与使用enum class和辅助函数。
Python123:计算天数、查找指定字符、字符串逆序（C语言）
chat8052的博客
07-02 783
Python123:计算天数、查找指定字符、字符串逆序（C语言）
C语言 do while 循环语句练习 中
最新发布
2401_84378523的博客
07-05 119
注：使用Sleep首字母必须大写，引用头函数#include <windows.h>，Sleep是延时函数，用来做延时效果。使用system需应用头函数。
WPF UI 3D 多轴 机械臂 stl 模型UI交互
cao919的专栏Net
07-02 335
鼠标交互（没有强调场景的变换）鼠标命中测试（HitTest 不推荐）平面对象加载数据绑定（数据与动作）顶部控件多轴控制uiui后端效果。
c++ map的底层实现原理
07-28
C++ 中的 `std::map` 是一种关联容器，它基于红黑树实现。红黑树是一种自平衡的二叉搜索树，它具有...总结起来，C++ 的 `std::map` 使用红黑树作为底层实现，通过自平衡的红黑树结构实现了高效的查找、插入和删除操作。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值