C++进阶：map与set简单自实现

最新推荐文章于 2024-07-04 11:10:43 发布
最新推荐文章于 2024-07-04 11:10:43 发布
阅读量441 收藏 5
点赞数 4
文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_71806743/article/details/138295216
版权

目录

1. map与set封装红黑树的方式

1.1 大概实现思路

  1. STL库中，实现的map与set其底层都为红黑树这种数据结构，在前面的学习中，我们已经简单模拟实现了红黑树。
  2. 因此，对于map与set的实现无需再去从零开始一一构建，而是可以采用类似于栈与队列这两个容器适配器的形式，直接将红黑树进行封装，调用其的各种方法接口间接实现。

1.2 红黑树模板抽象

  1. 虽然map与set的底层数据结构都为红黑树，但是，它们也并不是完全相同，map中存储的数据结点为KV类型，而set中存储的数据结点为K类型，所以，两者在接口与使用上也有所不同。
  2. 可仅仅因此不大的差别就再写一份高度类同的红黑树代码，就不免冗余性过高，由此，我们仿照库中实现的类似方式，将红黑树抽象为模板，通过模板参数来调整细节的方式，来同时适配map与set的需求。
//红黑树模板参数
template<class K, class T, class KeyOfT>
//参数K：set与map的key值类型，K参数的存在是必要的，否则无法进行此类型函数参数的声明
//参数T：set中也为key值类型，而map中为pair<K, V>类型
//参数KeyOfT：仿函数类型，从T类型结点中提取出key值，进行查找，插入等操作必须获知与比对key值

1.3 红黑树的迭代器

  1. 当调用库中的map与set容器时，我们使用相应迭代器遍历其中存储数据，得到的是一串排序好的有序数据。
  2. 因为map与set的底层本质上为一棵搜索二叉树，这种遍历后得到的数据特点，我们不难知道，迭代器底层实则是在由整颗树最左侧结点做中序遍历，那么，其底层的逻辑究竟应该怎么去实现呢？

2. 红黑树模板的实现

2.1 结点结构的定义

//结点结构
enum colour
{
	Red,
	Black
};

template<class K, class T>
struct RBTreeNode
{
	RBTreeNode<K, T>* _left;
	RBTreeNode<K, T>* _right;
	RBTreeNode<K, T>* _parent;
	T _kv;
	colour _col;

	RBTreeNode(const T& kv)
		:_left(nullptr)
		,_right(nullptr)
		,_parent(nullptr)
		,_kv(kv)
		,_col(Red)
	{}
};

2.2 红黑树迭代器的实现

2.2.1 迭代器的结构

//定义一个迭代器模板，适配出普通迭代器与const迭代器
template<class K, class T, class Ref, class Ptr>
class RBTree_iterator
{
	typedef RBTreeNode<K, T> RBTNode;
public:
	//构造
	RBTree_iterator(RBTNode* node)
		:_node(node)
	{}
	
	//拷贝构造
	RBTree_iterator(const RBTree_iterator& it)
	{
		_node = it._node;
	}

	//后置++，左根右
	RBTree_iterator operator++(int);
	
	//后置--，右根左
	RBTree_iterator operator--(int);

	//const T&
	Ref operator*();

	//const T*
	Ptr operator->();

	//指向结点相同
	bool operator==(RBTree_iterator it);

	bool operator!=(RBTree_iterator it);

private:
	RBTNode* _node;
};

2.2.2 迭代器的方法实现

  1. 杂项
//const T&
Ref operator*()
{
	return _node->_kv;
}

//const T*
Ptr operator->()
{
	return &_node->_kv;
}

//指向结点相同
bool operator==(RBTree_iterator it)
{
	return _node == it._node;
}

bool operator!=(RBTree_iterator it)
{
	return _node != it._node;
}
  1. 后置++与–
    在这里插入图片描述
//先使用，再++
//operator++，左根右
RBTree_iterator operator++(int)
{
	RBTree_iterator cp(*this);

	//左根右
	if (_node->_right)
	{
		//向左找
		RBTNode* SubLeft = _node->_right;
		while (SubLeft->_left)
		{
			SubLeft = SubLeft->_left;
		}

		_node = SubLeft;
	}
	else
	{
		RBTNode* cur = _node;
		RBTNode* parent = cur->_parent;
		if (cur == parent->_left)
		{
			_node = parent;
		}
		else
		{
			//一层一层向上找，空结点检测
			while (parent && cur == parent->_right)
			{
				cur = parent;
				parent = cur->_parent;
			}

			_node = parent;
		}
	}

	return cp;
}

//operator--，右根左
RBTreeNode_iterator operator--(int)
{
	RBTree_iterator cp(*this);

	//右根左
	if (_node->_left)
	{
		//向右找
		RBTNode* SubRight = _node->_left;
		while (SubRight->_right)
		{
			SubRight = SubRight->_right;
		}

		_node = SubRight;
	}
	else
	{
		RBTNode* cur = _node;
		RBTNode* parent = _node->_parent;
		while (parent && cur == parent->_left)
		{
			cur = parent;
			parent = cur->_parent;
		}

		_node = parent;//处理逻辑同时符合两种情况
	}

	return cp;
}

2.3 树结构的定义

//树结构
template<class K, class T, class KeyOfT>
class RBTree
{
	typedef RBTreeNode<K, T> RBTNode;
public:
	//查找
	bool Find(const K& key);

	//插入
	pair<iterator, bool> Insert(const T& kv);
	
private:
	RBTNode* _root = nullptr;
	KeyOfT con;
}

2.4 红黑树接口实现

2.4.1 插入

//插入
pair<iterator, bool> Insert(const T& kv)
{
	//找到插入位置
	RBTNode* cur = _root;
	RBTNode* parent = nullptr;
	while (cur)
	{
		if (con(kv) < con(cur->_kv))
		{
			parent = cur;
			cur = cur->_left;
		}
		else if (con(kv) > con(cur->_kv))
		{
			parent = cur;
			cur = cur->_right;
		}
		else
		{
			//有相同值，插入失败
			//return false;
			return make_pair(iterator(cur), false);
		}
	}

	//插入
	RBTNode* newnode = new RBTNode(kv);
	cur = newnode;
	if (_root == nullptr)//根结点
	{
		_root = cur;
		_root->_col = Black;
		//return true;
		return make_pair(iterator(cur), true);
	}
	else
	{
		if (con(kv) < con(parent->_kv))
		{
			parent->_left = cur;
			cur->_parent = parent;
		}
		else
		{
			parent->_right = cur;
			cur->_parent = parent;
		}
	}

	//判断与调整
	while (parent)
	{
		//父亲结点为黑色
		if (parent->_col == Black)
		{
			break;
		}
		else//父结点为红色
		{
			RBTNode* grandparent = parent->_parent;
			RBTNode* uncle = grandparent->_left;
			if (parent == grandparent->_left)
			{
				uncle = grandparent->_right;
			}

			//叔叔结点存在且为红色
			if (uncle && uncle->_col == Red)
			{
				parent->_col = uncle->_col = Black;
				grandparent->_col = Red;
				cur = grandparent;
				//注，父节点存放变量也需重置
				parent = cur->_parent;
			}
			else//叔叔结点为黑色/不存在
			{
				if (parent == grandparent->_left)//左外高
				{
					if (cur == parent->_left)//右单旋
					{
						//      g
						//   p      u
						//c
						RotateR(grandparent);
						parent->_col = Black;
						grandparent->_col = Red;
					}
					else//左右双旋
					{
						//      g
						//   p      u
						//     c
						RotateLR(grandparent);
						cur->_col = Black;
						grandparent->_col = Red;
					}
				}
				else//右外高
				{
					if (cur == parent->_right)//左单旋
					{
						//   g
						//u      p
						//          c
						RotateL(grandparent);
						parent->_col = Black;
						grandparent->_col = Red;
					}
					else//右左双旋
					{
						//   g
						//u      p
						//     c
						RotateRL(grandparent);
						cur->_col = Black;
						grandparent->_col = Red;
					}
				}

				break;
			}
		}
	}

	_root->_col = Black;

	return make_pair(iterator(newnode), true);
}

2.4.2 查找

//查找
bool Find(K key)
{
	RBTNode* cur = _root;
	while (cur)
	{
		if (key < con(cur->_kv))
		{
			cur = cur->_left;
		}
		else if (key > con(cur->_kv))
		{
			cur = cur->_right;
		}
		else
		{
			return true;
		}
	}

	return false;
}

2.4.3 迭代器相关

typedef RBTree_iterator<K, T, T&, T*> iterator;
typedef RBTree_iterator<K, T, const T&, const T*> const_iterator;

iterator begin()
{
	RBTNode* cur = _root;
	while (cur->_left)
	{
		cur = cur->_left;
	}

	return cur;
}

iterator end()
{
	return nullptr;
}

const iterator cbegin() const
{
	RBTNode* cur = _root;
	while (cur->_left)
	{
		cur = cur->_left;
	}

	return cur;
}

const iterator cend() const
{
	return nullptr;
}

3. map与set的自实现

3.1 set封装

template<class K>
class myset
{
	struct KeyOfT
	{
		K operator()(const K& key)
		{
			return key;
		}
	};

	typedef RBTree_iterator<K, K, K&, K*> iterator;
	typedef RBTree_iterator<K, K, const K&, const K*> const_iterator;
public:
	bool Find(K key)
	{
		return tree.Find(key);
	}

	pair<iterator, bool> Insert(K key)
	{
		return tree.Insert(key);
	}

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

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

	const_iterator cbegin() const
	{
		return tree.cbegin();
	}

	const_iterator cend() const
	{
		return tree.cend();
	}

	void InOrder()
	{
		tree.InOrder();
	}

private:
	RBTree<K, K, KeyOfT> tree;
};

3.2 map封装

template<class K, class V>
class mymap
{
	struct KeyOfT
	{
		K operator()(const pair<const K, V> kv)
		{
			return kv.first;
		}
	};
	typedef RBTree_iterator<K, pair<const K, V>, pair<const K, V>&, pair<const K, V>*> iterator;
	typedef RBTree_iterator<K, pair<const K, V>, const pair<const K, V>&, const pair<const K, V>*> const_iterator;
public:
	bool Find(K key)
	{
		return tree.Find(key);
	}

	pair<iterator, bool> Insert(const pair<K, V> kv)
	{
		return tree.Insert(kv);
	}

	//迭代器
	iterator begin()
	{
		return tree.begin();
	}

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

	const_iterator cbegin() const
	{
		return tree.cbegin();
	}

	const_iterator cend() const
	{
		return tree.cend();
	}

	V& operator[](const K key)
	{
		pair<iterator, bool> ret = Insert(make_pair(key, V()));

		return ret.first->second;
	}

private:
	RBTree<K, pair<const K, V>, KeyOfT> tree;
};
执笔者548
关注
  • 4
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
c++进阶（stl资源），非原创，配套b站（C++进阶之STL）教程
02-18
**C++进阶：STL资源详解** C++标准模板库（Standard Template Library，简称STL）是C++编程中的一个重要组成部分，它提供了一系列高效、泛用的容器、迭代器、算法和函数对象，极大地提高了C++程序员的开发效率。在...
C++进阶STL笔记资料.zip
07-22
这份"C++进阶STL笔记资料"将详细讲解STL的各个方面，是深入学习和掌握C++进阶技巧的重要参考资料。通过阅读和实践，开发者不仅能熟悉STL的使用，还能理解其背后的设计思想，从而更好地应对复杂的编程挑战。
C++进阶：map与set容器的使用
qq_71806743的博客
04-24 1020
【代码】C++进阶：map与set容器的使用。
C++进阶：map和set
qq_71925940的博客
04-28 803
5.
C++学习进阶：map和set的实现
weixin_73234157的博客
12-14 966
我们知道set和map的底层其实是红黑树，在学习完红黑树这个数据结构之后，我们开始简单模拟实现一下这两个STL容器。
C++进阶之map与set
cls的博客
05-23 2380
stl中将数据结构叫做容器。 容器分为 序列式容器：vector/list... 就类似线性表 关联史容器：map/set.. 数据之间有强烈的关联性，底层是搜索树 栈和队列是适配器 set底层就是搜索树。 void test_set1() { //排序＋去重 set<int> s; s.insert(3); s.insert(1); s.insert(8); s.insert(2); s.insert(5); s.insert(5); s.insert(5)
【C++进阶：map和set】
weixin_56235740的博客
07-27 171
在C++初阶阶段，已经学习并总了STL中的部分容器，比如：vector、list、deque、forward_list等，这些容器统称为序列式容器，因为其底层为线性序列的数据结构，里面存储的是元素本身。那什么是关联式容器？它与序列式容器有什么区别？关联式容器也是用来存储数据的，与序列式容器不同的是，其里面存储的是结构的键值对，在数据检索时比序列式容器效率更高。
C++进阶：详细讲解容器set与map（pair、multiset、multimap）
qq_74415153的博客
04-09 1655
上次介绍了搜索二叉树 为了介绍后面的AVLTree和红黑树，我们要进行一些铺垫，就是set与map的介绍啦
C++学习进阶：unordered_set和ma的实现
weixin_73234157的博客
04-10 999
我们在上一篇博客数据结构与算法：哈希表-CSDN博客中学习了哈希表这个数据结构，也对哈希桶有了一定的了解，学习这个数据结构的本质是为了对STL容器unordered_set和unordered_map进行深入的学习我们在C知道中搜索“unordered_set和set 区别”，发现了这两个容器对应着不同的场景，为了更好的了解这个两个容器我们开始学习如何实现“unordered_set和map”把！！！C++学习进阶：map和set的实现-CSDN博客。
C++学习进阶：set 和 map
weixin_73234157的博客
11-21 426
C++中的set是一种基于红黑树实现的关联容器，用于存储唯一且已排序的元素集合。set中的元素按照一定的顺序排列，插入和删除操作的时间复杂度为O(log n)，查找操作的时间复杂度也为O(log n)。set中的元素必须是可比较的，因此需要重载运算符或者提供自定义比较函数。如图set分为普通set以及multiset，普通set就是上面所说存储唯一且已排序的元素结合，而multiset就是可以存储多个相同key的set那么我们先开始进行set的学习。
C++进阶：哈希表封装unordered_map和unordered_set（模拟实现）
qq_71925940的博客
06-03 299
基于my_unordered_map.h封装的哈希表类提供的接口，实现一个unordered_map。unordered_map的值是一个键值对。基于HashTable.h封装的哈希表类提供的接口，实现一个unordered_set类。该文件基本实现了unordered_set类。该文件基本实现了unordered_map类。
C++进阶课程讲义_v1.0.4.pdf
04-22
8.2 C++异常处理的实现 35 8.2.1异常基本语法 35 8.2.2栈解旋(unwinding) 39 8.2.3异常接口声明 40 8.2.4异常类型和异常变量的生命周期 40 8.2.5异常的层次结构(继承在异常中的应用) 46 8.3标准程序库异常 47 8.4...
C++进阶STL源码笔记
11-15
这份“C++进阶STL源码笔记”显然是一个深入研究STL的资源，适合那些已经有一定C++编程基础的开发者，通过源码分析来提升对STL的理解和应用能力。以下将详细讲解STL中的关键组件和概念。 1. 容器： STL的核心组成...
c++习题08-计算星期几
码到成龚的博客
07-03 594
问题描述 假设今天是星期日，那么过a^b天之后是星期几？ 输入描述 两个正整数a，b，中间用单个空格隔开。0
C++初学者指南-3.自定义类型(第一部分)-析构函数
silencestarsky的博客
07-02 627
本文介绍了C++初学者指南中关于自定义类型和析构函数的重要内容。主要涵盖了特殊的成员函数如构造函数和析构函数的作用，RAII资源管理的重要性以及避免编写特殊成员函数的建议。
关键路径——C语言（理论）
2302_80790488的博客
06-28 861
关键路径，是项目网络中从起始事件到终止事件的最长路径，决定了项目的最短完成时间。 关键路径中的任务没有任何可调整的余地，如果任何一个任务被延迟，整个项目的完成时间也会被延迟。
Android 开发中 C++ 和Java 日志调试
最新发布
小羊子的技术专栏
07-04 912
Android 开发中 C++ 和Java 日志调试方法小结
机器人运动范围检测 c++
m0_61862494的博客
07-02 761
地上有一个m行n列的方格，一个机器人从坐标（0，0）的格子开始移动，它每次可以向上下左右移动一个格子，但不能进入行坐标和列坐标的位数之和大于k的格子，请问机器人能够到达多少个格子。这个算法的时间复杂度为O(mn)，其中m和n分别是网格的行数和列数。空间复杂度也是O(mn)，主要用于存储visited数组和BFS队列。这个实现使用了广度优先搜索（BFS）算法来解决问题。
C++进阶重点知识精讲1-202110231
08-03
"C++进阶课程，涵盖了智能指针、右值引用、匿名函数、正则表达式、线程池、异常处理、协程等内容，提供了C++参考手册链接，并强调了C++11及后续标准的新特性在实际编程中的应用。" C++是一种强大的编程语言，特别...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值