数据结构——堆与堆排序

最近开始学习王争老师的《数据结构与算法之美》，通过总结再加上自己的思考的形式记录这门课程，文章主要作为学习历程的记录。

堆是一种特殊的树，只要满足以下两点，它就是一个堆：

一、堆是一个完全二叉树

二、堆中每一个节点的值都必须大于等于（或小于等于）其子树中每个节点的值。

对于每个节点的值都大于等于子树中每个节点值的堆，叫作“大顶堆”。

对于每个节点的值都小于等于子树中每个节点值的堆，叫作“小顶堆”。

如何实现一个堆？

要实现一个堆，要先知道堆都支持哪些操作以及如何存储一个堆。

完全二叉树通常用数组来存储，如下图：

数组中下标为i的节点的左子节点，就是下标为$i\ast 2$的节点，右子节点就是$i\ast 2+1$的节点。父节点就是下标为$i/2$的节点。

1.往堆中插入元素

往堆中插入一个元素后，我们需要继续满足堆的两个特性。把新插入的元素放在堆的最后，但这样不符合堆的特性，需要进行堆化。堆化实际上分为两种：从下往上和从上往下。堆化就是顺着节点所在路径，向上或向下，对比然后交换。

先讨论从下往上的堆化方法：

让新插入的节点与父节点对比大小。如果不满足子节点小于等于父节点的大小关系，就互换两个节点。一直重复这个过程，直到父子节点之间满足堆的大小关系。

def insert(data):
    data_list.append(data)   #data_list为数组，从下标1开始存储数据
    index = len(data_list)
    while(index/2>0 and data_list[index]>data_list[index/2]):  #自下往上堆化
        swap(data_list,index,index/2)
        index = index/2

2.删除堆顶元素

把最后一个节点放到堆顶，然后利用同样的父子节点对比方法。

def removeMax():
    if count==0: #count表示堆中已经存储的数据个数
        return -1
    a[1] = a[count]
    count-=1
    heapify(data_list,count,1)
    
def heapify(a,n,i):
    while True:
        maxvalue_index = i
        if i*2 <= n and a[i] < a[i*2]:
            maxvalue_index = i*2
        if i*2+1 <= n and a[maxPos] < a[i*2+1]:
            maxvalue_index = i*2+1
        if maxvalue_index==i:
            break
        swap(a,maxvalue,i)
        i = maxvalue_index

如何基于堆实现排序？

借助于堆这种数据结构实现的排序算法，就叫做堆排序。堆排序的过程分解为两个大步骤：建堆和排序。

一、建堆

首先将数组原地建成一个堆。建堆的过程有两种思路：

第一种是借助在堆中插入元素的思路，尽管数组中包含n个数据，但可以假设堆中只包含一个数据，就是下标为1的数据，然后调用前面讲的插入操作，将下标从2到n的数据依次插入到堆中，这样就包含n个数据的数组，组织成了堆。

第二种实现思路，是从后往前处理数组，并且每个数据都是从上往下堆化。

def buildHeap(a,n):
    for i in range(int(n/2),0,-1):
        heapify(a,n,i)

代码是对下标从$n/2$开始到1的数据进行堆化，下标为$n/2+1$到n的节点是叶子节点，不需要堆化。对于完全二叉树，下标从$n/2+1$到n的节点都是叶子节点。

因为叶子节点不需要堆化，所以需要堆化的节点从倒数第二层开始。每个节点堆化的过程中，需要比较和交换的个数，跟这个节点的高度k成正比。

将每个非叶子节点的高度求和，就是下面这个式子:

$S1=1\ast h+2^1\ast (h-1)+2^2\ast (h-2)+...+2^k\ast (h-k)+...+2^{h-1}\ast 1$

通过$2S1-S1$，得到$S=-h+2+2^2+...+2^{h-1}+2^h=2^{h+1}-h-2$

又$h=lo{g}_{2}n$代入公式S，就得到S=O(n)，故时间复杂度为O(n)。

二、排序

建堆结束后，数据中的数据已经是按照大顶堆的特性来组织的。数组中的第一个元素就是堆顶，也就是大元素，把它同最后一个元素交换，那最大元素就放到下标为n的位置。

有点类似于“删除堆顶元素”的操作，当堆顶元素移除后，我们把下标为n的元素放到堆顶，然后再通过堆顶的方法，将剩下的n-1个元素重新构建成堆。堆化完成后，我们再将堆顶的元素放到下标是n-1的位置，一直重复这个过程，直至最后堆中只剩下标为1的一个元素，排序工作就完成了。

def sort(a,n):
    buildHeap(a,n)
    k = n
    while(k>1):
        swap(a,1,k)
        k -= 1
        heapify(a,k,1)

每次重建意味着一个节点出堆，堆容量减一。每次重建对调次数与高度k成正比。重建堆需要n-1次循环，相加时间复杂度为$log2+log3+...+logn=log(n!)=nlogn$，故排序时间复杂度为O($nlogn$)。

堆排序是原地排序，包括建堆和排序。建堆的时间复杂度为O(n)，排序的时间复杂度为O($nlogn$)，故堆排序的时间复杂度为O($nlogn$)。

堆排序不是稳定的排序算法，因为在排序过程中，存在将堆的最后一个节点跟堆顶节点互换的操作，因此有可能改变值相同数据的原始相对顺序。

在实际开发中，为什么快速排序要比堆排序性能好？

①堆排序数据访问的方式没有快速排序友好。

②对于同样的数据，在排序过程中，堆排序算法的数据交换次数要多于快速排序。

的最后一个节点跟堆顶节点互换的操作，因此有可能改变值相同数据的原始相对顺序。

在实际开发中，为什么快速排序要比堆排序性能好？

①堆排序数据访问的方式没有快速排序友好。

②对于同样的数据，在排序过程中，堆排序算法的数据交换次数要多于快速排序。

堆的应用

堆这种数据结构有几个非常重要的应用：优先级队列、求Top K和中位数。

堆的应用一：优先级队列

在优先级队列中，数据的出队顺序不是先进先出，而是按照优先级，优先级最高的最先出队。

可以用堆来实现优先级队列。一个堆可以看作一个优先级队列。往优先级队列中插入一个元素，就相当于往堆中插入一个元素；从优先级队列中取出优先级最高的元素，就相当于取出堆顶元素。

1、合并有序小文件

假设有100个小文件，每个文件为100M，每个文件中存储的都是有序的字符串。希望将这100个小文件合并成一个有序的大文件，这就需要优先级队列。

通常我们会从这100个文件中，各取第一个字符串，放入数组中，然后比较大小，把最小的那个字符串放入合并后的大文件，并从数组中删除。如果采用数组这种数据结构，需要循环遍历整个数组，不够高效。

这里就可以用到优先级队列，也可以说是堆。从小文件中取出的字符串放入到小顶堆中，堆顶元素，也就是优先级队列队首的元素，就是最小的字符串。将这个字符串放入到大文件中，并将其从堆中删除，然后再从小文件中取出下一个字符串放入到堆中，循环这个过程，就可以将100个小文件中的数据依次放入到大文件中。删除堆顶数据和往堆中插入数据的时间复杂度是O($logn$)，n为100，如此操作更为高效。

2、高性能定时器

假设一个定时器，维护了很多定时任务，每个任务都设定了一个要触发执行的时间点。定时器每过一个很小的单位时间（比如说1秒），就扫描一遍任务，看是否有任务到达设定的执行时间。如果到达了，就拿出来执行。

每过1秒扫描一次任务列表的做法比较低效，主要因为：

第一，任务的约定执行可能还要很久。

第二，每次都要扫描整个任务列表，如果任务列表很大，势必会很耗时。

针对这些问题，可以用优先级队列来解决。按照任务设定的执行时间，将这些任务存储在优先级队列中，队列首部（小顶堆堆顶）存储的是最先执行的任务。

拿队首任务的执行时间点与当前时间点相减，得到一个时间间隔T。这样定时器在设定T秒后，再来执行任务。执行完队首的任务后，再计算新的队首任务的执行时间点与当前时间点的差值。如此反复，性能就提高了。

堆的应用二：利用堆求Top K

将求Top K的问题抽象成两类：一类是针对静态数据集合，即数据集合事先确定，另一类是针对动态数据集合，即有数据动态地加入到集合中。

针对静态数据，可以维护一个大小为K的小顶堆，顺序遍历数组，从数组中取出数据与堆顶元素。如果比堆顶元素大，就把堆顶元素删除，并将这个元素插入到堆中。如果比堆顶元素大，则不作处理，继续遍历。等数据都遍历完后，堆中的数据就是前K大数据。遍历数组需O(n)的时间复杂度，一次堆化操作需O($logK$)的时间复杂度。最坏的情况下，n个元素都入堆一次，时间复杂度为O($nlogK$)。

针对动态数据，求得Top K就是实时Top K。实际上，我们都一直在维护一个K大小的小顶堆。当有数据被添加到集合中，我们就拿它与堆顶的元素进行对比。对比过程与之前相同。

堆的应用三：利用堆求中位数

中位数，即处在中间位置的那个数。如果数据的个数是奇数，把数据从小到大排列，那第$n/2+1$个数据就是中位数（数据从0开始编写）。如果数据是偶数的话，那处于中间位置的数据有两个，第$n/2$和第$n/2+1$个数据。可以随便取一个，如$n/2$为中位数。

对于一组静态数据，中位数是固定的，排序后取第$n/2$个数据。

但对于一组动态数据，中位数不断变动，再用排序的办法效率就不高了。但借助堆这种数据结构，可以非常高效地实现求中位数操作。

我们需要维护两个堆，一个大顶堆，一个小顶堆。大顶堆中存储前半部分数据，小顶堆中存储后半部分数据，且小顶堆中的数据都大于大顶堆中的数据。如下图：

其中，大顶堆的堆顶元素就是我们要找的中位数。

如果新加入的数据小于等于大顶堆的堆顶元素，我们就将这个数据插入到大顶堆中，否则，就将这个数据插入到小顶堆中。同时，通过从一个堆中不停地将堆顶元素移动到另一个堆，通过这样的调整，使其满足这样的约定。

插入数据需要堆化，故时间复杂度为O($logn$)，求中位数时，只需返回大顶堆的堆顶，时间复杂度为O(n)。

参考资料：王争《数据结构与算法之美》