1 前言

今天一起学习一下堆和优先队列，重点是堆排序的理解和优先队列的用法。

通过本文你将了解到以下内容：

• 堆的基本原理
• 堆的调整函数
• 堆排序及其应用
• 优先队列的概念
• 优先队列的原理和应用
  9 [3 {, A; k4 u, b

2 堆2.1 堆的基本概念

数据结构中的堆区别于内存分配的堆，我们说的用于排序的堆是一种表示元素集合的结构，堆是一种二叉树。

看看维基百科中对于堆的定义和说明：

堆是计算机科学中的一种特别的树状数据结构。

堆始于J. W. J. Williams在1964年发表的堆排序，当时他提出了二叉堆树作为此算法的数据结构，堆在戴克斯特拉算法和带优先级队列中亦为重要的关键。

若是满足以下特性，即可称为堆：给定堆中任意节点P和C，若P是C的母节点，那么P的值会小于等于C的值。若母节点的值恒小于等于子节点的值，此堆称为最小堆；反之称为最大堆。

2.2 堆的两个特性

堆有两个决定性特性：元素顺序和树的形状

• 元素顺序
  1 C. e! r# d7 G0 \

在堆中任何结点与其子结点的大小都遵守数值大小关系。

A. 如果结点大于等于其所有子结点，也就是堆的根是所有元素中最大的，这种堆称为大根堆(大顶堆、最大堆)；

B. 如果结点小于等于其所有子结点，也就是堆的根是所有元素中最小的，这种堆称为小根堆(小顶堆、最小堆)；

C. 大根堆/小根堆只是约定了父结点和子结点的大小关系，但是并不约束子结点的相对大小和顺序；

如图为小根堆结构：

• 树的形状
  : k: H) d. @1 a% ]( P

堆这种二叉树最多在两层具有叶子结点，并且最底层的叶子结点靠左分布，该树种不存在空闲位置，也就是堆是个完全二叉树。

上述的两种性质可以保证快捷找到最值，并且在插入和删除新元素时可以实现重新组织再次满足堆的性质。

2.3 堆的数组表示

堆中没有空闲位置并且数组是连续的，但是数组的下标是从0开始，为了统一，我们统一从1开始，也就是root结点的数组index=1，那么可以通过数组的index可以通过父结点找到左右子结点，也可以通过子结点找到父结点。

数组的元素遍历就是堆的层次遍历的结果，因此数组存储的堆具备以下性质：

//数组下标范围
i<=n && i>=1
//根结点下标为1
root_index = 1
  Z* r' n' H2 f) x) K% Z//层次遍历第i个结点的值等于数组第i个元素
! v1 U- j" [/ m* E2 l7 svalue(i) = array
//堆中第i个元素的左孩子下标i*2
" b! J) Z" ?) h7 q$ T  dleft_child_index(i) = i*2
: ^* M4 M+ i; F9 i! c//堆中第i个元素的右孩子下标i*2+1
right_child_index(i) = i*2+1
4 F+ H2 h! R3 e* n$ Q! n2 @2 }//堆中第i个元素的父结点下标i/2
( V- H& }; N3 M+ ?6 M- dparent(i) = i/2

7 v  i8 {  l# J  ^4 I堆和数组的对应关系如图：
$ x& M; f- u1 k6 K- }' h/ N# k

2.4 堆的调整函数

堆调整的过程非常像数学归纳法的递推过程，看一下就知道，敲黑板！以下两个函数对于掌握堆非常重要。

2.4.1 siftup函数的原理

以小根堆为例，之前a[1...n-1]满足堆的特性，在数组a[n]插入新元素之后，就产生了两种情况：
2 h* x$ a; N) X- Y7 _A. 如果a[n]大于父结点那么a[1...n]仍然满足堆的特性，不需要调整；
0 M6 r4 r- t. m) u) \; F/ iB. 如果a[n]比它的父结点要小无法保证堆的特性，就需要进行调整；

循环过程：自底向上的调整过程就是新加入元素不断向上比较置换的过程，直到新结点的值大于其父结点，或者新结点成为根结点为止。
+ r2 B4 g1 }" [; Z7 N6 J8 {8 X停止条件：siftup是一个不断向上循环比较置换的过程，理解循环的关键是循环停止的条件，从伪码中可以清晰地看到，siftup的伪码：

//siftup运行的前置条件
heap(1,n-1) == True
8 }5 H" B: U. C- }1 Q; A1 n8 Dvoid siftup(n)
     i = n
& d1 P7 y9 W: p; ~; k! R  _9 _     loop:
0 r& V+ r9 X; z: W         // 循环停止条件一
7 _$ O" C  [. P- y         // 已经是根结点
         if i == 1:
             break;
/ g5 |/ B; c8 t( z, r  U         p = i/2
4 T# D7 N4 |% s% A. z         // 循环停止条件二
& b1 T5 B& H* x+ V' a/ f8 e         // 调整结点大于等于在此位置的父结点
         if a[p] <= a
; a( R0 E" b; A5 a- H              break;
& B7 H+ E& I- {1 t" b  h$ V         swap(a[p],a)
         // 继续向上循环
: x4 N& j2 b$ T6 W+ n. c         i = p

siftup调整过程演示
( Q1 g$ v- j" _1 [+ i1 N7 L

在尾部插入元素16的调整过程如图：

2.4.2 siftdn函数的原理

以小根堆为例，之前a[1...n]满足堆的特性，在数组a[1]更新元素之后，就产生了两种情况：
A. 如果a[1]小于等于子结点仍然满足堆的特性，不需要调整；
B. 如果a[1]大于子结点无法保证堆的特性，就需要进行调整；

循环过程：自顶向下的调整过程就是新加入元素不断向下比较置换的过程，直到新结点的值小于等于其子结点，或者新结点成为叶结点为止。
$ h2 ?3 ?* h1 u9 @! I% O停止条件：siftdn是一个不断向下循环比较置换的过程，理解循环的关键是循环停止的条件，从伪码中可以清晰地看到siftdn的伪码:

heap(2,n) == True
6 Z& e, ~6 c1 N5 F0 [9 ^5 [1 m" D- ~void siftdn(n)
     i = 1
% @0 g0 q8 R+ y* D: y2 \3 G) R     loop:
         // 获取理论上的左孩子下标
         c = 2*i
+ Q% e$ a. I! f* K0 k. i1 _         // 如果左孩子下标已经越界
$ |/ ^% y; V6 o* P, ^3 u) n         // 说明当前已经是叶子结点
         if c > n:
             break;
         //如果存在右孩子
( L7 ?! s' H7 \         // 则获取左右孩子中更小的一个
4 S8 i0 Q: ~# |+ l. p2 l         // 和父结点比较
         if c+1 <= n:
             if a[c] > a[c+1]
                 c++
         // 父结点小于等于左右孩子结点则停止
         if a <= a[c]
3 V9 k3 l, s5 ?! h) W$ A+ g* U) {             break;
; m, v; Z1 g3 M6 d* z& d         // 父结点比左右孩子结点大
' |  k$ D* N, R; ~         // 则与其中较小的孩子结点交换
         // 也就是让原来的孩子结点成为父结点
2 f: B1 j3 f. ]) M+ _" @  E& ]         swap(a,a[c])
         // 继续向下循环
- ^9 P0 b1 Y  y4 w+ F         i = c     

siftdn调整过程演示

在头部元素更新为21的调整过程如图：

2.5 堆排序

场景：假如有200w数据，要找最大的前10个数。

分析：那么就需要先建立大小为10个元素的小顶堆，然后再逐渐把其他所有元素依次渗透进来比较或入堆淘汰老数据或跳过，直至所有数据渗透完成，最后小根堆的10个元素就是最大的10个数了。

小根堆：选择最大的TopN个数据使用小根堆，因为堆顶就是最小的数据，每次进来的新数据只需要和堆顶比较即可，如果小于堆顶则跳过，如果大于堆顶则替换掉堆顶进行siftdn调整，来找到新进元素的正确位置，以及产生新的堆顶。

建堆过程：可以自顶向下自底向上均可，以下采用自底向上思路分析。可以将数组的叶子节点，是单个结点满足二叉堆的定义，于是从底层叶子结点的父结点从左到右，逐个向上构建二叉堆，直到第一个节点时整个数组就是一个二叉堆，这个过程是siftup和siftdn的混合，宏观上来看是自底向上，微观上每个父结点是自顶向下。

渗透排序过程：完成堆化之后，开处理N之后的元素，从N+1~200w，遇到比当前堆顶大的则与堆顶元素交换，进入堆触发siftdn调整，直至生产新的小根堆。

代码实战：leetCode 第215题 数组中的第K个最大元素。

这道题可以用堆排序来完成，建立小根堆取堆顶元素即可，验证通过的代码举例：

//leetcode 215th the Kth Num
, V9 f, f: P# t8 _- P//Source Code:C++
class Solution {
& o# [$ H7 Q9 l) V0 I6 r! {public:
    //调整以当前节点为根的子树为小顶堆
    int heapadjust(vector<int> &nums,int curindex,int len){
) h5 H# r3 I) D3 @9 ^        int curvalue = nums[curindex];
        int child = curindex*2+1;
        while(child<len){
            //左右孩子中较小的那个
- F% g6 J) n6 l            if(child+1<len && nums[child] > nums[child+1]){
/ A- D% X# [" D% n                child++;
/ ^' |* s3 }3 T5 d            }
- ?  T9 Y6 Q/ R" j; Z) B            //当前父节点比左右孩子其中一个大
            if(curvalue > nums[child]){
( N  R7 y9 k. Y, }6 i                nums[curindex]=nums[child];
) x4 `. k6 D- o1 D$ Q5 Z; B                curindex = child;
                child = curindex*2+1;
            }else{
, x$ c5 K: W/ V. V6 `  w" ?# i                break;
            }
9 Z" a' i$ a6 @$ D; u3 c  d+ i        }
7 i2 U7 }1 v' y5 w" }        nums[curindex]=curvalue;
( F& U- N# V1 X        return 0;
! M9 L5 h' F* ]& N    }

/ ?  p5 C; s  ~. w* N    int findKthLargest(vector<int>& nums, int k) {
7 L9 z9 O+ E1 @2 o8 }        //边界条件
0 M; U: Y1 }+ h0 x5 @, K& ?$ D9 l        if(nums.size()<k)
            return -1;
9 Y' @8 p/ @1 O3 M: O        //建立元素只有K个的小顶堆
        //截取数组的前k个元素
        vector<int> subnums(nums.begin(),nums.begin()+k);
+ |- e- ]  w  s0 L1 j1 E0 s        int len = nums.size();
5 X" ]; e. @1 L' f5 |        int sublen = subnums.size();
        //将数组的前k个元素建立小顶堆
3 K. n  O: f8 O1 i% ?8 ~. |        for(int i=sublen/2-1;i>=0;i--){
; |$ ]$ O9 X2 L. K5 g1 m9 R            heapadjust(subnums,i,sublen);
        }
9 T6 C3 ~; ]2 G3 P7 ]        //建立好小顶堆之后 开始逐渐吸收剩余的数组元素
        //动态与堆顶元素比较 替换
        for(int j=k;j<len;j++){
            if(nums[j]<=subnums[0])
                continue;
8 m! {( P/ V" W9 x* i7 P            subnums[0] = nums[j];
% J" ?0 D& j9 W3 x+ }            heapadjust(subnums,0,sublen);
6 S  D: R. H# Z% V9 G% T# T9 x" [        }
        return subnums[0];  
    }
};2.6 堆小结

从实践来看，堆的重要用途是堆排序，堆排序重点是初始化堆和调整堆两个过程，然而这两个过程都离不开siftup和siftdn两个函数，因此掌握这两个函数，基本上就掌握了堆。

由于堆是二叉树，因此在实际使用中需要结合树的遍历和循环来实现堆调整，掌握堆调整过程和二叉树遍历过程，拿下堆，指日可待。

3 优先队列

先来看看维基百科对优先队列的定义：

优先队列是计算机科学中的一类抽象数据类型。

优先队列中的每个元素都有各自的优先级，优先级最高的元素最先得到服务；优先级相同的元素按照其在优先队列中的顺序得到服务。

优先队列至少需要支持下述操作：

a.插入带优先级的元素

b.取出具有最高优先级的元素

c.查看最高优先级的元素。

综合考虑插入和删除的性能 优先队列一般采用堆来实现。

由于优先队列的元素既可以是基础类型，也可以是复合类型，因此在C++中一般使用模板来定义优先队列，从而提高其可扩展性，简单定义：

template<class T>
: T8 c3 ?1 n0 u: lclass priqueue {
public:
& `4 x/ j" F- M* v! D# O& F       //构造函数 初始化
& l4 z! A. `& H2 D       priqueue(int maxsize);
       //将T类型新元素添加到队列中
       void insert(T t);
; A6 K6 p8 l5 p! J1 E" c4 t       //获取队列中最小的元素
       T extractmin();
+ _8 f# `. g! y; u# w* z: K};3.1 优先队列的理论实现

实现优先队列的候选数据结构包括：有序序列、无序序列、堆。

• 有序序列
  0 {+ K! M3 }% D+ V0 k% D有序序列中存储的数据都是有序的，在执行extractmin获取最小值时复杂度O(1)，但是在添加新元素时就存在大量的移动和查找正确的位置最大复杂度O(N)，因此在insert和extactmin同时执行N次时，最大复杂度为O(N^2)。

• 无序序列
  无序序列中存储的元素是无序的，在执行insert操作复杂度为O(1)，但是在extractmin时每次都要进行一次遍历复杂度为O(N)，因此在insert和extractmin同时执行N次时，最大复杂度为O(N^2)。

• 堆结构
  1 K+ g  n  D$ s# P) Y8 {5 y从上一节我们知道堆的insert不如无序序列那么随意，extractmin也没有有序序列那么容易，每次都需要进行siftup和siftdn操作进行调整，但是同时执行insert和extractmin时，复杂度是O(nlogn)，优于O(N^2)。

  
  

综上可知，堆结构在实现优先队列的插入和删除操作时复杂性都很稳定，在大量数据的场景下优于有序序列和无序序列，因此权衡之下选择堆作为优先队列的底层数据结构。

3.2 优先队列的工程实现

考虑优先队列的灵活性和效率，可以基于模板化和堆来实现优先队列：

template<class T>
( T2 Q/ ~8 h$ N5 |, `+ w' ]class priqueue {
- \7 t. A) _* b8 J' G5 q9 h7 \' t    private:
        int n,maxsize;
* J- Z9 j! a; [        T *x;
        void swap(int i,int j)
' ^# B8 H2 h5 {1 B& l) s! I        { T t = x; x = x[j]; x[j] = t; }
    public:
        //初始化
        priqueue(int m)
        {
1 j+ V* e+ R2 G$ u' Z" N" f            maxsize = m;
            x = new T[maxsize+1];
7 J  {; C. ^+ n8 ]. `            n = 0;
; G7 D0 i! i7 p0 K4 e( n; O& }        }
        //插入新数据
        void insert(T t)
6 c' p. e; S8 K8 Y& J5 T5 B        {
' T7 E) h, K# |            int i,p;
            x[++n] = t;
8 ]8 ~% O2 O& e# E            //末尾添加新数据 执行siftup操作
            for (i = n; i > 1 && x[p=i/2] > x; i = p)
# ?1 S* V; M3 V& k7 Q4 f0 x                swap(p,i);
        }
        //提取操作
        T extractmin()
       {
  K3 C. v1 ^, @9 }3 J; {2 N          int i,c;
          //提取堆顶元素
) B; @/ B1 h) f7 j+ g7 S2 Q          T t = x[1];
3 V' M9 D! C) o% m1 Y1 ?0 c/ e  s          //将尾部元素放到堆顶
0 [, y0 j' ], p0 }: @          x[1] = x[n--];
          //针对新堆顶进行siftdn操作
7 ]! _- k- }2 P6 [9 }          for (i = 1; (c = 2*i) <= n; i = c) {
* G; x7 g9 b; f/ e              if (c+1 <= n && x[c+1] < x[c])
                   c++;
              if (x <= x[c])
' B. [6 b: F( z, ^- _2 t% J                   break;
/ Y# b: G& _( q- [3 r               swap(c,i);
          }
% c* M4 I9 H+ d2 E4 n         return t;
& V' a( `0 n6 R; p      }
};

上述代码摘自编程珠玑并不是STL关于优先队列的实现，只是一部分简洁的代码，旨在表现insert和extract操作时如何运用堆的siftup和siftdn操作来封装成优先队列类的基础成员函数。

3.3 优先队列的自定义优先级

模板化的优先队列扩展了使用场景，但是也产生了新的问题，就是默认的优先级比较函数不一定满足所有要求，因此很多时候都需要自己来定义优先级判定函数。

实现了一个模板优先队列需要三个参数：

• 容器元素的类型

• 存储数据所用的容器

• 比较函数 缺省情况是less

  
  9 G6 e! C' u$ f1 B0 F

#include<quque>
$ t3 w4 P- [# \// 队列和优先队列的声明
std::queue<T> pq;
std::priority_queue<T, std::vector<T>, cmp> pq;
* X! k3 c, U: M- u" E$ X3 w* [//模板化优先队列的主要参数
3 z+ R: ~" _1 q$ z# epriority_queue<Type, Container, Func>
//举例
priority_queue<pair<char,int>,vector<pair<char,int>>,compare> pq;
//自定义比较函数
* @1 i0 X0 X: B$ Pstruct compare
# P# [* V+ F7 g2 h{
" [4 E% ?' P3 e- [    bool operator()(const pair<char,int> a,const pair<char,int> b){
        return b.second > a.second;
    }  
* F% [6 f/ q; x* r2 v7 j. d7 y+ }};

3.4 优先队列的应用

可以认为优先队列是对堆的工具化封装，加上模板和自定义比较函数两个利器加持，优先队列让使用者不再苦于堆排序的原始造轮子。

TopN问题和优先队列

仍以LeetCode 215题为例，获取数组第K大元素。

上一节中我们直接使用堆，但是构建的是小顶堆，并且大小是K个元素，遍历完成之后直接取堆顶即可，但是在数据量不大或者内存足够的情况下，可以直接建立优先队列。

默认的优先队列本质上是大顶堆，那么堆顶就不是第K大元素了，但是从堆顶开始依次pop出K-1个元素，堆顶也就是第K大元素了。

当然也可以修改比较函数实现小顶堆，取堆顶元素也是可以的，要灵活运用。使用优先队列实现LeetCode 第215题，代码如下：

//默认的比较函数是less 也就是优先队列相当于最大堆
% Q6 ?; n+ Z( Q( H3 k2 ?& `4 u" V//堆顶元素为最大值
& S5 V9 p9 {8 N% L( rpriority_queue<int,vector<int>,less<int>> q;
) v2 r0 P3 a" c0 x# d5 `* m; D! Hint findKthLargest(vector<int>& nums, int k)
# O2 Q$ j1 A! ?{
  priority_queue<int> q(nums.begin(),nums.end());
  for(int i=0;i<k-1;i++)
  _  s- T" J. V/ ?& ?      q.pop();
2 f* l' O6 Q4 l9 V5 m$ f) }  return q.top();
8 {9 v. W1 Z8 J! O! t! {. ?: t}

优先队列是贪心算法的重要组成部分，借助于优先队列贪心算法可以解决非常多的实际问题包括：

• 旅行商TSP问题
• 01背包问题
• 霍夫曼编码问题
• 最短路径Dijkstra算法
• 最小生成树Prim算法
  8 g3 X, v9 C9 C: H8 ?