map和set的模拟实现｜利用红黑树封装map和set｜STL源码剖析

news2024/11/28 2:37:05

前言

那么这里博主先安利一些干货满满的专栏了！

首先是博主的高质量博客的汇总，这个专栏里面的博客，都是博主最最用心写的一部分，干货满满，希望对大家有帮助。

高质量干货博客汇总icon-default.png?t=N6B9https://blog.csdn.net/yu_cblog/category_12379430.html?spm=1001.2014.3001.5482这两个都是博主在学习Linux操作系统过程中的记录，希望对大家的学习有帮助！

操作系统Operating Syshttps://blog.csdn.net/yu_cblog/category_12165502.html?spm=1001.2014.3001.5482Linux Syshttps://blog.csdn.net/yu_cblog/category_11786077.html?spm=1001.2014.3001.5482这两个是博主学习数据结构的同时，手撕模拟STL标准模版库各种容器的专栏。

STL源码剖析https://blog.csdn.net/yu_cblog/category_11983210.html?spm=1001.2014.3001.5482手撕数据结构https://blog.csdn.net/yu_cblog/category_11490888.html

Map和Set的底层是什么

在C++ STL中，map和set底层通常是使用红黑树（Red-Black Tree）来实现的。

红黑树是一种自平衡的二叉搜索树，它通过在每个节点上存储额外的信息（颜色）来维护平衡。这些颜色信息遵循一组特定的规则，以确保树保持平衡状态。红黑树的平衡性质使得插入、删除和查找操作的时间复杂度为对数级别。

在红黑树中，每个节点都有一个键值对，按照键的顺序进行排序。对于map而言，每个节点还有一个相关联的值，而对于set而言，节点的键即是其值。这种有序性质使得map和set非常适合需要按照键进行查找、插入和删除的应用场景。

需要注意的是，虽然红黑树是map和set的常见底层实现，但具体的实现可能因不同的编译器和标准库实现而有所不同。因此，对于特定的编译器和标准库版本，底层实现可能会有所变化。

因此，在学习如何使用红黑树封装STL的map和set的之前，我们需要先学习红黑树的底层原理，可以见博主之前的一篇博客，里面对于红黑树的原理讲的非常的详细。

手撕红黑树 | 变色+旋转你真的明白了吗？【超用心超详细图文解释 | 一篇学会Red_Black_Tree】icon-default.png?t=N6B9https://blog.csdn.net/Yu_Cblog/article/details/128210260

但是，上面这篇博客里面的红黑树，和即将要封装的版本，还是略微有差别的。

因为set只需要key，而map是key-value结构的。

封装版本的红黑树头文件博主放在博客结尾。

封装

Map.h

#pragma once

#include"RBTree.h"

namespace ns_Map {
	template<class K, class V>
	class map {
		struct MapKeyOfT {
			const K& operator()(const pair<K, V>& kv) {
				return kv.first;
			}
		};
	public:
	//迭代器
		//取模板的模板的类型 -- 所以要typename -- 告诉编译器是类型
		typedef typename RBTree <K, pair<K, V>, MapKeyOfT>::iterator iterator;
		iterator begin() {
			return _t.begin();
		}
		iterator end() {
			return _t.end();
		}
	public:
		//operator[] -- 只有map才有
		V& operator[](const K& key) {
			//如果有 -- 插入成功
			//如果没有 -- 插入失败
			pair<iterator, bool>ret = insert(make_pair(key, V()));
			return ret.first->second;
		}
	public:
		pair<iterator, bool> insert(const pair<K, V>& kv) {
			return _t.insert(kv);
		}
	private:
		RBTree <K, pair<K, V>, MapKeyOfT>_t;
	};



	void test_map() {
		map<int, int>m;
		m.insert(make_pair(1, 2));
		m.insert(make_pair(5, 2));
		m.insert(make_pair(2, 2));
		m.insert(make_pair(2, 2));
		m.insert(make_pair(3, 2));
		m.insert(make_pair(4, 2));
		m.insert(make_pair(6, 2));

		cout << "测试++" << endl;
		map<int, int>::iterator it = m.begin();
		while (it != m.end()) {
			cout << it->first << endl;
			++it;
		}
		cout << "测试--" << endl;
		//--it;
		//while (it != m.begin()) {
		//	cout << it->first << endl;
		//	--it;
		//}
		cout << endl;
	}
	void test_map2() {
		string arr[] = { "苹果","香蕉","苹果","苹果","西瓜","香蕉","苹果","苹果" };
		map<string, int>hash;
		for (auto& str : arr) {
			hash[str]++;
		}
		//map<string, int>::iterator it = hash.begin();
		//while (it != hash.end()) {
		//	cout << it->first << ":" << it->second << endl;
		//	++it;
		//}
		//范围for
		for (auto& e : hash) {
			cout << e.first << ":" << e.second << endl;
		}
	}
}

Set.h

#pragma once

#include"RBTree.h"

namespace ns_Set{
	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();
		}
	public:
		pair<iterator, bool> insert(const K& key) {
			return _t.insert(key);
		}
	private:
		RBTree<K, K, SetKeyOfT>_t;
	};





	void test_set() {
		set<int>s;
		s.insert(3);
		s.insert(3);
		s.insert(1);
		s.insert(2);
		s.insert(5);
		s.insert(5);
		s.insert(7);
		s.insert(6);

		set<int>::iterator it = s.begin();
		while (it != s.end()) {
			cout << *it << endl;
			++it;
		}
		cout << endl;
	}
}

RBTree.h

#pragma once
#include<map>
#include<iostream>
#include<assert.h>
using namespace std;
enum Colour {
	RED,BLACK
};

template<class T>
struct __Red_Black_TreeNode {
	__Red_Black_TreeNode<T>* _left;
	__Red_Black_TreeNode<T>* _right;
	__Red_Black_TreeNode<T>* _parent;
	//pair<K, V>_kv;
	T _data;
	Colour _col;
	__Red_Black_TreeNode(const T& data)
		:_left(nullptr), _right(nullptr), _parent(nullptr), _data(data) {}
};

//迭代器
template<class T, class Ref, class Ptr>
struct __redblack_tree_iterator {
	typedef __Red_Black_TreeNode<T>Node;
	Node* _node;
	__redblack_tree_iterator(Node* node)
		:_node(node) {}
	Ref operator*() {
		return _node->_data;
	}
	Ptr operator->() {
		return &_node->_data;
	}
	bool operator!=(const __redblack_tree_iterator& s) const {
		return _node != s._node;
	}
	bool operator==(const __redblack_tree_iterator& s) const {
		return _node == s._node;
	}
	__redblack_tree_iterator& operator++() {
		//1.右子树不为空，++就是找右子树的中序第一个
		//2.如果右子树为空，找孩子不是父亲右边的那个祖先
			//如果当前节点是父亲的右，说明父亲访问过了
		if (_node->_right) {
			//1.
			Node* left = _node->_right;
			while (left->_left) {
				left = left->_left;
			}
			_node = left;
		}
		else {
			//2.
			Node* parent = _node->_parent;
			Node* cur = _node;
			while (parent && cur == parent->_right) {
				cur = cur->_parent;
				parent = parent->_parent;
			}
			_node = parent;
		}
		return *this;
	}
	__redblack_tree_iterator& operator--() {
		//1.如果左不为空 -- 找左的最右
		//2.如果左为空 -- 找到孩子不是父亲的左的那个祖先
		if (_node->_left) {
			Node* right = _node->_left;
			while (right->_right) {
				right = right->_right;
			}
			_node = right;
		}
		else {
			Node* parent = _node->_parent;
			Node* cur = _node;
			while (parent && cur == parent->_left) {
				cur = cur->_parent;
				parent = parent->_parent;
			}
			_node = parent;
		}
		return *this;
	}	
};


//第三个模板参数是一个仿函数
template<class K,class T,class KeyOfT>
struct RBTree {
	typedef __Red_Black_TreeNode<T>Node;
private:
	Node* _root = nullptr;
public:
	typedef __redblack_tree_iterator<T, T&, T*> iterator;
	iterator begin() {
		//stl源码里面是有哨兵位的，这里我们没有 -- 所以我们找一下最左节点
		Node* left = _root;
		while (left && left->_left) {
			left = left->_left;
		}
		return iterator(left);
	}
	iterator end() {
		return iterator(nullptr);//直接给空就行了
	}
private:
	//左单旋
	void rotate_left(Node* parent) {
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
		parent->_right = subRL;
		if (subRL) {
			subRL->_parent = parent;
		}
		Node* ppNode = parent->_parent;//记录一下原先parent的parent
		subR->_left = parent;
		parent->_parent = subR;
		if (_root == parent) {
			_root = subR;
			subR->_parent = nullptr;
		}
		else {
			//如果ppNode==nullpt，是不会进来这里的
			if (ppNode->_left == parent) {
				ppNode->_left = subR;
			}
			else {
				ppNode->_right = subR;
			}
			subR->_parent = ppNode;
		}
	}
	//右单旋
	void rotate_right(Node* parent) {
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		parent->_left = subLR;
		if (subLR) {
			subLR->_parent = parent;
		}
		Node* ppNode = parent->_parent;
		subL->_right = parent;
		parent->_parent = subL;
		if (_root == parent) {
			_root = subL;
			subL->_parent = nullptr;
		}
		else {
			if (ppNode->_left == parent) {
				ppNode->_left = subL;
			}
			else {
				ppNode->_right = subL;
			}
			subL->_parent = ppNode;
		}
	}
public:
	//前面插入的过程和搜索树一样的
	pair<iterator, bool> insert(const T& data) {
		KeyOfT kot;
		if (_root == nullptr) {
			_root = new Node(data);
			_root->_col = BLACK;
			return make_pair(iterator(_root), true);
		}
		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* grandparent = parent->_parent;
			assert(grandparent && grandparent->_col == BLACK);
			//关键看叔叔
			//判断一下左右
			if (parent == grandparent->_left) {
				Node* uncle = grandparent -> _right;
				//情况1（不看方向）
				if (uncle && uncle->_col == RED) {
					parent->_col = uncle->_col = BLACK;
					grandparent->_col = RED;
					//继续向上处理
					cur = grandparent;
					parent = cur->_parent;
				}
				//情况2+3
				//uncle不存在/存在且为黑
				else {
					//情况2
					//   g
					//  p  u
					// c
					//右单旋+变色
					if (cur == parent->_left) {
						rotate_right(grandparent);
						parent->_col = BLACK;//父亲变黑
						grandparent->_col = RED;//祖父变红
					}
					//情况3
					//   g
					//  p  u
					//   c
					//左右双旋+变色
					else {
						rotate_left(parent);
						rotate_right(grandparent);
						//看着图写就行了
						cur->_col = BLACK;
						grandparent->_col = RED;
					}
					break;
				}
			}
			else {
				Node* uncle = grandparent->_left;
				//情况1（不看方向）
				if (uncle && uncle->_col == RED) {
					parent->_col = uncle->_col = BLACK;
					grandparent->_col = RED;
					//继续向上处理
					cur = grandparent;
					parent = cur->_parent;
				}
				else {
					//情况2
					//   g
					//  u  p
					//      c 
					//左单旋+变色
					if (cur == parent->_right) {
						rotate_left(grandparent);
						parent->_col = BLACK;//父亲变黑
						grandparent->_col = RED;//祖父变红
					}
					//情况3
					//   g
					//  u  p
					//    c
					//右左双旋+变色
					else {
						rotate_right(parent);
						rotate_left(grandparent);
						//看着图写就行了
						cur->_col = BLACK;
						grandparent->_col = RED;
					}
					break;
				}
			}
		}
		_root->_col = BLACK;//最后无论根是红是黑 -- 都处理成黑
		//这里我们要返回新增的节点 -- 但是刚才插入过程可能不见了，所以前面最好保存一下
		return make_pair(iterator(newnode), true);
	}
};

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

再战Nvidia，安装 Windows 11 和 EndeavourOS 双系统

再战Nvidia，安装 Windows 11 和 EndeavourOS 双系统

吐血刚装了一周的Ubuntu23.04就挂了&#xff0c;由于买的是最新的显卡就上了Test版本&#xff0c;结果Ubuntu自带的nvidia驱动535居然会失灵&#xff0c;nvidia-smi直接fail。于是换了一堆发行版本&#xff0c;但是我这个主板没带hdmi不支持集显输出&#xff0c;必须安装时就上…
阅读更多...
WEB:warmup

WEB:warmup

背景知识 文件包含 目录遍历 代码审计 题目 打开链接后只有一张图片 f12和查看源代码都试一下&#xff0c;查看源代码发现如下图 访问一下source.php&#xff0c;有如下代码&#xff0c;进行代码审计 <?phphighlight_file(__FILE__);class emmm{public static function c…
阅读更多...
#pragma pack不成对出现造成的异常

#pragma pack不成对出现造成的异常

#pragma pack需要成对出现&#xff0c;若不成对出现会造成异常&#xff0c;难以调查。 现有5个文件&#xff0c;分别是main.c&#xff0c;A.h&#xff0c;A.c&#xff0c;B.h&#xff0c;B.c。 A.h文件内容如下&#xff1a; #include <stdio.h> #include <stdlib.h&g…
阅读更多...
ylb-接口14购买理财产品

ylb-接口14购买理财产品

总览&#xff1a; 在api模块service包&#xff0c;Invest类下添加&#xff08;投资理财产品&#xff0c; int 是投资的结果 &#xff0c; 1 投资成功&#xff09;&#xff1a; package com.bjpowernode.api.service;import com.bjpowernode.api.pojo.BidInfoProduct;import j…
阅读更多...
go mod vendor简明介绍

go mod vendor简明介绍

Go 语言在 go 1.6 版本以后编译 go 代码会优先从 vendor 目录先寻找依赖包&#xff0c;它具有以下优点&#xff1a; 复制依赖&#xff1a;go mod vendor 会把程序所依赖的所有包复制到项目目录下的vendor 文件夹中&#xff0c;所以即使这些依赖包在外部源&#xff08;如 GitHu…
阅读更多...
MySQL 约束、聚合查询和联合查询练习

MySQL 约束、聚合查询和联合查询练习

1. 数据库约束 设置一个考勤系统, 包含员工表&#xff0c;考勤记录表 首先要明白, 员工表对考勤记录表是一对多 员工表中起码包含 id , name 考勤记录表则包含 id, 日期, 考勤记录 考勤记录表为子表, id 则为外键约束 员工表为父键, id则为主键约束 搞明白这些, 接下来就…
阅读更多...
【C语言】矩阵相乘

【C语言】矩阵相乘

#include <stdio.h>#define M 3 #define N 4 #define P 3void fun(int a[M][N], int b[N][P], int m, int p, int n)//定义函数fun {printf("m: %d, p: %d, n: %d\n", m, p, n);int c[M][P]{0};int i, j, k;for(i 0; i < m; i){for(j 0; j < n; j){fo…
阅读更多...
【数据结构】朴素模式匹配 KMP算法

【数据结构】朴素模式匹配 KMP算法

&#x1f387;【数据结构】朴素模式匹配 & KMP 算法&#x1f387; &#x1f308; 自在飞花轻似梦,无边丝雨细如愁 &#x1f308; &#x1f31f; 正式开始学习数据结构啦~此专栏作为学习过程中的记录&#x1f31f; 文章目录 &#x1f387;【数据结构】朴素模式匹配 & K…
阅读更多...
IDEA中设置鼠标滚轮修改字体大小

IDEA中设置鼠标滚轮修改字体大小

IDEA中设置鼠标滚轮修改字体大小&#xff1f; 选择File--Settings--Editor--General&#xff0c;把 Mouse Control 前的对勾勾选 后点击 OK 即可。 勾选此设置后&#xff0c;增加 Ctrl 鼠标滚轮 快捷键来控制代码字体大小显 示。字体随时可以放大缩小~~可真好用呢~
阅读更多...
IDEA运行TOMCAT出现404

IDEA运行TOMCAT出现404

就这种问题&#xff0c;每个人的原因都不一定一样&#xff0c;我出现这种问题的解决方法在这里记录一下。顺便把我的配置记录一下。 除了本文的问题&#xff0c;还有可能是默认打开的文件名错了&#xff0c;或者端口被占用。 软件版本IDEA2023 TOMCAT9 亲测&#xff1a;IDE…
阅读更多...
❤️创意网页：如何使用HTML制作漂亮的搜索框

❤️创意网页：如何使用HTML制作漂亮的搜索框

✨博主&#xff1a;命运之光 &#x1f338;专栏&#xff1a;Python星辰秘典 &#x1f433;专栏&#xff1a;web开发&#xff08;简单好用又好看&#xff09; ❤️专栏&#xff1a;Java经典程序设计 ☀️博主的其他文章&#xff1a;点击进入博主的主页 前言&#xff1a;欢迎踏入…
阅读更多...
pycharm python 函数添加注释 快捷键

pycharm python 函数添加注释 快捷键

写完函数定义后,在函数名下面点击,并按下敲入""",完后回车,这会自动生成函数的文档注释格式 完后找我要插件,会阅读函数的内容,自动生成注释的内容.
阅读更多...
RootThis靶机复盘

RootThis靶机复盘

RootThis靶机复盘 在这个靶机中收获良多&#xff0c;首先学会了一个新的交互方式&#xff0c;不需要用python了&#xff0c;同时知道了什么是静态链接文件&#xff0c;还有就是学会了遇到数据库文件应该怎么解决。 /usr/bin/script -qc /bin/bash /dev/null 静态链接版本的程…
阅读更多...
openpnp - 相机图像亮度太高的解决方法

openpnp - 相机图像亮度太高的解决方法

文章目录 openpnp - 相机图像亮度太高的解决方法概述笔记设置相机的合适参数白平衡END openpnp - 相机图像亮度太高的解决方法 概述 看到同学在群里讨论问题, 说相机补光灯亮度太高了, 导致openpnp图像惨白惨白的, 根本不能用. 能根本解决问题的方法, 就是群里同学说的, 用恒…
阅读更多...
Linux —— 进程状态

Linux —— 进程状态

目录 一&#xff0c;进程状态分类 二&#xff0c;僵尸进程 三&#xff0c;孤儿进程 一&#xff0c;进程状态分类 进程状态反应进程执行过程中的变化&#xff0c;状态会随外界条件的变化而转换&#xff1b; 三态模型&#xff0c;运行态、就绪态、阻塞态&#xff1b;五态模型…
阅读更多...
PyTorch: 权值初始化

PyTorch: 权值初始化

文章和代码已经归档至【Github仓库&#xff1a;https://github.com/timerring/dive-into-AI 】或者公众号【AIShareLab】回复 pytorch教程 也可获取。 文章目录 Pytorch&#xff1a;权值初始化梯度消失与梯度爆炸 Xavier 方法与 Kaiming 方法Xavier 方法nn.init.calculate_gain…
阅读更多...
VPC对等连接

VPC对等连接

对等连接
阅读更多...
Spark3新特性

Spark3新特性

Spark AQE 自适应查询优化&#xff1a; 实现运行时优化&#xff0c;纠正因统计信息不准确导致生成的逻辑计划不完善或有误的问题 动态调整JOIN策略&#xff1a;类似于mapjoin优化&#xff0c;将sortMergejoin转换成broadcasthashjoin&#xff0c;也就是将小表当作广播变量分发…
阅读更多...
基于深度学习的高精度线路板瑕疵目标检测系统（PyTorch+Pyside6+YOLOv5模型）

基于深度学习的高精度线路板瑕疵目标检测系统（PyTorch+Pyside6+YOLOv5模型）

摘要&#xff1a;基于深度学习的高精度线路板瑕疵目标检测系统可用于日常生活中来检测与定位线路板瑕疵目标&#xff0c;利用深度学习算法可实现图片、视频、摄像头等方式的线路板瑕疵目标检测识别&#xff0c;另外支持结果可视化与图片或视频检测结果的导出。本系统采用YOLOv5…
阅读更多...
SpringBoot+Vue实现的高校图书馆管理系统

SpringBoot+Vue实现的高校图书馆管理系统

项目描述&#xff1a;这是一个基于SpringBootVue框架开发的高校图书馆管理系统。首先&#xff0c;这是一个前后端分离的项目&#xff0c;代码简洁规范&#xff0c;注释说明详细&#xff0c;易于理解和学习。其次&#xff0c;这项目功能丰富&#xff0c;具有一个高校图书馆管理系…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023