• 【C++】封装map和set（红黑树实现）

    前言：

           前面，我们学习了set和map的用法，这两个容器可以完成查找，排序等操作，后来我们在学习过二叉搜索树的基础上又学习了两种特殊的二叉搜索树——AVL树和红黑树，他们俩可以是效率进一步提高，其实set和map的底层就是由红黑树封装而成的！

           所以，本篇文章我们自己学习用红黑树封装set和map。用红黑树封装，特别是用同一棵红黑树实现封装有一定的难度，其中很多操作（比如复用）我们会第一次尝试，所以大家请跟紧作者的脚步来。

    目录

    （一）如何复用同一棵红黑树

    （二）红黑树的改造流程（为封装做铺垫）

    1、结点的定义

    2、模拟实现结点的比较大小

    3、改造后的红黑树

    4、map和set迭代器的模拟实现

    4.1模版参数的构成

    4.2begin()和end()的模拟实现

    4.3operator* 和 operator->模拟实现

    4.4 operator++ 和 operator--模拟实现

    4.5 operator== 和 operator!=模拟实现

    4.6迭代器代码详解

     （三）封装map和set

    （一）如何复用同一棵红黑树

    前提疑问：

    在我们这所有的之前我们知道，map和set这两个容器都是用红黑树来实现的，那么就有了接下来的问题。

    • map和set都是用的同一棵红黑树复用的吗
    • 或者这两个容器各自使用一棵红黑树吗

    其实在前言中我们就知道了，根据STL的设计理念和泛型编程的理念，我们不会冗余的写两课红黑树，而是用一棵红黑树实现复用的效果。

    我们调用STL库中的原码来看：

    我们发现：

    • STL库中的原码也确实调用的同一棵红黑树
    • 他们实现的都是key_value模型

    我们设set中存放结点的值是K，map中存放的节点是pair键值对：

    • 对于set而言，底层红黑树的模版就是RBTree
    • 对于map而言，底层红黑树的模版就是RBTree>

    这时我们就有了另一个疑问，两个模板参数的第一个Key，不能省略掉吗？？

    • 首先，答案肯定是不能的
    • 那么原因又是什么呢？

    因为map的这个类中，无论怎么省略都会有一个查找函数要单独用到Key

    如果第一个Key删去了，那么map和set的查找函数就没法统一实现了，违背了我们一开始泛型编程的思想。

    综上所述：

    • map和set都是用了，Key_value模型
    • set中的K是K，V也是K
    • map中的K是K，V是pair
    • 并且模板参数中第一个K都不能省

    （二）红黑树的改造流程（为封装做铺垫）

    1、结点的定义

    这里由于set和map存放的结点一个是Key一个是pair，所以我们使用模版，把存放的结点泛化。

    2、模拟实现结点的比较大小

    • 上述提到，在模拟实现中，map和set我们复用同一棵红黑树的时候都是用的是Kye_value的结构
    • 但是红黑树中的数据比较又是Key值的比较，而现在我们用的则是pair的比较
    • 虽然编译上是可以通过但是真的就是我们所想要的吗？

    pair的比较大小：

    很显然这种比较规则不是我们所想要的，并且map和set想要取到用来比较的数据是不同的。 

    为了取到我们想要的数据，我们引入了仿函数：

    • 根据map和set的需求不同
    • 我们在红黑树中新引入了一个模板参数KeyOfT

     

    引入KeyOfT模板参数后，我们想要不同方式的比较方法只需要在set和map的封装中给出属于他们自己的比较仿函数。

    map中的仿函数： 

    set中的仿函数：

    使用方法：

     此时前面所说的仿函数的便利之处就体现出来了。

    3、改造后的红黑树

    具体代码：

    1. //红黑树的实现
    2. //KeyOfT --> 支持取出T对象中key的仿函数
    3. template<class K, class T, class KeyOfT>
    4. class RBTree
    5. {
    6. 	typedef RBTreeNode<T> Node;
    7. public:
    8. 	typedef __RBTreeIterator<T, T&, T*> iterator;
    9. 	typedef __RBTreeIterator<T, const T&, const T*> const_iterator;
    10.  
    11. 	//构造 拷贝构造 赋值 和析构 跟搜索树实现方式是一样的
    12.  
    13. 	//迭代器中序遍历，要找最左结点
    14. 	iterator Begin()
    15. 	{
    16. 		Node* subLeft = _root;
    17. 		while (subLeft && subLeft->_left)
    18. 		{
    19. 			subLeft = subLeft->_left;
    20. 		}
    21.  
    22. 		//树的迭代器用结点的指针就可以构造
    23. 		return iterator(subLeft);
    24. 	}
    25.  
    26. 	iterator End()
    27. 	{
    28. 		return iterator(nullptr);
    29. 	}
    30.  
    31. 	const_iterator Begin() const
    32. 	{
    33. 		Node* subLeft = _root;
    34. 		while (subLeft && subLeft->_left)
    35. 		{
    36. 			subLeft = subLeft->_left;
    37. 		}
    38.  
    39. 		//树的迭代器用结点的指针就可以构造
    40. 		return const_iterator(subLeft);
    41. 	}
    42.  
    43. 	const_iterator End() const
    44. 	{
    45. 		return const_iterator(nullptr);
    46. 	}
    47.  
    48. 	pair<iterator, bool> Insert(const T& data)
    49. 	{
    50. 		//1、搜索树的规则插入
    51. 		//2、看是否违反平衡规则，如果违反就需要处理：旋转
    52. 		if (_root == nullptr)
    53. 		{
    54. 			_root = new Node(data);
    55. 			_root->_col = BLACK; //根节点是黑色
    56. 			return make_pair(iterator(_root), true);
    57. 		}
    58.  
    59. 		KeyOfT kot;
    60.  
    61. 		Node* parent = nullptr;
    62. 		Node* cur = _root;
    63.  
    64. 		while (cur)
    65. 		{
    66. 			if (kot(cur->_data) < kot(data))
    67. 			{
    68. 				parent = cur;
    69. 				cur = cur->_right;
    70. 			}
    71. 			else if (kot(cur->_data) > kot(data))
    72. 			{
    73. 				parent = cur;
    74. 				cur = cur->_left;
    75. 			}
    76. 			else
    77. 			{
    78. 				return make_pair(iterator(cur), false);
    79. 			}
    80. 		}
    81.  
    82. 		//找到符合规则的位置之后再插入
    83. 		cur = new Node(data); 
    84. 		Node* newnode = cur;
    85. 		cur->_col = RED;
    86.  
    87. 		if (kot(parent->_data) < kot(data))
    88. 		{
    89. 			parent->_right = cur;
    90. 		}
    91. 		else
    92. 		{
    93. 			parent->_left = cur;
    94. 		}
    95.  
    96. 		//三叉链的链接 -- 链上父节点
    97. 		cur->_parent = parent;
    98.  
    99. 		//存在连续红色结点
    100. 		while (parent && parent->_col == RED)
    101. 		{
    102. 			//理论而言，祖父是一定存在的，父亲存在且是红不可能是根（根一定是黑的）
    103. 			Node* grandfather = parent->_parent;
    104. 			assert(grandfather);
    105.  
    106. 			if (grandfather->_left == parent)
    107. 			{
    108. 				Node* uncle = grandfather->_right;
    109. 				//情况一：（叔叔存在且为红）
    110. 				if (uncle && uncle->_col == RED)
    111. 				{
    112. 					//祖父和叔叔变成黑色
    113. 					parent->_col = uncle->_col = BLACK;
    114. 					grandfather->_col = RED;
    115.  
    116. 					//继续往上处理
    117. 					cur = grandfather;
    118. 					parent = cur->_parent;
    119. 				}
    120. 				//情况二：（叔叔不存在 or 叔叔存在且为黑）
    121. 				else
    122. 				{
    123. 					//单旋
    124. 					//	   g
    125. 					//	 p
    126. 					// c
    127. 					if (cur == parent->_left)
    128. 					{
    129. 						RotateR(grandfather);
    130. 						parent->_col = BLACK;
    131. 						grandfather->_col = RED;
    132. 					}
    133. 					//双旋
    134. 					//    g
    135. 					//  p
    136. 					//    c
    137. 					else
    138. 					{
    139. 						RotateL(parent);
    140. 						RotateR(grandfather);
    141. 						cur->_col = BLACK;
    142. 						grandfather->_col = RED;
    143. 					}
    144.  
    145. 					break;
    146. 				}
    147. 			}
    148. 			//无论父亲和叔叔是左是右都是一样的
    149. 			//grandfather->_right == parent;
    150. 			else
    151. 			{
    152. 				Node* uncle = grandfather->_left;
    153. 				//情况一：
    154. 				if (uncle && uncle->_col == RED)
    155. 				{
    156. 					//祖父和叔叔变成黑色
    157. 					parent->_col = uncle->_col = BLACK;
    158. 					grandfather->_col = RED;
    159.  
    160. 					//继续往上处理
    161. 					cur = grandfather;
    162. 					parent = cur->_parent;
    163. 				}
    164. 				else
    165. 				{
    166. 					//单旋
    167. 					// g
    168. 					//   p
    169. 					//     c
    170. 					if (cur == parent->_right)
    171. 					{
    172. 						RotateL(grandfather);
    173. 						parent->_col = BLACK;
    174. 						grandfather->_col = RED;
    175. 					}
    176. 					//双旋
    177. 					//  g
    178. 					//    p
    179. 					//  c
    180. 					else
    181. 					{
    182. 						RotateR(parent);
    183. 						RotateL(grandfather);
    184. 						cur->_col = BLACK;
    185. 						grandfather->_col = RED;
    186. 					}
    187.  
    188. 					break;
    189. 				}
    190. 			}
    191. 		}
    192.  
    193. 		//父亲为空就出循环，将根节点设置成黑色
    194. 		_root->_col = BLACK;
    195.  
    196. 		return make_pair(iterator(newnode), true);
    197. 	}
    198. }

    插入（Insert）和寻找（Find）代码：
     

    1.  
    2. 	Node* Find(const K& key)
    3. 	{
    4. 		Node* cur = _root;
    5. 		KeyOfT kot;
    6. 		while (cur)
    7. 		{
    8. 			if (kot(cur->_data) < key)
    9. 			{
    10. 				cur = cur->_right;
    11. 			}
    12. 			else if (kot(cur->_data) > key)
    13. 			{
    14. 				cur = cur->_left;
    15. 			}
    16. 			else
    17. 			{
    18. 				return cur;
    19. 			}
    20. 		}
    21.  
    22. 		return nullptr;
    23. 	}
    24.  
    25. 	pair<itertaor, bool> Insert(const T& data)
    26. 	{
    27. 		if (_root == nullptr)
    28. 		{
    29. 			_root = new Node(data);
    30. 			_root->_col = BLACK;
    31.  
    32. 			return make_pair(itertaor(_root), true);
    33. 		}
    34.  
    35. 		KeyOfT kot;
    36. 		Node* parent = nullptr;
    37. 		Node* cur = _root;
    38. 		while (cur)
    39. 		{
    40. 			if (kot(cur->_data) < kot(data))
    41. 			{
    42. 				parent = cur;
    43. 				cur = cur->_right;
    44. 			}
    45. 			else if (kot(cur->_data) > kot(data))
    46. 			{
    47. 				parent = cur;
    48. 				cur = cur->_left;
    49. 			}
    50. 			else
    51. 			{
    52. 				return make_pair(itertaor(cur), false);
    53. 			}
    54. 		}
    55.  
    56. 		cur = new Node(data);
    57. 		Node* newnode = cur;
    58. 		if (kot(parent->_data) > kot(data))
    59. 		{
    60. 			parent->_left = cur;
    61. 		}
    62. 		else
    63. 		{
    64. 			parent->_right = cur;
    65. 		}
    66. 		cur->_parent = parent;
    67.  
    68. 		while (parent && parent->_col == RED)
    69. 		{
    70. 			Node* grandfather = parent->_parent;
    71. 			if (grandfather->_left == parent)
    72. 			{
    73. 				Node* uncle = grandfather->_right;
    74. 				// 情况1：u存在且为红，变色处理，并继续往上处理
    75. 				if (uncle && uncle->_col == RED)
    76. 				{
    77. 					parent->_col = BLACK;
    78. 					uncle->_col = BLACK;
    79. 					grandfather->_col = RED;
    80.  
    81. 					// 继续往上调整
    82. 					cur = grandfather;
    83. 					parent = cur->_parent;
    84. 				}
    85. 				else // 情况2+3：u不存在/u存在且为黑，旋转+变色
    86. 				{
    87. 					//     g
    88. 					//   p   u
    89. 					// c 
    90. 					if (cur == parent->_left)
    91. 					{
    92. 						RotateR(grandfather);
    93. 						parent->_col = BLACK;
    94. 						grandfather->_col = RED;
    95. 					}
    96. 					else
    97. 					{
    98. 						//     g
    99. 						//   p   u
    100. 						//     c
    101. 						RotateL(parent);
    102. 						RotateR(grandfather);
    103. 						cur->_col = BLACK;
    104. 						//parent->_col = RED;
    105. 						grandfather->_col = RED;
    106. 					}
    107.  
    108. 					break;
    109. 				}
    110. 			}
    111. 			else // (grandfather->_right == parent)
    112. 			{
    113. 				//    g
    114. 				//  u   p
    115. 				//        c
    116. 				Node* uncle = grandfather->_left;
    117. 				// 情况1：u存在且为红，变色处理，并继续往上处理
    118. 				if (uncle && uncle->_col == RED)
    119. 				{
    120. 					parent->_col = BLACK;
    121. 					uncle->_col = BLACK;
    122. 					grandfather->_col = RED;
    123.  
    124. 					// 继续往上调整
    125. 					cur = grandfather;
    126. 					parent = cur->_parent;
    127. 				}
    128. 				else // 情况2+3：u不存在/u存在且为黑，旋转+变色
    129. 				{
    130. 					//    g
    131. 					//  u   p
    132. 					//        c
    133. 					if (cur == parent->_right)
    134. 					{
    135. 						RotateL(grandfather);
    136. 						grandfather->_col = RED;
    137. 						parent->_col = BLACK;
    138. 					}
    139. 					else
    140. 					{
    141. 						//    g
    142. 						//  u   p
    143. 						//    c
    144. 						RotateR(parent);
    145. 						RotateL(grandfather);
    146. 						cur->_col = BLACK;
    147. 						grandfather->_col = RED;
    148. 					}
    149.  
    150. 					break;
    151. 				}
    152. 			}
    153. 		}
    154.  
    155. 		_root->_col = BLACK;
    156.  
    157. 		return make_pair(itertaor(newnode), true);;
    158. 	}

    4、map和set迭代器的模拟实现

    上面改造后的红黑树中已经涉及到了迭代器，这里我们来模拟实现。

    备注：

    • T：数据
    • Ref：引用
    • Ptr：指针
    • Sef：iterator本身

    4.1模版参数的构成

    要想实现同一棵红黑树的复用，模版参数的构成极为重要。

    之前我们也遇到过相似的情况，我们这里的实现方法参看之前。

    迭代器的实现中：

    • 涉及到了*解引用操作，返回的是数据的引用；
    • 涉及到了->指针操作，返回的是数据的地址;
    • 涉及到++，--操作，返回的是操作后迭代器本身的位置。

    但是以上的行为，我们都涉及结点，所以结点的数据类型也尤为重要！

    综上，模版参数的构成如下图：

    4.2begin()和end()的模拟实现

    • 因为是二叉搜索树，为了更有顺序，所以我们采取的是中序遍历。
    • 那么中序遍历Begin（）就应该是最左结点
    • 我们实现的版本中End（）定义为空是（nullptr）

    ps：

    而库中的红黑树则是设计了一个哨兵位的头结点：

    所以我们实现的只是简化版本。

    4.3operator* 和 operator->模拟实现

    就是正常的运用operator，但是operator->和list中讲的一样，返回的是地址的原因是为了连续访问（连续的operator->会优化成一个->）

    4.4 operator++ 和 operator--模拟实现

    这里迭代器的++和- - 需要分类一下，分别是：前置++，- - 、后置++，- -

    前置++ ：
    因为我们是中序遍历，我们访问完自己之后，下一个该访问哪一个结点？

    我们观察任何一棵二叉树都能看出，无非是下面两种情况：

    分如下两种情况：（重点）

    • 右子树为空：找孩子是父亲的左的那个祖先节点，否则继续往上走，直到空（nullptr）
    • 右子树为非空：找右子树的最左节点

    这一过程有点类似于递归思想，但是是非递归实现的

    代码实现：

     前置-- ：

    有了上面的思路，我们联想一下，现在需要看当前位置左子树是否是空。

    前置- -就是倒着走，同样还是对当前位置分两种情况：（重点）

    1. 左子树为空：找孩子是父亲的右的那个祖先节点，否则继续往上走，直到空（nullptr）
    2. 左子树为非空：找左子树的最右节点

    只要前置++理解了，那么前置- -完全就是前置++倒过来走一遍。

    后置++、后置- - ：

    和之前实现容器的得带器一样，我们这里直接复用即可：

    4.5 operator== 和 operator!=模拟实现

    有了之前封装迭代器的经验，这两个的视线还是比较容易得：

    4.6迭代器代码详解

    1. template<class T, class Ref, class Ptr>
    2. struct __RBTreeIterator
    3. {
    4. 	typedef RBTreeNode<T> Node;
    5. 	Node* _node;
    6.  
    7. 	typedef __RBTreeIterator<T, Ref, Ptr> Self;
    8.  
    9. 	__RBTreeIterator(Node* node)
    10. 		:_node(node)
    11. 	{}
    12.  
    13. 	Ref operator*()
    14. 	{
    15. 		return _node->_data;
    16. 	}
    17.  
    18. 	Ptr operator->()
    19. 	{
    20. 		return &_node->_data;
    21. 	}
    22.  
    23. 	Self& operator++()
    24. 	{
    25. 		if (_node->_right == nullptr)
    26. 		{
    27. 			//找祖先里面，孩子是父亲左的那个
    28. 			Node* cur = _node;
    29. 			Node* parent = cur->_parent;
    30. 			while (parent && parent->_right == cur)
    31. 			{
    32. 				cur = cur->_parent;
    33. 				parent = parent->_parent;
    34. 			}
    35.  
    36. 			_node = parent;
    37. 		}
    38. 		else
    39. 		{
    40. 			//右子树的最左结点
    41. 			Node* subLeft = _node->_right;
    42. 			while (subLeft->_left)
    43. 			{
    44. 				subLeft = subLeft->_left;
    45. 			}
    46.  
    47. 			//左为空
    48. 			_node = subLeft;
    49. 		}
    50. 		return *this;
    51. 	}
    52.  
    53. 	Self& operator--()
    54. 	{
    55. 		if (_node->_left == nullptr)
    56. 		{
    57. 			//找祖先里面，孩子是父亲
    58. 			Node* cur = _node;
    59. 			Node* parent = cur->_parent;
    60. 			while (parent && cur == parent->_left)
    61. 			{
    62. 				cur = cur->_parent;
    63. 				parent = parent->_parent;
    64. 			}
    65.  
    66. 			_node = parent;
    67. 		}
    68. 		else
    69. 		{
    70. 			//左子树的最右结点
    71. 			Node* subRight = _node->_left;
    72. 			while (subRight->_right)
    73. 			{
    74. 				subRight = subRight->_right;
    75. 			}
    76.  
    77. 			_node = subRight;
    78. 		}
    79.  
    80. 		return *this;
    81. 	}
    82.  
    83. 	Self operator++(int)
    84. 	{
    85. 		Self tmp(*this);
    86.  
    87. 		++(*this);
    88.  
    89. 		return tmp;
    90. 	}
    91.  
    92. 	Self operator--(int)
    93. 	{
    94. 		Self tmp(*this);
    95. 		
    96. 		--(*this);
    97.  
    98. 		return tmp;
    99. 	}
    100.  
    101. 	bool operator!=(const Self& s) const
    102. 	{
    103. 		return _node != s._node;
    104. 	}
    105.  
    106. 	bool operator==(const Self& s) const
    107. 	{
    108. 		return _node == s._node;
    109. 	}
    110. };

     （三）封装map和set

    有了上面的红黑树的改装，我们这里的对map和set的封装就显得很得心应手了。

    封装主要是把map和set的基本操作封装在一个类中。

    map的封装：

    1. template<class K, class V>
    2. class map
    3. {
    4. 	//定义一个内部类
    5. 	struct MapKeyOfT
    6. 	{
    7. 		const K& operator()(const pair<K, V>& kv)//operator() 可以像函数一样去使用
    8. 		{
    9. 			return kv.first;
    10. 		}
    11. 	};
    12.  
    13. public:
    14. 	typedef typename RBTree<K, pair<K, V>, MapKeyOfT>::iterator iterator;
    15. 	typedef typename RBTree<K, pair<K, V>, MapKeyOfT>::const_iterator const_iterator;
    16.  
    17. 	iterator begin()
    18. 	{
    19. 		return _t.Begin();
    20. 	}
    21.  
    22. 	iterator end()
    23. 	{
    24. 		return _t.End();
    25. 	}
    26.  
    27. 	pair<iterator, bool> insert(const pair<K, V>& kv)
    28. 	{
    29. 		return _t.Insert(kv);
    30. 	}
    31.  
    32. 	V& operator[](const K& key)
    33. 	{
    34. 		pair<iterator, bool> ret = insert(make_pair(key, V()));
    35. 		return ret.first->second;
    36. 	}
    37. private:
    38. 	RBTree<K, pair<K, V>, MapKeyOfT> _t;
    39. };

    这里map中的operator[ ]我们知道其原理之后，模拟实现就非常方便，直接调用插入函数，控制好参数和返回值即可。

    对set的封装：

    1. template<class K>
    2. class set    
    3. {
    4. 	struct SetKeyOfT
    5. 	{
    6. 		const K& operator()(const K& key)//operator() 可以像函数一样去使用
    7. 		{
    8. 			return key;
    9. 		}
    10. 	};
    11. public:
    12.  
    13. 	//加上typename告诉编译器这是个类型，类模板实例化了再去取
    14. 	typedef typename RBTree<K, K, SetKeyOfT>::const_iterator iterator;
    15. 	typedef typename RBTree<K, K, SetKeyOfT>::const_iterator const_iterator;
    16.  
    17. 	iterator begin() const
    18. 	{
    19. 		return _t.Begin();
    20. 	}
    21.  
    22. 	iterator end() const
    23. 	{
    24. 		return _t.End();
    25. 	}
    26.  
    27. 	pair<iterator, bool> insert(const K& key)
    28. 	{
    29. 		//pair<typename RBTree<K, K, SetKeyOfT>::iterator, bool> ret = _t.Insert(key);
    30. 		auto ret = _t.Insert(key);
    31. 		return pair<iterator, bool>(iterator(ret.first._node), ret.second);
    32. 	}
    33.  
    34. 	iterator find(const K& key)
    35. 	{
    36. 		return _t.Find(key);
    37. 	}
    38.  
    39. private:
    40. 	RBTree<K, K, SetKeyOfT> _t;
    41. };

    附详细代码：——》红黑树封装map和set

  • 相关阅读:
    MySql学习笔记10——视图介绍
    Pinyin4j介绍和简单使用
    全网最全JAVA面试八股文，终于整理完了
    50天50个前端小项目（纯html+css+js）第十八天（背景轮播图）
    Beelzebub过程记录及工具集
    RBF神经网络案例——客户流失率预测
    Opencv基于文字检测去图片水印
    Codeforces Round 958 (Div. 2)[部分题解ABC]
    Stable Diffussion和MJ的详细对比
    MySQL中的事务
  • 原文地址：https://blog.csdn.net/m0_67821824/article/details/132767277