用红黑树封装实现map和set

最新推荐文章于 2024-07-05 23:03:08 发布
最新推荐文章于 2024-07-05 23:03:08 发布
阅读量1k 收藏 22
点赞数 21
分类专栏： C++ 数据结构 文章标签： 数据结构 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/decade777555/article/details/136722708
版权

目录

1、map和set的底层

2、map与set中的key关键值

3、红黑树迭代器的实现。

1、++操作

2、-- 操作

3、==和!=操作

4、在红黑树中封装迭代器

5、map和set对迭代器的封装

1、map

map中[]的重载

2、set

1、map和set的底层

        map和set都是基于红黑树实现的。红黑树是一种自平衡的二叉搜索树，它保持着良好的平衡性能，插入、删除、查找的时间复杂度都是O(log n)。在C++ STL中，map和set都是使用红黑树作为底层数据结构来实现的。红黑树在前面文章模拟实现过，可以参考

rep_type通常是用来表示set容器内部红黑树的节点类型。在STL头文件中，通常会定义rep_type作为红黑树节点的类型，用于表示set容器和map容器内部的数据结构。 

可以看到set和map的源代码中都使用了红黑树作为底层数据结构。

可以看到红黑树中的数据类型只有一个，

而在map和set中都有key值，也有数据类型，map的数据类型是键值对pair<const key,T>,set中的数据类型也是key。

2、map与set中的key关键值

那么我们该如何模拟实现呢？

🚀map传给红黑树的模板参数是pair键值对

🚀set传给红黑树的模板参数是key值

 红黑树该如何判断key值来比较大小呢，这个时候我们需要使用仿函数的方法，因为红黑树比较节点只看key值。我们选择仿函数的方法：

map.h文件：

template<class K,class V>
class MYmap
{
	struct KeyofMap
	{
		const K& operator ()(const pair<K,V> &kv)
		{
			return kv.first;
		}

	};
private:
	RBTree<K, pair<const K, V>, KeyofMap> _t;
};

set.h文件：

template<class T>
class Myset
{
	struct SetKeyofvalue
	{
		const T& operator()(const T& key)
		{
			return key;
		}
	};
private:
	RBTree<T, const T, SetKeyofvalue> _t;
};

set存放的数据本身就是key，但是为了与红黑树结构：

以及map的结构统一，所以也需要实现一个。

3、红黑树迭代器的实现。

1、++操作

++操作也就是找到下一个比它大的值，那么就有两种可能：

1.右子树的最小值。

//如果右子树不为空，那么比这个元素大的下一个节点就是右子树的最小元素

//也就是右子树的最左节点

2.如果没有右子树，那么向上查找，直到找到一个节点是其父节点的左字数，该父节点就是符合条件的值。

Self& operator++()
	{
		//如果右子树不为空，那么比这个元素大的下一个节点就是右子树的最小元素
		//也就是右子树的最左节点
		if (_node->_right)
		{
			Node* subrm = _node->_right;
			while (subrm->_left)
			{
				subrm = subrm->_left;
			}
			_node = subrm;
		}
		//如果右子树为空，那么向上查找，直到找到一个节点是其父节点的左子树
		else
		{
			Node* cur = _node;
			Node* parent = cur->_parent;
			while (parent&& parent->_right == cur)
			{
				cur = parent;
				parent = parent->_parent;
			}
			_node = parent;
		}

		return *this;
	}

2、-- 操作

--操作也就是找到下一个比它小的值，那么就有两种可能：

1.左子树存在

//找出这个迭代器前面一个比它小的元素，如果左子树存在，那么就先找左边最大的节点
//也就是右子树的最右节点

2.左子树不存在

 //如果左子树为空，那么向上查找，直到找到一个节点是其父节点的右子树

Self& operator --()
	{
		//找出这个迭代器前面一个比它小的元素，如果左子树存在，那么就先找左边最大的节点
		//也就是右子树的最右节点
		if (_node->_left)
		{
			Node* sublmax = _node->_left;
			while (sublmax->_right)
			{
				sublmax = sublmax->_right;
			}
			_node = sublmax;

		}
		//如果左子树为空，那么向上查找，直到找到一个节点是其父节点的右子树
		else
		{
			Node* cur = _node;
			Node* parent = cur->_parent;
			while (parent && cur == parent->_left)
			{
				cur = parent;
				parent = parent->_parent;

			}
			_node = parent;

		}
		return *this;
	}

3、==和!=操作

//重载！=运算符
	bool operator!=(const Self& s)
	{
		return _node != s._node;
	}
	//重载==运算符
	bool operator == (const Self & s)
	{
		return _node == s._node;
	}

比较的内容是迭代器指向的节点是不是相同，不是比较节点的key值，同时也不需要修改，所以这里只需要const引用即可。

红黑树迭代器完整实现代码：


//红黑树迭代器
template<class T>
struct __RBTreeIterator
{
	typedef RBTreeNode<T> Node;
	typedef __RBTreeIterator<T> Self;
	Node* _node;

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

	T& operator *()
	{
		return _node->_data;
	}

	T* operator ->()
	{
		return &_node->_data;
	}

	Self& operator++()
	{
		//如果右子树不为空，那么比这个元素大的下一个节点就是右子树的最小元素
		//也就是右子树的最左节点
		if (_node->_right)
		{
			Node* subrm = _node->_right;
			while (subrm->_left)
			{
				subrm = subrm->_left;
			}
			_node = subrm;
		}
		//如果右子树为空，那么向上查找，直到找到一个节点是其父节点的左子树
		else
		{
			Node* cur = _node;
			Node* parent = cur->_parent;
			while (parent&& parent->_right == cur)
			{
				cur = parent;
				parent = parent->_parent;
			}
			_node = parent;
		}

		return *this;
	}

	Self& operator --()
	{
		//找出这个迭代器前面一个比它小的元素，如果左子树存在，那么就先找左边最大的节点
		//也就是右子树的最右节点
		if (_node->_left)
		{
			Node* sublmax = _node->_left;
			while (sublmax->_right)
			{
				sublmax = sublmax->_right;
			}
			_node = sublmax;

		}
		//如果左子树为空，那么向上查找，直到找到一个节点是其父节点的右子树
		else
		{
			Node* cur = _node;
			Node* parent = cur->_parent;
			while (parent && cur == parent->_left)
			{
				cur = parent;
				parent = parent->_parent;

			}
			_node = parent;

		}
		return *this;
	}

	//重载！=运算符
	bool operator!=(const Self& s)
	{
		return _node != s._node;
	}
	//重载==运算符
	bool operator == (const Self & s)
	{
		return _node == s._node;
	}

};

4、在红黑树中封装迭代器

在红黑树中，起始节点begin()是最左节点

结束位置是空位置节点

本文采用上面的实现方法。

为了实现左闭右开，STL库采用的是end指向哨兵位头结点，最左边节点也和头相连。


template<class K,class T,class KeyofT>
class RBTree
{
public:
	typedef __RBTreeIterator<T> iterator;
	typedef RBTreeNode<T> Node;
	KeyofT kot;
	iterator begin()
	{
		Node* subleft = _root;
		while (subleft && subleft->_left)
		{
			subleft = subleft->_left;
		}
		return iterator(subleft);
	}

	iterator end()
	{
		return iterator(nullptr);
	}
private:
	Node* _root=nullptr;
};

5、map和set对迭代器的封装

1、map

typedef typename RBTree<K, pair<const K, V>, KeyofMap>::iterator iterator;

这里要使用typename

当在模板中使用嵌套类型或依赖于模板参数的类型推导时，需要使用typename关键字来告诉编译器这是一个类型而不是一个变量。这通常出现在模板中使用嵌套类型或依赖于模板参数的类型推导时。

map中[]的重载

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

 map中的[]可以实现查找，修改，插入三个功能。

当使用[]操作符访问map中的元素时，

如果该键已经存在，则返回对应的值；

如果该键不存在，则会插入一个新的键值对，并返回一个默认构造的值。

在红黑树中也要对insert进行修改来匹配 

 

我们来测试一下修改（更改value值）:

#pragma once
#include"RBTree.h"

template<class K,class V>
class MYmap
{
	struct KeyofMap
	{
		const K& operator ()(const pair<K,V> &kv)
		{
			return kv.first;
		}

	};
public:
	typedef typename RBTree<K, pair<const K, V>, KeyofMap>::iterator iterator;

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

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



private:
	RBTree<K, pair<const K, V>, KeyofMap> _t;
};

2、set

#pragma once
#include"RBTree.h"
template<class T>
class Myset
{
	struct SetKeyofvalue
	{
		const T& operator()(const T& key)
		{
			return key;
		}
	};

public:
	typedef typename RBTree<T,const T, SetKeyofvalue>::iterator iterator;

	iterator begin()
	{
		return _t.begin();
	}
	iterator end()
	{
		return _t.end();
	}

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

private:
	RBTree<T, const T, SetKeyofvalue> _t;
};

在C++的std::map和std::set容器中，元素的键值是不可更改的，这是因为这两个容器是基于红黑树实现的，红黑树的性质要求元素的键值在插入后不能被修改，否则会破坏红黑树的结构。

所以在实现时，map使用了

RBTree<K, pair<const K, V>, KeyofMap> _t;

set使用了

RBTree<T, const T, SetKeyofvalue> _t; 

来保证key值不会被修改。 

下面给出红黑树完整的插入函数：

pair<iterator,bool> Insert(const  T& data)
	{
		if (_root == nullptr)
		{
			_root = new Node(data, BLACK);
			Node* newnode = _root;
			//根的双亲为头结点
			return make_pair(iterator(newnode), 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(cur,false);
			}
		}
		cur = new Node(data, RED);
		Node* newnode = cur;
		if (kot(cur->_data) < kot(parent->_data))
		{
			parent->_left = cur;
		}
		else
		{
			parent->_right = cur;
		}
		cur->_parent = parent;

		while (parent && parent->_color == RED)
		{
			Node* grandparent = parent->_parent;
			if (parent == grandparent->_left)
			{
				Node* uncle = grandparent->_right;
				if (uncle && uncle->_color == RED)
				{
					grandparent->_color = RED;
					parent->_color = BLACK;
					uncle->_color = BLACK;

					cur = grandparent;
					parent = cur->_parent;
				}
				else
				{
					if (cur == parent->_left)
					{
						RotateR(grandparent);
						parent->_color = BLACK;
						grandparent->_color = RED;
					}
					else
					{
						RotateL(parent);
						RotateR(grandparent);
						cur->_color = BLACK;
						grandparent->_color = RED;
					}
					break;
				}
			}
			else
			{
				Node* uncle = grandparent->_left;
				if (uncle && uncle->_color == RED)
				{
					grandparent->_color = RED;
					parent->_color = BLACK;
					uncle->_color = BLACK;
					cur = grandparent;
					parent = cur->_parent;
				}
				else
				{
					if (cur == parent->_right)
					{
						RotateL(grandparent);
						parent->_color = BLACK;
						grandparent->_color = RED;
					}
					else
					{
						RotateR(parent);
						RotateL(grandparent);
						cur->_color = BLACK;
						grandparent->_color = RED;
					}
					break;
				}
			}
		}
		_root->_color = BLACK;
		return make_pair(iterator(newnode),true);
	}

通过封装实现Map和Set，可以使用红黑树的特性来实现键值对的存储和查找，同时保持数据结构的平衡性和高效性。以上就是用红黑树封装实现map和set，当然这只是简单实现，对于更好地理解和使用这个容器比较有帮助。

Faiz..
关注
  • 21
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
红黑树封装实现map和set
06-20
封装红黑树实现map和set解决方案
红黑树封装map&&set源代码
06-01
通过理解红黑树的工作原理，并结合上述关键部分，我们可以构建出自己的红黑树封装的Map和Set实现。这样的实现有助于深入理解数据结构和算法，同时也可以用于学习和教学目的。在实际开发中，直接使用Java提供的`...
map和set的模拟实现
06-06
这将帮助我们更好地理解和实现红黑树，从而有效地模拟出Map和Set。 总之，通过封装红黑树并结合C++的面向对象特性，我们可以构建出高性能的Map和Set模拟实现。这不仅可以加深对数据结构和算法的理解，也有助于在...
c++容器list、vector、map、set区别与用法详解
08-19
map容器是一个基于红黑树的平衡检索二叉树，存储结构为键值对,value>。map容器的特点是： * 采用平衡检索二叉树，存储结构为键值对,value>。 * 支持快速查找、插入和删除元素。 * 查找、插入和删除元素的时间复杂度...
【数据结构】（6.3）堆的应用——堆排序（C语言）
最新发布
金哥的博客
07-05 215
堆排序（Heap Sort）就是对直接选择排序的一种改进。此话怎讲呢？直接选择排序在待排序的n个数中进行n-1次比较选出最大或者最小的，但是在选出最大或者最小的数后，并没有对原来的序列进行改变，这使得下一次选数时还需要对全部数据进行比较，效率大大降低。堆排序算法是Floyd和Williams在1964年共同发明的，同时他们发明了“堆”这种数据结构。
数据结构(3.3)——栈的链式存储结构
m0_65240792的博客
06-30 254
采用链式存储的栈成为链栈的优点是便于多个栈共享存储空间和提高其效率，且。通常采用单链表实现。
数据结构-线性表的应用
pyc68的博客
07-02 926
本篇文章介绍线性表的应用，分别使用顺序表和单链表实现有序表的合并，最后介绍如何使用单链表实现两个稀疏多项式的相加和相乘。
数据结构--顺序表
LH__1314的博客
06-30 3443
当我们想要使⽤大量使⽤同⼀类型的数据时，通过⼿动定义⼤量的独立的变量对于程序来说，可读性非常差，我们可以借助数组这样的数据结构将⼤量的数据组织在⼀起，结构也可以理解为组织数据的方式。在使用完顺序表后，就要销毁顺序表，因为动态顺序表内存是动态开辟的，所以需要对动态内存进行释放，并将有效数据和空间容量个数置为0；到这里，顺序表的知识就完成了，学完这些，我们也要写顺序表的实践，就是通讯录——在下一篇进行实现。求数组的长度，求数组的有效数据个数，向下标为数据有效个数的位置插入数据（注意：这里是。
C语言的数据结构：图的基本概念
Caoshuang_的博客
07-02 949
之前学过了其它的数据结构，如： 集合 集合 —— 数据元素属于一个集合。 线型结构 线型结构 —— 一个对一个，如线性表、栈、队列，每一个节点和其它节点之间的关系 一个对一个 一个对一个。 树型结构 树型结构 —— 一个对多个，如树。 现在要接触一下图这个结构了，图是多个对多个的结构，其没有初始结点，也没有最终结点。每一个节点都称为顶点。 图 图——因为图是若干个顶点，顶点之间相互连接，没有先后顺序，所以图没有顺序存储结构，但可以借助二维数组来表示元素间的关系（ 邻接矩阵 邻接矩阵）。
数据结构试卷（一）王彬
qq_64919823的博客
07-02 663
1．设某数据结构的二元组形式表示为A=(D，R)，D={01，02，03，04，05，06，07，08，09}，R={r}，r={<01，02>，<01，03>，<01，04>，<02，05>，<02，06>，<03，07>，<03，08>，<03，09>}，则数据结构A是（ ）。3．设有向图G的二元组形式表示为G =（D，R），D={1，2，3，4，5}，R={r}，r={<1,2>，<2,4>，<4,5>，<1,3>，<3,2>，<3,5>}，则给出该图的一种拓扑排序序列__________。
Java [数据结构] Deque与Queue
lenyan~的博客
06-30 901
Queue适用于需要先进先出的情况，常见实现类如LinkedList和。Deque提供了更多的灵活性，可以作为队列（FIFO）和栈（LIFO）使用，常见实现类如LinkedList和ArrayDeque。觉得有用的话可以，支持一下。如果愿意的话关注一下。会对你有更多的帮助。每天都会不定时更新哦 >人
数据结构第04节：数组
hummhumm的专栏
07-02 1146
如果货架已经放满了，你就不能在这个货架上再添加更多的商品了，除非你更换一个更大的货架，这类似于Java中的静态数组。数组可以是静态的或动态的。这就像Java中的动态数组，随着元素的添加，数组会自动增加容量。虽然Java的数组本身不支持动态扩展，但我们可以通过创建一个新的数组并将旧数组的内容复制到新数组中来实现。接下来，我们可以进一步讨论数组的更多特性和操作，包括数组的初始化、遍历、搜索、排序和多维数组的使用。让我们通过Java代码来进一步探讨数组的使用，包括数组的逆序、数组的旋转以及数组的动态扩展。
优先队列在数据结构中的作用与实现方式
技术研究中心
07-02 461
堆是实现优先队列的一种有效方式，通常使用最小堆（Min-Heap）或最大堆（Max-Heap）来实现优先队列的功能。优先队列（Priority Queue）是一种特殊的队列，每次出队的元素都是队列中优先级最高（或最低）的元素。与普通队列不同的是，优先队列不是先进先出的结构，而是根据元素的优先级确定出队顺序。通过理解优先队列的特性和使用场景，可以更好地应用于实际的算法设计和系统开发中，提高程序的效率和性能。优先队列在各种算法和系统中的应用非常广泛，通过优先队列可以有效地管理和处理具有优先级的任务或数据。
数据结构(3.4)——队列的基本概念
m0_65240792的博客
07-01 179
队列(Queue)是只允许在一端进行插入（入队），另一端删除（出队）的线性表(操作受限)特点：先进入队列的元素先出队，先进先出 First In FIrst Out（FIFO），例如食堂打饭，高速公路过站点重要术语：队头，队尾，空队列InitQueue(&Q):初始化队列，构造一个空队列QDestoryQueue(&Q):销毁队列，销毁并释放队列Q所占用的内存空间EnQueue(&Q,x):入队，若队列Q未满，将x加入，使之成为新的队尾DeQueue(&Q,&x):出队，若队列Q非空，删除队头元素，并用x返
深入探讨数据结构：基础理论与应用实践
m0_46566693的博客
07-02 600
深入探讨数据结构：基础理论与应用实践
冒泡排序、选择排序、插入排序~java版
weixin_70044963的博客
06-30 310
三种基本算法排序：冒泡排序、选择排序以及插入排序的简单介绍以及代码实现（java语言）
数据结构-第八章（1.基本概念）
2203_75970230的博客
06-30 332
读者应深入掌握各种排序算法的思想、排序过程（手动过程）和特征（初态的影响、复杂度、稳定性、适用性等），通常以选择题的形式考查不同算法之间的对比。此外，对于一些常用排序算法的关键代码，要达到熟练编写的程度；这一章，比第七章，在理解上是更容易理解，这一章，在一轮的时候，只单独的把各各排序相对于单独学了，没有串起来。不过建议8.6，可以以背诵的形式，对比理解，在单独的每一种排序，就刷题，看视频就可以了。注：这一章我花了两天半的时间过完，有点赶，对于一轮复习，我没有做8.6各部分内部排序算法的比较及应用。
【数据结构】03.顺序表的应用——通讯录
2301_80258336的博客
07-02 482
顺序表实现通讯录的增删查改
C语言的数据结构：图的操作
Caoshuang_的博客
07-02 1123
注意：在遍历的过程中，可能会出现回路已经访问过的节点还要重新访问一次当从A开始访问时，先访问A，然后C，这时候由于C和D没有连接，无法直接到达D，需要再回到A，此时A就被多次访问了。可以创建一个数组用于保存访问过的顶点。
C++ map set 红黑树
07-28
使用map和set可以实现高效的查找、插入和删除操作，时间复杂度为O(logN)，其中N为容器中元素的个数。同时，由于基于红黑树的特性，这两个容器还能提供一些额外的操作，例如查找某个区间内的元素。 你可以使用C++...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值