C++---红黑树模拟实现STL中的map与set

已于 2023-03-23 22:21:10 修改
阅读量568 收藏
点赞数
分类专栏： 数据结构 C++ 文章标签： 数据结构 c++
于 2022-11-07 10:42:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/blue_jun_/article/details/127717361
版权

     

目录

set的封装：

map的封装：

RBTree迭代器模板

map加迭代器后的封装

set加迭代器后的封装

       我们知道，map和set底层是红黑树实现的，但是set类型是key类型，而map类型是key，value类型，那么是否意味着我们要实现两颗红黑树去分别实现map和set呢？

        这里我们还是利用类模板去封装，在原来《实现红黑树》的基础上修改一番。

        首先，我们将原来节点中用来存储节点值的 pair键值对 改为 模板参数 T。

template<class T>
struct RBTreeNode
{
	RBTreeNode* _left;
	RBTreeNode* _right;
	RBTreeNode* _parent;

	//pair<K, V> _kv;
	T _data;//节点值用T表示，封装set时T为key，封装map时T为pair<K,V>键值对
	Color _col;

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

其次，红黑树节点插入设计节点值比较，但是由于set和map类型不同，不能用同一种方式比较，因此红黑树的定义中传入的模板参数需要加上一个仿函数，用于比较节点值。

// 因为关联式容器中存储的是<key, value>的键值对，因此
// k为key的类型，
// T: 如果是map，则为pair<K, V>; 如果是set，则为k
// KeyOfT: 通过T来获取key的一个仿函数类
template<class K, class T,class KeyOfT>
struct RBTree
{
	typedef RBTreeNode<T> Node;
public:
	bool Insert(const T& data)
	{
		KeyOfT kot;//定义仿函数kot用于节点比较

		if (_root == nullptr)
		{
			_root = new Node(data);
			_root->_col = BLACK;//根节点为黑色
			return 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 false;
			}
		}
		//cur走到要插入的位置
		cur = new Node(data);
		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* grandfather = parent->_parent;
			assert(grandfather);
			assert(grandfather->_col == BLACK);
			//关键看叔叔
			if (parent == grandfather->_left)
			{
				Node* uncle = grandfather->_right;
				//情况一:uncle存在且为红
				if (uncle && uncle->_col == RED)
				{
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;
					//继续往上处理
					cur = grandfather;
					parent = cur->_parent;
				}
				else//情况二+三：uncle不存在+存在且为黑
				{
					//     g
					//   p   u
					// c
					if (cur == parent->_left)
					{
						RotateR(grandfather);
						//变色
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else
					{
						//     g
						//   p   u
						//    c
						RotateL(parent);
						RotateR(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}
					break;
				}
			}
			else//parent == grandfather->_right
			{
				Node* uncle = grandfather->_left;
				//情况一
				if (uncle && uncle->_col == RED)
				{
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;
					//继续往上处理
					cur = grandfather;
					parent = cur->_parent;
				}
				else//情况二+三：uncle不存在+存在且为黑
				{
					//     g
					//   u   p
					//         c
					if (cur == parent->_right)
					{
						RotateL(grandfather);
						//变色
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else
					{
						//     g
						//   u   p
						//      c
						RotateR(parent);
						RotateL(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}
					break;
				}
			}
		}
		//根节点一定为黑
		_root->_col = BLACK;
		return true;
	}
private：
void RotateL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;

		parent->_right = subRL;
		if (subRL)//subRL可以为空，所以加条件
		{
			subRL->_parent = parent;
		}
		//parnet 可能为根也可以不是，记录一下
		Node* ppNode = parent->_parent;

		subR->_left = parent;
		parent->_parent = subR;

		if (_root == parent)
		{
			_root = subR;
			subR->_parent = nullptr;
		}
		else
		{
			if (ppNode->_left == parent)
			{
				ppNode->_left = subR;
			}
			else
			{
				ppNode->_right = subR;
			}
			subR->_parent = ppNode;
		}
	}
	void RotateR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;

		parent->_left = subLR;
		if (subLR)//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;
		}
	}
private:
	Node* _root = nullptr;
}；

set的封装：

#include"RBTree.h"

namespace zj
{
	template<class K>
	class set
	{
		struct SetKeyOfT//用于比较set节点值的仿函数类
		{
			const K& operator()(const K& key)
			{
				return key;
			}
		};
	public:
		bool insert(const K& key)
		{
			return _t.Insert(key);
		}
	private:
		RBTree<K, K, SetKeyOfT> _t;
	};
}

map的封装：

#include"RBTree.h"

namespace zj
{
	template<class K, class V>
	class map
	{
		struct MapKeyOfT//用于比较map节点值的仿函数类
		{
			const K& operator()(const pair<K,V>& kv)
			{
				return kv.first;
			}
		};
	public:
		bool insert(const pair<K, V>& kv)
		{
			return _t.Insert(kv);
		}
	private:
		RBTree<K, pair<K, V>,MapKeyOfT> _t;
	};
}

RBTree迭代器模板

template<class T, class Ref, class Ptr>
struct __RBTreeIterator
{
	typedef RBTreeNode<T> Node;
	typedef __RBTreeIterator<T, Ref, Ptr> Self;
	Node* _node;

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

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

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

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

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

	Self& operator++()
	{
		//右子树不为空
		if (_node->_right)
		{
			//下一个就是右子树最左节点
			Node* left = _node->_right;
			while (left->_left)
			{
				left = left->_left;
			}
			_node = left;
		}
		else//右子树为空
		{
			//找祖先里面孩子不是祖先右的那个
			Node* parent = _node->_parent;
			Node* cur = _node;
			while (parent && cur == parent->_right)
			{
				cur = cur->_parent;
				parent = parent->_parent;
			}
			_node = parent;
		}
		return *this;
	}

	Self& operator--()//与++过程相反
	{
		//左子树不为空
		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 RBTreeNode<T> Node;
public:
	typedef __RBTreeIterator<T, T&, T*> iterator;

	iterator begin()
	{
		Node* left = _root;
		while (left && left->_left)
		{
			left = left->_left;
		}
		return iterator(left);
	}

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

map加迭代器后的封装

template<class K, class V>
	class map
	{
		struct MapKeyOfT
		{
			const K& operator()(const pair<K,V>& kv)
			{
				return kv.first;
			}
		};
	public:
		//加typename告诉编译器RBTree<K, pair<K, V>, MapKeyOfT>::iterator是类型不是静态变量
		typedef typename RBTree<K, pair<K, V>, MapKeyOfT>::iterator iterator;

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

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

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

		V& operator[](const K& key)
		{
			pair<iterator, bool> ret = insert(make_pair(K, V()));
			return ret.first->second;
		}
	private:
		RBTree<K, pair<K, V>,MapKeyOfT> _t;
	};

set加迭代器后的封装

template<class K>
	class set
	{
		struct SetKeyOfT
		{
			const K& operator()(const K& key)
			{
				return key;
			}
		};
	public:
		//加typename告诉编译器RBTree<K, pair<K, V>, MapKeyOfT>::iterator是类型不是静态变量
		typedef typename RBTree<K, K, SetKeyOfT>::iterator iterator;

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

		iterator end()
		{
			return _t.end();
		}
		pair<iterator, bool> insert(const K& key)
		{
			return _t.Insert(key);
		}
	private:
		RBTree<K, K, SetKeyOfT> _t;
	};

不秃头的小猿
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SGISTL源码探究-STL中的红黑树(上)
Move_now的博客
09-16 1573
前言本小节将进入到SGISTL的红黑树部分。关于红黑树,是一种比较复杂的数据结构,但是并不是特别难。如果对红黑树不太了解,可以去网上查阅相关的资料,因为本文的主要目的是分析STL中的红黑树的源码,和普通的红黑树略有不同,还要复杂一些,需要有一定的基础。基本概念首先什么是二叉搜索树,二叉搜索树即符合任何一个节点的值一定大于其左子树的任何一个节点的值并且小于其右子树的任何一个节点的值(节点的值不允许重复
红黑树模拟实现STL中的map与set（附详细代码）
zhao_leilei的博客
01-26 701
文章目录1.红黑树的迭代器2.改造红黑树3.map的模拟实现4.set的模拟实现 1.红黑树的迭代器 迭代器的好处是可以方便遍历，使数据结构的底层实现与用户透明。如果想要给红黑树增加迭代器，需要考虑以下问题： begin()与end() STL明确规定，begin()与end()代表的是一段前闭后开的区间，而对红黑树进行中序遍历后，可以得到一个有序的序列，因此：begin()可以放在红黑树中最小节点(即最左侧节点)的位置，end()放在最大节点(最右侧节点)的下一个位置，关键是最大节点的下一个位置在哪块？能
红黑树实现——STL中的map
zhongjie的专栏
11-04 7810
红黑树实现——STL中的map [ 2009-07-24 13:55:31 | 作者: dklkt ] 字号: 大 | 中 | 小 [转载]STL中map实现技术 来源：http://blog.csdn.net/Fandywang_jlu/archive/2008/03/23/2208363.aspx 红黑树是一种自平衡二叉查找树，是在计算机科学中用到的一种数据结构，
学习-＞C++篇十五：红黑树和map,set
u014801954的博客
10-18 788
目录 一 . 红黑树的定义（规则）： 二 . 红黑树是如何保持平衡的？ 插入操作： 情况一：叔叔节点存在且为红色 情况二：叔叔节点不存在或存在且为黑色 三.map和set如何封装？
C++红黑树模拟实现map和set
轻松学C语言
08-20 172
点击蓝字关注我们一、红黑树及其节点的设计对于底层都是红黑树的map和set来说，他们之间存在的最大的区别就是：对于set是K模型的容器，而map是KV模型的容器。为了更好的灵活兼容实现map和set，就需要在红黑树以及树节点上进行特别的设计1、树节点的设计对于红黑树的节点我们需要节点对于set来说储存key，对于map来说储存key-value键值对，所以这里我们就直接让节点类型的阈值类型为T，用...
科普解读：为什么C++ STL中的map使用红黑树而不是散列表？
Lion_Long的博客
07-27 1965
文章探讨了C++STL中的map使用红黑树而非散列表的原因，分析了红黑树和散列表在查找、插入、删除操作的时间复杂度、空间利用率等方面的差异，并介绍了unordered_map作为散列表实现的特点和应用场景。红黑树在保持良好平衡性的同时提供稳定的查找效率，适合有序存储，而unordered_map利用散列表实现快速插入和查找，但不保证元素顺序。
红黑树-基于C++实现的红黑树数据结构.zip
03-21
例如，在C++标准模板库(STL)中，`std::set`和`std::map`就是基于红黑树实现的。 在C++中实现红黑树时，通常会定义一个名为`RBTree`的类，包含私有成员变量（如根节点指针）和公共成员函数（如`insert`, `delete`, `...
【C++】红黑树详解并封装实现map和set
love_guanghui的博客
03-18 3151
红黑树详解
红黑树-基于C语言实现的红黑树数据结构.zip
最新发布
03-21
在实际应用中，红黑树广泛用于各种场景，如C++标准库中的STL map和set，它们底层就是基于红黑树实现的。红黑树的高效性和自平衡特性使得它在内存管理、数据库索引、文件系统等领域都有重要应用。理解并熟练掌握红黑...
C++ - SGI 版本 STL源码
10-25
- **set/multiset**: 基于红黑树的关联容器，存储唯一或允许重复的元素，支持O(log n)的查找、插入和删除操作。 - **map/multimap**: 类似于set，但键值对映射到特定值。 - **unordered_set/unordered_multiset**...
【C++】map&set利用红黑树进行简单封装
QiHai的博客
11-16 724
基于红黑树实现简单封装map和set。
C++中的红黑树：一种高效的数据结构
san_que的博客
11-12 183
在阅读红黑树的源代码时，需要从顶层向底层逐步分析，关注关键函数的实现，对比不同版本的红黑树实现，调试和测试代码，并参考其他资源。在删除一个节点时，需要先找到该节点的前驱节点或后继节点，然后通过颜色调整和旋转操作来重新调整树的结构，以保持树的平衡。在红黑树中，每个节点都维护了一个父节点指针。在插入一个新节点时，需要先找到插入位置的前驱节点或后继节点，然后通过颜色调整和旋转操作来保持树的平衡。在删除一个节点时，需要先找到该节点的前驱节点或后继节点，然后通过颜色调整和旋转操作来重新调整树的结构，以保持树的平衡。
STL容器之map和set的补充——红黑树
qq_33093885的博客
03-06 1086
c++红黑树的学习和模拟实现
【C++】红黑树详解（附迭代器以及插入实现），适合初学者
jhao的博客
07-13 2467
红黑树的简单实现附有迭代器实现，代码都有详细解释，适合于初学者和想要理解STL map/set原理的朋友观看。
Stl中map、set 容器（数据结构：AVL树、红黑树）--C++
qq_63412763的博客
09-24 2274
Stl的容器中，map和set都是用的树状数据结构----二叉树！但实际上用的并不是普普通通的树状结构，而是一种设计好的，规律性极强的树状数据结构：红黑树（二叉树的一种，细节下面讲）对于map和set来讲，中序遍历依旧是有序的，而这和之前讲的二叉搜索树有点相似。
stl map底层之红黑树插入步骤详解与代码实现
热门推荐
mxway的专栏
06-08 2万+
文章用图片的方式对红黑树插入过程的调整进行了详细解释。并给出红黑树插入调整实现的C++源码。
STL中的map、set（学完红黑树后的一个小总结）
Dachao0707的博客
01-01 395
树介绍 树是一种很常用的数据结构，在很多地方都能看到树的应用，因为树往往可以用来优化数据查找的效率。 在一些优秀的系统中就会经常用到各种树结构，比如红黑树、AVL树、B树等。 红黑树的应用： 原理： 根节点是黑色的 只有红黑节点 叶节点都是黑色的nil 红色节点子节点必须是黑色的 对每个节点，从该节点到叶子节点路径上的黑节点数目一致，黑平衡性质 以上的五个性质保证了红黑树是平衡的，所以红黑树的...
Java中的STL-HashMap中红黑树的原理和应用
qq_35170267的博客
02-28 4556
Java中的STL-HashMap中红黑树的原理和应用 红黑树 我相信大部分程序员对红黑树这个数据结构都不陌生。下面来巩固一下红黑树数据结构。 R-B Tree，全称是Red-Black Tree，又称为“红黑树”，它一种特殊的二叉查找树。红黑树的每个节点上都有存储位表示节点的颜色，可以是红(Red)或黑(Black)。它有以下几个特点。 1、 每个节点或者是黑色，或者是红色。 2 、根节点是黑...
STL map / set 底层机制: 红黑树完全剖析
专注游戏研发
08-21 2923
前言： 在 STL 的容器中两大阵营 (vector deque list forward_list) 顺序容器 与 关联容器 （map set unorder_map unorder_set） 。 关联容器指的是以关键字匹配指定数据的一种关联数据结构的集合， 在关联容器中通过关键字去查找对应的数据是非常块的， 下面我们会彻底地去剖析其底层实现机制 ： 红黑树。 由基础树 到 二叉搜索树 介绍红黑树之前，容许我介绍树的概念。 1. 树（tree）， 在计算机科学中，是十分基础的数据结构： .
探索搜索树：二叉、AVL、红黑与B-树的原理与应用
红黑树广泛应用于C++ STL中的关联容器，如set、map等。 4. **B-树** B-树是一种多路搜索树，适用于磁盘等外存环境下，它能在一次I/O操作中处理多个记录。B-树的特点是每个节点可以有多个子节点，并且所有叶子节点...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值