STL源码剖析（十）序列式容器之heap、priority_queue

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

heap概述
heap并不归属STL容器组件，可称为priority queue的助手，priority queue允许用户以任何次序将元素推入容器内，但取出时一定是从优先级最高的元素开始取。
binary max heap正具有这样的特性，适合作为priority queue的底层机制。
如果将list作为priority queue的底层机制，元素插入操作可享常数时间。但要找到list中的极值，需要对list进行线性扫描。如果在元素插入前先排序，此时取得极值和删除元素操作可达到最高效率，但元素的插入只有线性表现。
以binary search tree作为priority queue的底层机制，元素的插入和极值的取得就有O(logN)的表现，但binary search tree的输入随机，且binary search tree不易实现。
priority queue的复杂度最好介于queue和binary search tree之间，此时binary heap最佳选择。
binary heap其实是一种完全二叉树，整棵树除了最底层叶节点之外是填满的，最底层的叶节点左右不得有空隙。
完全二叉树可利用array储存所有节点，将#0位置保留，当树中某个节点位于array的i处时，其左子节点必位于array的2i处，右子节点位于array的2i+1处，父节点位于i/2处。
通过简单的位置规则，array实现完全二叉树，array表述树称为隐式表述法，如此来一个array和一组heap算法（用来插入、删除元素、取极值、将一整组数据排列成一个heap）便可实现完全二叉树，但array无法动态改变大小，可替换成vector。
根据元素排列方式，heap可分为max-heap和min-heap两种，前者每个节点键值大于或等于其子节点键值，后者每个节点键值小于或等于其子节点键值。
max-heap的最大值在根节点，并位于低层array或vector的起头处，min-heap的最小值在根结点，总是位于底层array或vector的起头处。
STL提供的是max-heap。

push_heap算法
为了满足完全二叉树的条件，新加入的元素一定放在最下一层作为叶节点，填补由左至右的第一个空格，也就是把新元素插入到底层vector的end()处。
新元素为满足max-heap的条件，将新节点与父节点比较，如果键值比父节点大则父子对换位置，如此上溯直到不需对换或根节点为止。

pop_heap算法
max-heap最大值必然在根节点，pop操作取走根节点（其实是移至vector的最后一个元素处）之后，为了满足max-heap的条件，必须将最下一层最右边的叶节点拿掉，并为这个拿掉的节点寻找合适位置。根节点子节点较大节点填补根节点，拿掉的最右叶节点填补根节点子节点位置，填补位置之后与子节点比较一直到合适位置为止。
pop_heap之后，最大元素只是被放置于底部容器的尾端，如果要取其值，可使用底部容器vector提供的back()操作函数，如果要移除它，可使用底部容器vector提供的pop_back()操作函数。

sort_heap算法
每次pop_heap可获得heap中键值最大的元素，如果持续对整个heap做pop_heap操作，每次将操作范围从后向前缩减一个元素，当整个程序执行完毕时，便获得一个递增序列。

make_heap算法
这个算法用来将一段现有的数据转化为一个heap，依据为前面提到的完全二叉树的隐式表述。

注：heap的所有元素都必须遵循完全二叉树排列规则，所有heap不提供遍历功能，也不提供迭代器。

priority_queue概述
priority_queue所有元素进出都有一定规则，只有queue顶端的元素（权值最高者）才有机会被外界取用，priority_queue不提供遍历功能，也不提供迭代器。

namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION

  template<typename _RandomAccessIterator, typename _Distance, typename _Tp>
    void
    __push_heap(_RandomAccessIterator __first,
		_Distance __holeIndex, _Distance __topIndex, _Tp __value)
    {
      _Distance __parent = (__holeIndex - 1) / 2;
      while (__holeIndex > __topIndex && *(__first + __parent) < __value)
	{
	  *(__first + __holeIndex) = _GLIBCXX_MOVE(*(__first + __parent));
	  __holeIndex = __parent;
	  __parent = (__holeIndex - 1) / 2;
	}
      *(__first + __holeIndex) = _GLIBCXX_MOVE(__value);
    }

  template<typename _RandomAccessIterator>
    inline void
    push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
	  _ValueType;
      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
	  _DistanceType;
      __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
	    _RandomAccessIterator>)
      __glibcxx_function_requires(_LessThanComparableConcept<_ValueType>)
      __glibcxx_requires_valid_range(__first, __last);
      __glibcxx_requires_heap(__first, __last - 1);

      _ValueType __value = _GLIBCXX_MOVE(*(__last - 1));
      std::__push_heap(__first, _DistanceType((__last - __first) - 1),
		       _DistanceType(0), _GLIBCXX_MOVE(__value));
    }

  template<typename _RandomAccessIterator, typename _Distance, typename _Tp,
	   typename _Compare>
    void
    __push_heap(_RandomAccessIterator __first, _Distance __holeIndex,
		_Distance __topIndex, _Tp __value, _Compare __comp)
    {
      _Distance __parent = (__holeIndex - 1) / 2;
      while (__holeIndex > __topIndex
	     && __comp(*(__first + __parent), __value))
	{
	  *(__first + __holeIndex) = _GLIBCXX_MOVE(*(__first + __parent));
	  __holeIndex = __parent;
	  __parent = (__holeIndex - 1) / 2;
	}
      *(__first + __holeIndex) = _GLIBCXX_MOVE(__value);
    }

  template<typename _RandomAccessIterator, typename _Compare>
    inline void
    push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
	      _Compare __comp)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
	  _ValueType;
      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
	  _DistanceType;
      __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
	    _RandomAccessIterator>)
      __glibcxx_requires_valid_range(__first, __last);
      __glibcxx_requires_heap_pred(__first, __last - 1, __comp);

      _ValueType __value = _GLIBCXX_MOVE(*(__last - 1));
      std::__push_heap(__first, _DistanceType((__last - __first) - 1),
		       _DistanceType(0), _GLIBCXX_MOVE(__value), __comp);
    }

  template<typename _RandomAccessIterator, typename _Distance, typename _Tp>
    void
    __adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex,
		  _Distance __len, _Tp __value)
    {
      const _Distance __topIndex = __holeIndex;
      _Distance __secondChild = __holeIndex;
      while (__secondChild < (__len - 1) / 2)
	{
	  __secondChild = 2 * (__secondChild + 1);
	  if (*(__first + __secondChild) < *(__first + (__secondChild - 1)))
	    __secondChild--;
	  *(__first + __holeIndex) = _GLIBCXX_MOVE(*(__first + __secondChild));
	  __holeIndex = __secondChild;
	}
      if ((__len & 1) == 0 && __secondChild == (__len - 2) / 2)
	{
	  __secondChild = 2 * (__secondChild + 1);
	  *(__first + __holeIndex) = _GLIBCXX_MOVE(*(__first
						     + (__secondChild - 1)));
	  __holeIndex = __secondChild - 1;
	}
      std::__push_heap(__first, __holeIndex, __topIndex,
		       _GLIBCXX_MOVE(__value));
    }

  template<typename _RandomAccessIterator>
    inline void
    __pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
	       _RandomAccessIterator __result)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
	_ValueType;
      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
	_DistanceType;

      _ValueType __value = _GLIBCXX_MOVE(*__result);
      *__result = _GLIBCXX_MOVE(*__first);
      std::__adjust_heap(__first, _DistanceType(0),
			 _DistanceType(__last - __first),
			 _GLIBCXX_MOVE(__value));
    }

  template<typename _RandomAccessIterator>
    inline void
    pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
	_ValueType;
      __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
	    _RandomAccessIterator>)
      __glibcxx_function_requires(_LessThanComparableConcept<_ValueType>)
      __glibcxx_requires_non_empty_range(__first, __last);
      __glibcxx_requires_valid_range(__first, __last);
      __glibcxx_requires_heap(__first, __last);

      if (__last - __first > 1)
	{
	  --__last;
	  std::__pop_heap(__first, __last, __last);
	}
    }

  template<typename _RandomAccessIterator, typename _Distance,
	   typename _Tp, typename _Compare>
    void
    __adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex,
		  _Distance __len, _Tp __value, _Compare __comp)
    {
      const _Distance __topIndex = __holeIndex;
      _Distance __secondChild = __holeIndex;
      while (__secondChild < (__len - 1) / 2)
	{
	  __secondChild = 2 * (__secondChild + 1);
	  if (__comp(*(__first + __secondChild),
		     *(__first + (__secondChild - 1))))
	    __secondChild--;
	  *(__first + __holeIndex) = _GLIBCXX_MOVE(*(__first + __secondChild));
	  __holeIndex = __secondChild;
	}
      if ((__len & 1) == 0 && __secondChild == (__len - 2) / 2)
	{
	  __secondChild = 2 * (__secondChild + 1);
	  *(__first + __holeIndex) = _GLIBCXX_MOVE(*(__first
						     + (__secondChild - 1)));
	  __holeIndex = __secondChild - 1;
	}
      std::__push_heap(__first, __holeIndex, __topIndex, 
		       _GLIBCXX_MOVE(__value), __comp);      
    }

  template<typename _RandomAccessIterator, typename _Compare>
    inline void
    __pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
	       _RandomAccessIterator __result, _Compare __comp)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
	_ValueType;
      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
	_DistanceType;

      _ValueType __value = _GLIBCXX_MOVE(*__result);
      *__result = _GLIBCXX_MOVE(*__first);
      std::__adjust_heap(__first, _DistanceType(0),
			 _DistanceType(__last - __first),
			 _GLIBCXX_MOVE(__value), __comp);
    }

  template<typename _RandomAccessIterator, typename _Compare>
    inline void
    pop_heap(_RandomAccessIterator __first,
	     _RandomAccessIterator __last, _Compare __comp)
    {
      // concept requirements
      __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
	    _RandomAccessIterator>)
      __glibcxx_requires_valid_range(__first, __last);
      __glibcxx_requires_non_empty_range(__first, __last);
      __glibcxx_requires_heap_pred(__first, __last, __comp);

      if (__last - __first > 1)
	{
	  --__last;
	  std::__pop_heap(__first, __last, __last, __comp);
	}
    }

  template<typename _RandomAccessIterator>
    void
    make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
	  _ValueType;
      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
	  _DistanceType;
      __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
	    _RandomAccessIterator>)
      __glibcxx_function_requires(_LessThanComparableConcept<_ValueType>)
      __glibcxx_requires_valid_range(__first, __last);

      if (__last - __first < 2)
	return;

      const _DistanceType __len = __last - __first;
      _DistanceType __parent = (__len - 2) / 2;
      while (true)
	{
	  _ValueType __value = _GLIBCXX_MOVE(*(__first + __parent));
	  std::__adjust_heap(__first, __parent, __len, _GLIBCXX_MOVE(__value));
	  if (__parent == 0)
	    return;
	  __parent--;
	}
    }

  template<typename _RandomAccessIterator, typename _Compare>
    void
    make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
	      _Compare __comp)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
	  _ValueType;
      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
	  _DistanceType;
      __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
	    _RandomAccessIterator>)
      __glibcxx_requires_valid_range(__first, __last);

      if (__last - __first < 2)
	return;

      const _DistanceType __len = __last - __first;
      _DistanceType __parent = (__len - 2) / 2;
      while (true)
	{
	  _ValueType __value = _GLIBCXX_MOVE(*(__first + __parent));
	  std::__adjust_heap(__first, __parent, __len, _GLIBCXX_MOVE(__value),
			     __comp);
	  if (__parent == 0)
	    return;
	  __parent--;
	}
    }

  template<typename _RandomAccessIterator>
    void
    sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
    {
      __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
	    _RandomAccessIterator>)
      __glibcxx_function_requires(_LessThanComparableConcept<
	    typename iterator_traits<_RandomAccessIterator>::value_type>)
      __glibcxx_requires_valid_range(__first, __last);
      __glibcxx_requires_heap(__first, __last);

      while (__last - __first > 1)
	{
	  --__last;
	  std::__pop_heap(__first, __last, __last);
	}
    }

  template<typename _RandomAccessIterator, typename _Compare>
    void
    sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
	      _Compare __comp)
    {
      __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
	    _RandomAccessIterator>)
      __glibcxx_requires_valid_range(__first, __last);
      __glibcxx_requires_heap_pred(__first, __last, __comp);

      while (__last - __first > 1)
	{
	  --__last;
	  std::__pop_heap(__first, __last, __last, __comp);
	}
    }

_GLIBCXX_END_NAMESPACE_VERSION
} // namespace
花花...
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ STL容器之heap（堆）篇
Flowing_River的博客
08-12 2656
没有想到第一次用堆 是在LeetCode的算法题上，作为一个学生党来说，需要用到堆跟堆算法的场景确实比较少。 这篇文章不仅是跟大家分享有关于堆的知识，也是为了通过这种方式巩固我自己对堆的理解。并且我将通过最开始说的拿到LeetCode题来跟大家一起实践堆的使用 。 本期文章代码将用C++来进行说明。
heap和priority_queue总结
sinat_41619762的博客
03-14 258
1.priority_queue是适配器，它默认使用的底层数据结构是vector。而为了让这个vector表现得像一个堆，它必须借助heap算法。 2.实现堆使用的是完全二叉树，这个完全二叉树每个节点的键值都大于（或者小于）孩子节点的键值。 3.用一个数据结构来存储这个完全二叉树，这个数据结构就是1中提到的底层数据结构，默认是vector。这个vector中的元素按照这个完全二叉树的层序遍历的顺序进行存储。这样，对于第iii个元素，它的父节点是(i−1)/2(i-1)/2(i−1)/2，它的左孩子节点是i×
Go标准容器之Heap
Cynhard的专栏
06-01 2922
简介本篇主要介绍如何使用container/heap包实现最小堆。关于堆的概念请参阅相关资料。heap包container/heap包仅仅提供了最小堆的操作，没有提供堆的数据结构，堆的数据结构必须我们自己实现。heap包提供了一个heap.Interface接口来作为堆的操作（heap包提供）和堆的数据结构（我们自己实现）之间的桥梁，堆的数据结构必须满足此接口：container/heap−−−−−
【STL】顺序容器 — heap
Nestle的专栏
04-30 1178
heap不属于STL容器，它扮演者priority queue的助手。heap是一种完全二叉树，可由数组来实现，但heap需要动态改变大小，所以最终选择了vector作为底层容器。STL默认提供最大堆。 题外话：分析heap的源码就能清楚的理解堆这种数据结构的例程，而STL库代码的质量又很高，所以看堆的代码，STL源码是一个很好的选择。 为了满足完全二叉树的性质，新插入的元素一
【C++】STL之heap（堆）
qq_36367326的博客
03-27 2228
转自：https://www.cnblogs.com/MrLiuZF/p/13498631.html 1、误区！ 1、堆排序排完后的堆和大顶堆、小顶堆不是一个概念！ 2、堆分为大顶堆和小顶堆，即要么大顶堆（大根堆/最大堆），要么小顶堆。 3、对于堆，堆的根节点一定是堆中所有节点的最大值或者最小值。 4、大顶堆只是说这个堆总每一个节点满足：每一个节点大于或者等于其左右娃。并非这个堆一定是从大到小的序列。 5、所以才必须要有堆排序呀！堆排序排完了之后的，才一定是一个有序的序列。 6、堆实际上是用数组或者vect
STL序列式容器之heap（注heap并不归属于stl组件）
handsomeKyne
07-12 583
在学习优先队列之前，我们有必要学习一下堆，heap。 注:heap并不归属于STL组件，它是幕后英雄，扮演则有限队列priority_queue的助手。我们知道优先队列可以将元素以任意次序压入队列中，但是弹出队列元素时，总是弹出优先级最高的元素。最大堆就满足这样的性质。
STL 中的 heap 与 priority_queue
看艾薇的熊猫的博客
06-02 415
介绍下 STL 中的 heap 与 priority_queue
C++STL 优先队列priority_queue使用
weixin_34179762的博客
08-07 217
头文件：#include <queue> 一.申明方式 std::priority_queue<T> q; std::priority_queue<T, std::vector<T>, cmp> q;1.普通方法： priority_queue<int> q; //大的优先级高 priority_queue<int,...
chapter4 序列式容器：heap
weixin_42323999的博客
05-25 133
目录1 heap1.1 概述1.1.1 priority queue底层机制的选择分析1.1.2 binary heap1.1.3 heap的分类1.2 heap算法1.2.1 push_heap1.2.2 pop_heap1.2.3 sort_heap1.2.4 make_heap2 priority_queue2.1 概述2.2 定义完整列表2.3 priority_queue没有迭代器2.4 示例 1 heap 1.1 概述 heap并不是归属于STL容器组件，它是个幕后英雄，扮演priority
STL sort源码分析
qq_41529799的博客
05-11 490
先大概介绍一下sort的实现吧。sort的底层实际上算是两种甚至三种排序的混合。当对大量数据采用快速排序，当数据基本有序时改用插入排序，并且在发现时间复杂度有向O(n*n)发展时，改用堆排序。 以下代码均来自于devc++ 5.11版本。 我们从sort函数看起 //stl_algo.h, line 4703 template<typename _RandomAccessIterator, typename _Compare> inline void sort(_Ra
STL priority_queue（优先队列）详解
09-01
主要介绍了 STL priority_queue（优先队列）详解的相关资料,需要的朋友可以参考下
STLyuanmapouxi.rar_STLyuanmapouxi_jjalloc_stl map_stl源码剖析
09-14
代码中包含了部分作者侯捷的<<STL源码剖析>>一书中的程序实例,有助于理解及应用STL,来进行方便高效的编程
STL源码剖析.pdf(侯捷，完整版，已加全书签)
06-17
第4 章 序列式容器（sequence containers） 第5 章 關聯式容器（associated containers） 第6 章 演算法（algorithms） 第7 章 仿函式or 函式物件（functors, or function objects） 第8 章 配接器（adapter）
STL源码剖析_C++STL_stl源码c++_
09-29
标准模板库的源码剖析，一本很不错的c++模板库的分析书
STL源码剖析.pdf
04-24
STL源码剖析.pdf
PriorityQueue的BinaryHeap实现
gaobohello1987的专栏
01-22 1379
PriorityQueue（优先队列）有很多应用场景，例如去听一场音乐会，假如票已经都卖完了，但是还有许多没票的人在排队等是否有人退票，如果有人退票，那么系统就需要把这张票分类给优先级最高的那个排队者（这里的优先级可以是排队的时间，或者交的钱多少等，这里的优先级条件对应priorityqueue中的key）。 PriorityQueue的实现方法有多种，包括SortedList，UnSorted
【heap】是算法不是容器哦
weixin_43232279的博客
03-26 788
前面是一些小Tips和关键点，以及代码里不好理解的点，后面是源码，重要的函数全部都写了满满的注释嘿嘿嘿！为什么是这种形式呢，因为看书的时候就是讲解源码的，于是顺着读代码的时候就加了注释。
STL容器（五）——heap
bigfacesafdasgfewgf
01-27 1105
STL容器（五）——heap          我们可以调用STL中的heap堆，实现建堆和堆排序等操作。     首先，STL中的heap默认构建的是最大堆，程序如下： #include #include #include using namespace std; int main() { int a[]={2, 3, 5, 1, 9, 6}; vector vec(a
聊聊C++11标准库中堆(heap)算法的源码
FlushHip
12-29 1966
STL中支持堆操作，对外暴露了`std::make_heap`，`std::push_heap`，`std::pop_heap`，`std::sort_heap`，`std::is_heap`，`std::is_heap_until`这6个函数，详细的使用方法可以参见[图解STL中算法的分类、简介及其Demo](https://blog.csdn.net/FlushHip/article/details/82858933#t37)。
STL之priority_queue优先队列stl priority_queu
最新发布
10-07
在STL中，priority_queue是基于堆的数据结构，底层使用了make_heap()、push_heap()和pop_heap()等算法来实现。make_heap()算法可以将一个无序的序列转化为一个堆，push_heap()算法可以将一个新的元素插入到堆中，并...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值