STL源码剖析（二十一）set、heap相关算法

最新推荐文章于 2023-03-22 15:56:27 发布
最新推荐文章于 2023-03-22 15:56:27 发布
阅读量114 收藏
点赞数
分类专栏： STL源码剖析 文章标签： 算法 STL C++ set 容器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mei_true/article/details/121062255
版权

set算法
STL提供了四种set相关的算法<stl_algo.h>，分别是并集union，交集intersection，差集difference，对称差集symmetric difference，与数学上的意义不一样。
本节算法接受set/multiset容器作为输入区间，不接受hash_set/hash_multiset作为输入区间。
输入及输出区间都是排序区间且元素不唯一，返回迭代器指向输出区间的尾端。

set_union
set_union算法构造以S1为基础，S2与S1的并集，假设一个值在S1出现n次，在S2出现m次，那么该值在输出区间会出现max(m, n)次，其中n个来自于S1，其余来自于S2。
set_union是一种稳定操作，输入区间内元素的相对顺序不会改变，STL提供两个版本的算法，第一版本使用operator<进行元素比较，第二版本采用仿函数comp进行比较。

set_intersection
set_intersection构造以S1为基础，S2与S1的交集，假设一个值在S1出现n次，在S2出现m次，那么该值在输出区间会出现min(m, n)次，并且全部来自于S1。

set_difference
set_difference构造以S1为基础的S1-S2差集，出现在S1但不出现于S2的元素，如果某值在S1出现n次，在S2出现m次，那么该值在输出区间出现max(n-m, 0)次，并且全部来自于S1，n必须大于m，否则不出现。

set_symmetric_difference
set_symmetric_difference构造S1、S2对称差集，即(S1-S2)U(S2-S1)，如果某个值在S1出现n次，在S2出现m次，该值在输出区间出现|n-m|次，如果n>m，输出区间内的n-m个元素来自S1，如果n<m，输出区间m-n个元素来自于S2。

heap算法
四个heap算法在前面heap中已介绍，make_heap(), pop_heap(), push_heap(), sort_heap()，此处不做介绍。

namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
  //使用operator<比较元素
  template<typename _InputIterator1, typename _InputIterator2,
	   typename _OutputIterator>
    _OutputIterator
    set_union(_InputIterator1 __first1, _InputIterator1 __last1,
	      _InputIterator2 __first2, _InputIterator2 __last2,
	      _OutputIterator __result)
    {
      typedef typename iterator_traits<_InputIterator1>::value_type
	_ValueType1;
      typedef typename iterator_traits<_InputIterator2>::value_type
	_ValueType2;
      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
      __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
				  _ValueType1>)
      __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
				  _ValueType2>)
      __glibcxx_function_requires(_LessThanOpConcept<_ValueType1, _ValueType2>)
      __glibcxx_function_requires(_LessThanOpConcept<_ValueType2, _ValueType1>)
      __glibcxx_requires_sorted_set(__first1, __last1, __first2);
      __glibcxx_requires_sorted_set(__first2, __last2, __first1);

      while (__first1 != __last1 && __first2 != __last2)
	{ //当两区间都未到达尾端时，执行以下操作
	  if (*__first1 < *__first2) //元素比较
	    { //将较小元素者记录于目标区间并移动迭代器，进行下次比较
	      *__result = *__first1; //记录较小元素
	      ++__first1; //移动较小元素迭代器，另一区间迭代器不动
	    }
	  else if (*__first2 < *__first1)
	    {
	      *__result = *__first2;
	      ++__first2;
	    }
	  else
	    { //两元素相等时，记录目标区间，移动两输入迭代器
	      *__result = *__first1;
	      ++__first1;
	      ++__first2;
	    }
	  ++__result; //输出区间迭代器移动
	} //输入区间有一区间到达尾端即结束循环
	  //两区间有一空白区间，将另一区间剩余元素拷贝到输出区间
      return std::copy(__first2, __last2, std::copy(__first1, __last1,
						    __result)); 
    }
  //使用仿函数__comp比较元素
  template<typename _InputIterator1, typename _InputIterator2,
	   typename _OutputIterator, typename _Compare>
    _OutputIterator
    set_union(_InputIterator1 __first1, _InputIterator1 __last1,
	      _InputIterator2 __first2, _InputIterator2 __last2,
	      _OutputIterator __result, _Compare __comp)
    {
      typedef typename iterator_traits<_InputIterator1>::value_type
	_ValueType1;
      typedef typename iterator_traits<_InputIterator2>::value_type
	_ValueType2;

      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
      __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
				  _ValueType1>)
      __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
				  _ValueType2>)
      __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
				  _ValueType1, _ValueType2>)
      __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
				  _ValueType2, _ValueType1>)
      __glibcxx_requires_sorted_set_pred(__first1, __last1, __first2, __comp);
      __glibcxx_requires_sorted_set_pred(__first2, __last2, __first1, __comp);

      while (__first1 != __last1 && __first2 != __last2)
	{
	  if (__comp(*__first1, *__first2))
	    {
	      *__result = *__first1;
	      ++__first1;
	    }
	  else if (__comp(*__first2, *__first1))
	    {
	      *__result = *__first2;
	      ++__first2;
	    }
	  else
	    {
	      *__result = *__first1;
	      ++__first1;
	      ++__first2;
	    }
	  ++__result;
	}
      return std::copy(__first2, __last2, std::copy(__first1, __last1,
						    __result));
    }

  template<typename _InputIterator1, typename _InputIterator2,
	   typename _OutputIterator>
    _OutputIterator
    set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
		     _InputIterator2 __first2, _InputIterator2 __last2,
		     _OutputIterator __result)
    {
      typedef typename iterator_traits<_InputIterator1>::value_type
	_ValueType1;
      typedef typename iterator_traits<_InputIterator2>::value_type
	_ValueType2;
      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
      __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
				  _ValueType1>)
      __glibcxx_function_requires(_LessThanOpConcept<_ValueType1, _ValueType2>)
      __glibcxx_function_requires(_LessThanOpConcept<_ValueType2, _ValueType1>)
      __glibcxx_requires_sorted_set(__first1, __last1, __first2);
      __glibcxx_requires_sorted_set(__first2, __last2, __first1);
      //当两区间都未到达尾端时，执行以下操作
      while (__first1 != __last1 && __first2 != __last2)
		if (*__first1 < *__first2)
		  ++__first1;
		else if (*__first2 < *__first1)
		  ++__first2;
		else //移动输入区间迭代器直到有相等元素
		  { //记录元素于目标区间，移动输入、输出区间迭代器
		    *__result = *__first1;
		    ++__first1;
		    ++__first2;
		    ++__result;
		  }
      return __result;
    }

  template<typename _InputIterator1, typename _InputIterator2,
	   typename _OutputIterator, typename _Compare>
    _OutputIterator
    set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
		     _InputIterator2 __first2, _InputIterator2 __last2,
		     _OutputIterator __result, _Compare __comp)
    {
      typedef typename iterator_traits<_InputIterator1>::value_type
	_ValueType1;
      typedef typename iterator_traits<_InputIterator2>::value_type
	_ValueType2;

      // concept requirements
      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
      __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
				  _ValueType1>)
      __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
				  _ValueType1, _ValueType2>)
      __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
				  _ValueType2, _ValueType1>)
      __glibcxx_requires_sorted_set_pred(__first1, __last1, __first2, __comp);
      __glibcxx_requires_sorted_set_pred(__first2, __last2, __first1, __comp);

      while (__first1 != __last1 && __first2 != __last2)
	if (__comp(*__first1, *__first2))
	  ++__first1;
	else if (__comp(*__first2, *__first1))
	  ++__first2;
	else
	  {
	    *__result = *__first1;
	    ++__first1;
	    ++__first2;
	    ++__result;
	  }
      return __result;
    }

  template<typename _InputIterator1, typename _InputIterator2,
	   typename _OutputIterator>
    _OutputIterator
    set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
		   _InputIterator2 __first2, _InputIterator2 __last2,
		   _OutputIterator __result)
    {
      typedef typename iterator_traits<_InputIterator1>::value_type
	_ValueType1;
      typedef typename iterator_traits<_InputIterator2>::value_type
	_ValueType2;
      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
      __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
				  _ValueType1>)
      __glibcxx_function_requires(_LessThanOpConcept<_ValueType1, _ValueType2>)
      __glibcxx_function_requires(_LessThanOpConcept<_ValueType2, _ValueType1>)	
      __glibcxx_requires_sorted_set(__first1, __last1, __first2);
      __glibcxx_requires_sorted_set(__first2, __last2, __first1);
      //当两区间都未到达尾端时，执行以下操作
      while (__first1 != __last1 && __first2 != __last2)
		if (*__first1 < *__first2)
		  { //第一区间元素小于第二区间元素，记录此值并移动迭代器
		    *__result = *__first1;
		    ++__first1; //输出区间移动
		    ++__result; //第一区间移动
		  }
		else if (*__first2 < *__first1) //第一区间元素大于第二区间元素
		  ++__first2; //第二区间移动迭代器
		else //两元素相等，S1、S2移动迭代器
		  {
		    ++__first1;
		    ++__first2;
		  }
      return std::copy(__first1, __last1, __result);
    }

  template<typename _InputIterator1, typename _InputIterator2,
	   typename _OutputIterator, typename _Compare>
    _OutputIterator
    set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
		   _InputIterator2 __first2, _InputIterator2 __last2,
		   _OutputIterator __result, _Compare __comp)
    {
      typedef typename iterator_traits<_InputIterator1>::value_type
	_ValueType1;
      typedef typename iterator_traits<_InputIterator2>::value_type
	_ValueType2;
      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
      __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
				  _ValueType1>)
      __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
				  _ValueType1, _ValueType2>)
      __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
				  _ValueType2, _ValueType1>)
      __glibcxx_requires_sorted_set_pred(__first1, __last1, __first2, __comp);
      __glibcxx_requires_sorted_set_pred(__first2, __last2, __first1, __comp);

      while (__first1 != __last1 && __first2 != __last2)
	if (__comp(*__first1, *__first2))
	  {
	    *__result = *__first1;
	    ++__first1;
	    ++__result;
	  }
	else if (__comp(*__first2, *__first1))
	  ++__first2;
	else
	  {
	    ++__first1;
	    ++__first2;
	  }
      return std::copy(__first1, __last1, __result);
    }

  template<typename _InputIterator1, typename _InputIterator2,
	   typename _OutputIterator>
    _OutputIterator
    set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
			     _InputIterator2 __first2, _InputIterator2 __last2,
			     _OutputIterator __result)
    {
      typedef typename iterator_traits<_InputIterator1>::value_type
	_ValueType1;
      typedef typename iterator_traits<_InputIterator2>::value_type
	_ValueType2;
      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
      __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
				  _ValueType1>)
      __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
				  _ValueType2>)
      __glibcxx_function_requires(_LessThanOpConcept<_ValueType1, _ValueType2>)
      __glibcxx_function_requires(_LessThanOpConcept<_ValueType2, _ValueType1>)	
      __glibcxx_requires_sorted_set(__first1, __last1, __first2);
      __glibcxx_requires_sorted_set(__first2, __last2, __first1);
      //当两区间都未到达尾端时，执行以下操作
      while (__first1 != __last1 && __first2 != __last2)
	if (*__first1 < *__first2) //两元素不相等时取出该元素，移动迭代器
	  {
	    *__result = *__first1;
	    ++__first1;
	    ++__result;
	  }
	else if (*__first2 < *__first1)
	  {
	    *__result = *__first2;
	    ++__first2;
	    ++__result;
	  }
	else //两元素相等时，输入区间移动迭代器
	  {
	    ++__first1;
	    ++__first2;
	  }
      return std::copy(__first2, __last2, std::copy(__first1,
						    __last1, __result));
    }

  template<typename _InputIterator1, typename _InputIterator2,
	   typename _OutputIterator, typename _Compare>
    _OutputIterator
    set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
			     _InputIterator2 __first2, _InputIterator2 __last2,
			     _OutputIterator __result,
			     _Compare __comp)
    {
      typedef typename iterator_traits<_InputIterator1>::value_type
	_ValueType1;
      typedef typename iterator_traits<_InputIterator2>::value_type
	_ValueType2;
      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
      __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
				  _ValueType1>)
      __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
				  _ValueType2>)
      __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
				  _ValueType1, _ValueType2>)
      __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
				  _ValueType2, _ValueType1>)
      __glibcxx_requires_sorted_set_pred(__first1, __last1, __first2, __comp);
      __glibcxx_requires_sorted_set_pred(__first2, __last2, __first1, __comp);

      while (__first1 != __last1 && __first2 != __last2)
	if (__comp(*__first1, *__first2))
	  {
	    *__result = *__first1;
	    ++__first1;
	    ++__result;
	  }
	else if (__comp(*__first2, *__first1))
	  {
	    *__result = *__first2;
	    ++__first2;
	    ++__result;
	  }
	else
	  {
	    ++__first1;
	    ++__first2;
	  }
      return std::copy(__first2, __last2, 
		       std::copy(__first1, __last1, __result));
    }

_GLIBCXX_END_NAMESPACE_ALGO
} // namespace std
花花...
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
STL源码剖析——heap
Smile&搁浅
06-15 2468
Heap堆是常用的数据结构，Heap中也可以存放元素。但是STL中并没有提供Heap容器，只是提供了关于Heap操作的算法。只要支持RandomAccessIterator的容器都可以作为Heap容器。 Heap分为max heap和min heap，max heap中每次取出的结点时heap结构中值最大的结点，min heap中每次取出的结点时heap结构中值最小的结点。 在实际应用中，经常
STL源码剖析
04-21
这本书所呈现的源码，使读者看到vector的实现、list的实现、heap的实现、deque的实现、Red Black tree的实现、hash table的实现、set/map的实现；看到各种算法（排序、查找、排列组合、数据移动与复制技术）的实现；...
STL源码 SET 解析
anualday的博客
04-06 594
这个是阿里春招实习二面的时候面试官问的一个问题。 SET是STL中的标准容器，SET里面的元素会根据键值自动排序，它不像map那样拥有实值value和键值key的对应，set只有实值。SET的底层实现时RB-tree，当插入到RB-tree中后，其值不能再更改，因为更改就意味着可能不符合RB-tree的特性了，所以其迭代器set::iterator是RB-tree的constrant ite
STL源码剖析 set相关算法
CHYabc123456hh的博客
07-21 258
STL 一共提供了四种与set (集合)相关的算法，分别是并集(union)、交集(intersection) > 差集 (difference)、对称差集 (symmetricdifference 所谓set,可细分为数学上的定义和STL的定义两种，数学上的set允许元素重复而未经排序，例 如 ｛ 1,1,4,6,3｝ , ST L 的定义(也就是set 容器，见 5.3节) 则要求元素不得重复，并且经过排序，例如 ｛1,3,4,6｝ 。本节的四个算法所接受的set,必须是有序区间(sorted.
STL源码剖析——STL算法之set集合算法
关注校招求职，微信号：job_campus
09-29 2388
本节介绍set集合的相关算法，分别是并集set_union，差集set_difference，交集set_intersection和对称差集set_symmetric_difference，这是个函数都提供了两个版本的函数原型：第一个版本是采用默认的排序比较方式 operator<；第二个版本是用户通过仿函数comp自行指定排序方式。注意：这四个算法接受的输入区间都是有序的，输出也是有序的。
STL源码剖析 数值算法 heap算法
CHYabc123456hh的博客
11-30 779
算法 adjacent_find count count_if find find_if find_end for_each generate generate_n includes max_element merge min_element partition remove remove remove_copy remove_if remove_copy_if replace replace_copy replace_if replace_copy_if r
《STL源码剖析》要点总结
Cu_OH_2的博客
03-22 490
《STL源码剖析》读书笔记/要点总结
STL源码剖析（十七）算法
mei_true的博客
04-16 123
算法概观 以有限的步骤，解决逻辑或数学上的问题，称为算法。 以下所探讨的是记录于STL中，极具复用价值的STL算法。 算法分析和复杂度表示O() 一般而言，算法的执行时间和所要处理的数据量有关，两者之间存在某种函数关系，一次、二次、三次或对数关系，分别表示为O(N), O(N2), O(N3) , O(logN)，数据量小时，多项式函数每项内容都可能对结果产生影响，数据大时，只有最高次方的项目才具主导地位。 STL算法总览 算法名称 算法用途
STL 源码剖析：6、算法
qq_30534935的博客
11-03 182
6.1 算法概观 以有限的步骤，解决逻辑或数学上的问题。 6.1.1 算法分析与复杂度表示 6.1.2 STL 算法总览 6.1.3 质变算法 会改变操作对象的值。 6.1.4 非质变算法 不改变操作对象的值。 6.1.5 STL 算法的一般形式 所有的泛型算法的前两个参数都是一堆迭代器，通常称为 first 和 last。 6.2 算法的泛化过程 关键在于，只要把操作对象的型别加以抽象...
C++ STL源码剖析 笔记
weixin_43992162的博客
02-03 1934
记录一下《C++ STL源码剖析》中的要点。
STL源码剖析 电子版
04-22
侯捷 版本 STL源码剖析 C++ 学习不二经典 学习编程的人都知道，阅读、剖析名家代码乃是提高水平的捷径。源码之前，了无秘密。大师们的缜密思维、经验结晶、技术思路、独到风格，都原原本本体现在源码之中。 这本书...
STL源码剖析简体中文完整版(清晰扫描带目录).pdf
07-11
这本书所呈现的源码，使读者看到vector的实现、list的实现、heap的实现、deque的实现、Red Black tree的实现、hash table的实现、set/map的实现；看到各种算法（排序、查找、排列组合、数据移动与复制技术）的实现...
STL源码剖析（二）__alloc_traits特性
mei_true的博客
03-18 1430
__alloc_traits特性 类__allocator_traits_base，用于获取内存分配器Alloc的属性，内存分配器不一定是std::allocator，可以是自定义的。 namespace std _GLIBCXX_VISIBILITY(default) { struct __allocator_traits_base { //分配器_Tp没有rebind成员函数时，调用普通版本__rebind template<typename _Tp, typename _
STL源码剖析（一）allocator内存分配类
mei_true的博客
02-22 451
空间配置器allocator 1，空间配置器隐藏在容器背后工作，STL的操作对象存放在容器内，而容器需要配置一定的空间。 2，空间不一定是内存，可以是磁盘或其他辅助存储介质，但一般情况下allocator配置对象为内存。 allocator模板类定义如下： namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION /// allocator<void> specialization. //
STL源码剖析（十三）关联式容器之RB-tree（红黑树）设计
mei_true的博客
06-08 370
namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION #if __cplusplus > 201103L # define __cpp_lib_generic_associative_lookup 201304 #endif // Red-black tree class, designed for use in implementing STL // associative contai
STL源码剖析（二十）基本算法之copy
mei_true的博客
10-31 351
namespace std _GLIBCXX_VISIBILITY(default) { template<bool, bool, typename> //模板类__copy_move<bool, bool, typename> struct __copy_move { template<typename _II, typename _OI> static _OI //静态成员函数 __copy_m(_II __first, _II
STL源码剖析（五）序列式容器之vector
mei_true的博客
03-08 322
namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION _GLIBCXX_BEGIN_NAMESPACE_CONTAINER /// See bits/stl_deque.h's _Deque_base for an explanation. template<typename _Tp, typename _Alloc> struct _Vector_base {
侯捷stl 源码剖析源码
最新发布
08-29
侯捷的《STL源码剖析》是一本深入解析STL源码的书籍。其中包含了对STL的各个组成部分，例如泛型编程、面向对象、C 标准库以及STL的重要资源等的详细解释和剖析。在STL中，大约有80%左右的内容由STL组成，包括了平衡...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值