一、heap概述
- heap并不归属于 STL 容器组件
- binary heap作为priority queue的底层实现机制。顾名思义,priority queue允许使用者以任何次序将任何元素推入容器内,但取出时一定是从优先权最高(也就是数值最高)之元素开始取。binary max heap正是具有这样的特性,适合做为priorityqueue的底层机制
heap作为priority queue的底层实现
- 假设list作为priority queue的底层机制:
- 元素插入动作可享常数时间
- 但是要找到list中的极值,却需要对整个list进行线性扫描。我们也可以改个做法,让元素插入前先经过排序这一关,使得list的元素值总是由小到大(或由大到小),但这么一来:虽然取得极值以及元素删除动作达到最高效率,可元素的插入却只有线性表现
- 如果以binary serach tree(二叉搜索树,如RB-tree)作为priority queue的底层机制:
- 这么一来元素的插入和极值的取得就有O(logN)的表现
- 但是这么一来binary search tree的输入需要足够的随机性,二来 binary search tree并不容易实现
- 如果以binary heap作为priority queue的底层机制:
- 为了减少复杂度,我们选择介于queue和binary search tree之间的binary heap作为priority queue的底层实现
heap的分类
- 根据元素排列方式,heap可分为max-heap和 min-heap两种:
- max-heap:每个节点的 键值(key)都大于或等于其子节点键值
- min-heap:的每个节点键值(key)都小于或等于其子节点键值。
- 因此:
- max-heap的最大值在根节点,并总是位于底层array或vector的起头处
- min-heap的最小值在根节点,亦总是位于底层 array或vector 的起头处
- STL 供应的是 max-heap,因此以下我说 heap 时,指的是 max-heap
heap没有迭代器
- heap的所有元素都必须遵循特别的(complete binary tree)排列规则,所以 heap 不提供遍历功能,也不提供迭代器
二、binary heap概述
![](https://i-blog.csdnimg.cn/blog_migrate/2591dc11c1cf5c7ab7c254844bdc82c1.png)
三、heap的实现
- complete binary tree整棵树内没有任何节点为空,这带来一个极大好处:我们可以利用array来储存所有节点
- 假设array的0索引处元素保留(或设为无限大值或无限小值),那么当完全二叉树中的某个节点位于array的i索引处时,有如下规则:
- 其左子节点必位于array的2i索引处
- 其右子节点必位于array 的2i+1索引处
- 其父节点必位于i/2索引处
- 通过这么简单的位置规则,array可以轻易实作出完全二叉树。 这种以array表述tree的方式 , 我们称为隐式表述法( implicit representation)
- 这么一来,我们需要的工具就很简单了:一个array和一组heap算法(用来插入元素、删除元素、取极值、将某一整组数据排列成一个 heap)。array的缺点是无法动态改变大小,而heap却需要这项功能,因此以vector代替array是更好的选择
四、heap的分类
- 根据元素排列方式,heap可分为max-heap和 min-heap两种:
- max-heap:每个节点的键值(key)都大于或等于其子节点键值
- min-heap:的每个节点键值(key)都小于或等于其子节点键值
- 因此:
- max-heap的最大值在根节点,并总是位于底层array或vector的起头处
- min-heap的最小值在根节点,亦总是位于底层 array或vector 的起头处
- STL供应的max-heap,因此本文下面介绍的heap,指的是max-heap
五、push_heap算法
算法图解
- push_heap算法思路如下:
- 1.把新元素插入在底层vector的end()处
- 2.如果其有父节点,将其与父节点比较,如果值比父节点小,就保持位置不变,结束算法;如果值比父节点大,进行下一步
- 3.如果值比父节点大,将其与父节点进行位置交换;交换之后如果还有父节点,那么再次回到步骤2
- 下面是一个演示:
- 1.将插入的新元素50放在vector的末尾
- 2.因为其父节点24比自己小,所以将父节点与自己交换位置
- 3.交换之后,其父节点变为31,其值比31大,所以继续交换位置
- 4.接着其父节点变为68,其值比68小,所以结束push_heap算法
![](https://i-blog.csdnimg.cn/blog_migrate/9731867e975e4e88f76c04e7138fc7dd.png)
- 上面这种比较方式我们称之为:percolate up(上溯)程序
push_heap源码
- 下面便是 push_heap 算法的实现细节。此函数接受两个迭代器,用来表现一个heap底部容器(vector)的头尾,新元素并且已经插入到底部容器的最尾端。 如果不符合这两个条件,push_heap的执行结果未可预期
template <class RandomAccessIterator>
inline void push_heap(RandomAccessIterator first,RandomAccessIterator last)
{
// 注意,此函式被调用时,新元素已置于底部容器的最尾端
__push_heap_aux(first, last, distance_type(first),value_type(first));
}
template <class RandomAccessIterator, class Distance, class T>
inline void push_heap_aux(RandomAccessIterator first,RandomAccessIterator last, Distance*, T*)
{
__push_heap(first, Distance((last - first) - 1), Distance(0),T(*(last - 1)));
// 以上系根据implicit representation heap的结构特性:新值必置于底部
// 容器的最尾端,此即第一个洞号:(last-first)–1
}
// 以下这组 push_back()不允许指定“大小比较标准”
template <class RandomAccessIterator, class Distance, class T>
void __push_heap(RandomAccessIterator first, Distance holeIndex,Distance topIndex, T value)
{
Distance parent = (holeIndex - 1) / 2; // 找出父节点
while (holeIndex > topIndex && *(first + parent) < value) {
// 当尚未到达顶端,且父节点小于新值(于是不符合 heap 的次序特性)
// 由于以㆖使用 operator<,可知 STL heap 是一种 max-heap(大者为父)
*(first + holeIndex) = *(first + parent); //令洞值为父值
holeIndex = parent; // percolate up:调整洞号,向上提升至父节点
parent = (holeIndex - 1) / 2; // 新洞的父节点
} // 持续至顶端,或满足heap的次序特性为止
*(first + holeIndex) = value; //令洞值为新值,完成插入动作
}
六、pop_heap算法
算法图解
- 因为是max-heap,最大值必然在根节点,pop操作时取走根节点(取走vector的最后一个元素),取走根节点之后,为了满足完全二叉树的规则,我们需要重新调整二叉树的结构
- pop_heap算法思路如下:
- 1.把根节点元素取出,把最后一个节点的元素取出
- 2.将原根节点元素放在vector的最后一个节点处
- 3.将原先的最后一个节点的元素放置到原根节点处作为新根节点
- 4.将新根节点逐个与子节点比较,直到其值比子节点都大时,结束算法
- 下面是一个演示:
- 1.取出根节点元素68,取出最后一个节点的元素24
- 2.将原根节点元素68放在vector的最后一个位置
- 3.将原先最后一个节点的元素24放置到原根节点68处作为新根节点
- 4.接着其值24比左、右节点50、65都小,但是65比50大,于是就将其值24与值68的子节点互换
- 5.接着其值24又比左、右节点32、26都小,但是32比26大,于是就将其值24与值32的子节点互换
- 6.最后其没有子节点可以比较了,结束算法
![](https://i-blog.csdnimg.cn/blog_migrate/07158bd08f59fc494cd439812cc0926a.png)
- 上面这种比较方式我们称之为:percolate down(下溯)程序
- 注意,pop_heap 之后,最大元素只是被置放于底部容器的最尾端,尚未被取走。 如果要取其值,可使用底部容器(vector)所提供的 back() 操作函数。如果要移除它,可使用底部容器(vector)所提供的 pop_back() 操作函数
pop_heap源码
- 下面便是 pop_heap算法的实现细节。此函数接受两个迭代器,用来表现以个 heap 底部容器(vector)的头尾。如果不符合这个条件,pop_heap 的执行结果 未可预期。
template <class RandomAccessIterator>
inline void pop_heap(RandomAccessIterator first,RandomAccessIterator last)
{
__pop_heap_aux(first, last, value_type(first));
}
template <class RandomAccessIterator, class T>
inline void __pop_heap_aux(RandomAccessIterator first,RandomAccessIterator last, T*)
{
__pop_heap(first, last-1, last-1, T(*(last-1)),
distance_type(first));
// 以上,根据 implicit representation heap 的次序特性,pop操作的结果
// 应为底部容器的第一个元素。因此,首先设定欲调整值为尾值,然后将首值调至
// 尾节点(所以以上将迭代器 result设为 last-1)。然后重整 [first, last-1),
// 使之重新成一个合格的 heap
}
// 以下这组 pop_heap() 不允许指定“大小比较标准”
template <class RandomAccessIterator, class T, class Distance>
inline void __pop_heap(RandomAccessIterator first,
RandomAccessIterator last,
RandomAccessIterator result,
T value, Distance*)
{
*result = *first; // 设定尾值为首值,于是尾值即为欲求结果,
// 可由客端稍后再以底层容器之 pop_back() 取出尾值
__adjust_heap(first, Distance(0), Distance(last - first), value);
// 以上欲重新调整 heap,洞号为 0(亦即树根处),欲调整值为 value(原尾值)
}
// 以下这个 __adjust_heap() 不允许指定“大小比较标准”
template <class RandomAccessIterator, class Distance, class T>
void __adjust_heap(RandomAccessIterator first, Distance holeIndex,Distance len, T value)
{
Distance topIndex = holeIndex;
Distance secondChild = 2 * holeIndex + 2; // 洞节点之右子节点
while (secondChild < len) {
// 比较洞节点之左右两个子值,然后以 secondChild 代表较大子节点
if (*(first + secondChild) < *(first + (secondChild - 1)))
secondChild--;
// Percolate down:令较大子值为洞值,再令洞号下移至较大子节点处
*(first + holeIndex) = *(first + secondChild);
holeIndex = secondChild;
// 找出新洞节点的右子节点
secondChild = 2 * (secondChild + 1);
}
if (secondChild == len) { // 没有右子节点,只有左子节点
// Percolate down:令左子值为洞值,再令洞号下移至左子节点处
*(first + holeIndex) = *(first + (secondChild - 1));
holeIndex = secondChild - 1;
}
// 将欲调整值填入目前的洞号内。注意,此时肯定满足次序特性
push_heap(first, holeIndex, topIndex, value);
}
七、sort_heap算法
算法图解
- 既然每次pop_heap可获得heap之中键值最大的元素,如果持续对整个heap做pop_heap动作,每次将操作范围从后向前缩减一个元素(因为pop_heap会把键值最大的元素放在底部容器的最尾端),当整个程序执行完毕,我们便有了一个递增序列
- 下图展示sort_heap算法的实际演示操作
![](https://i-blog.csdnimg.cn/blog_migrate/57cc798909b187078d2cbaff4b63580b.png)
sort_heap源码
- 下面是sort_heap算法的实作细节。此函数接受两个迭代器,用来表现一个 heap 底部容器(vector)的头尾。如果不符合这个条件,sort_heap 的执行结 果未可预期。注意,排序过后,原来的heap就不再是个合法的 heap 了
// 以下这个sort_heap() 不允许指定“大小比较标准”
template <class RandomAccessIterator>
void sort_heap(RandomAccessIterator first,RandomAccessIterator last)
{
// 以下,每执行一次 pop_heap(),极值(在STL heap中为极大值)即被放在尾端
// 扣除尾端再执行一次 pop_heap(),次极值又被放在新尾端。一直下去,最后即得排序结果
while (last - first > 1)
pop_heap(first, last--); // 每执行 pop_heap() 一次,操作范围即退缩一格
}
八、make_heap算法
// 将 [first,last) 排列为一个heap
template <class RandomAccessIterator>
inline void make_heap(RandomAccessIterator first,RandomAccessIterator last)
{
__make_heap(first, last, value_type(first), distance_type(first));
}
// 以下这组 make_heap() 不允许指定“大小比较标准”
template <class RandomAccessIterator, class T, class Distance>
void __make_heap(RandomAccessIterator first,RandomAccessIterator last, T*,Distance*)
{
if (last - first < 2)
return; //如果长度为0或1,不必重新排列
Distance len = last - first;
// 找出第一个需要重排的子树头部,以parent标示出。由于任何叶节点都不需执行
// perlocate down,所以有以下计算。parent命名不佳,名为holeIndex 更好
Distance parent = (len - 2)/2;
while (true) {
// 重排以 parent 为首的子树。len是为了让__adjust_heap() 判断操作范围
__adjust_heap(first, parent, len, T(*(first + parent)));
if (parent == 0)
return; // 走完根节点,就结束。
parent--; // (即将重排之子树的)头部向前一个节点
}
}
九、heap算法演示案例
演示案例①
#include <iostream>
#include <algorithm>
using namespace std;
int main()
{
int arr[6] = { 4,1,7,6,2,5 };
std::make_heap(arr, arr + 6);
for (int i = 0; i < 6; ++i)
std::cout << arr[i] << " "; //7 6 5 1 2 4
std::cout << std::endl;
return 0;
}
![](https://i-blog.csdnimg.cn/blog_migrate/bc4aceb1a8e5052f1a9df20f5b89a54e.png)
- 初始化堆(make_heap)的步骤如下(下面的演示案例相同):
- 1.从最后一个具有孩子的节点开始检查(i=6/2=3),于是先检查i=3这个节点,其子节点都比其小,所以保持不变(图A所示)
- 2.接着检查i=3-1=2这个节点,其值1比两个子节点都小,但是左子节点6比右子节点2大,因此与左子节点6进行互换,得到结果如图B所示
- 3.接着检查i=2-1=1这个节点,其值比两个子节点都小,但是右子节点7比左子节点6大,因此与右子节点7进行互换,得到结果如图C所示。比较滞后其还有子节点,于是继续与子节点进行比较,发现比左子节点5值小,于是就继续进行互换,结果如下图D所示。(备注:这两步是同一步中完成的,我们分开来讲解)
- 4.由于已经遍历到根节点了,所以结束make_heap
![](https://i-blog.csdnimg.cn/blog_migrate/a35363f1398e0de59d30d4987b1317e8.png)
演示案例②
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main()
{
int arr[9] = { 0,1,2,3,4,8,9,3,5 };
std::vector<int> ivec(arr, arr + 9);
//构造一个最大堆
std::make_heap(ivec.begin(), ivec.end());
for (int i = 0; i < ivec.size(); ++i)
std::cout << ivec[i] << " "; //9 5 8 3 4 0 2 3 1
std::cout << std::endl;
ivec.push_back(7); //将7添加到尾部
for (int i = 0; i < ivec.size(); ++i)
std::cout << ivec[i] << " "; //9 5 8 3 4 0 2 3 1 7
std::cout << std::endl;
/*
上面将7添加到尾部,破坏了完全二叉树的结构,因此需要调用此函数
显式说明尾部有个元素需要插入到完全二叉树中,因此下面打印的为重新调整后的元素顺序
*/
std::push_heap(ivec.begin(), ivec.end());
for (int i = 0; i < ivec.size(); ++i)
std::cout << ivec[i] << " "; //9 7 8 3 5 0 2 3 1 4
std::cout << std::endl;
std::pop_heap(ivec.begin(), ivec.end());//只是将根节点移到容器尾部,但是还没有删除
std::cout << ivec.back() << std::endl; //打印9
ivec.pop_back(); //将最后的尾节点9移除
for (int i = 0; i < ivec.size(); ++i)
std::cout << ivec[i] << " "; //8 7 4 3 5 0 2 3 1
std::cout << std::endl;
std::sort_heap(ivec.begin(), ivec.end()); //对vector进行堆排序
for (int i = 0; i < ivec.size(); ++i)
std::cout << ivec[i] << " "; //0 1 2 3 3 4 5 7 8
std::cout << std::endl;
return 0;
}
![](https://i-blog.csdnimg.cn/blog_migrate/69292cc060c18ed54e31db79bd868e77.png)
演示案例③
- 下面的arr为数组(array),数组是不能动态改变大小的,因此当数组满载时不能对数组进行push_heap()操作
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main()
{
int arr[9] = { 0,1,2,3,4,8,9,3,5 };
std::vector<int> ivec(arr, arr + 9);
std::make_heap(arr, arr + 9);
for (int i = 0; i < 9; ++i)
std::cout << arr[i] << " "; //9 5 8 3 4 0 2 3 1
std::cout << std::endl;
std::sort_heap(arr, arr + 9);
for (int i = 0; i < 9; ++i)
std::cout << arr[i] << " "; //0 1 2 3 3 4 5 8 9
std::cout << std::endl;
//以上面的arr顺序再次构造一个最大堆
std::make_heap(arr, arr + 9);
for (int i = 0; i < 9; ++i)
std::cout << arr[i] << " "; //9 8 5 3 3 4 2 1 0
std::cout << std::endl;
//将最大堆的根节点弹出(移到尾部,但是还没有删除)
std::pop_heap(arr, arr + 9);
std::cout << arr[8] << std::endl; //9
return 0;
}
![](https://i-blog.csdnimg.cn/blog_migrate/52e23f86f0d3e9cfc71ad9cd44451ede.png)
- 我是小董,V公众点击"笔记白嫖"解锁更多【C++ STL源码剖析】资料内容。
![](https://i-blog.csdnimg.cn/blog_migrate/4e8489a1b95c3911ab85d46835eeb6a8.png)