数据结构与算法之美 - 堆和堆排序

153 阅读12分钟

堆是一种特殊的树,它需要满足以下两点要求:

  • 堆是一个完全二叉树
  • 堆中每一个节点的值都必须大于等于(或小于等于)其子树中每个节点的值

对于每个节点的值都大于等于子树中每个节点值得堆,我们称之为大顶堆,对于每个节点的值都小于等于子树中每个节点值得堆,我们称之为小顶堆

如何实现一个堆

要实现一个堆,我们需要知道,如何存储一个堆堆都支持哪些操作

如何存储一个堆?

因为堆是一个完全二叉树,而完全二叉树比较适合使用数组来存储,可以非常节省存储空间。

堆的操作

1.往堆中插入一个元素

插入元素到堆之后,通过对元素位置进行调整,让其满足堆的特性,这就是堆化

堆化实际上有两种,从下到上和从上到下,我们先讲从下到上的堆化方法

把新插入的数据放到数组的最后,然后从下往上堆化。

2.删除堆顶元素

把堆的最后一个节点放到堆顶,然后利用同样的父子节点对比方法,对不满足父子节点大小关系的,互换两个节点,重复进行这个过程,直到所有节点满足大小关系为止。这就是从上而下的堆化方法

复杂度分析

一个包含 n 个节点的完全二叉树,树的高度不会超过 log2n,堆化的过程是顺着节点所在路径比较交换的,所以堆化的时间复杂度跟树的高度成正比,也就是 O(logn) 。插入数据和删除堆顶元素的主要操作就是堆化,所以往堆中插入一个元素和删除堆顶元素的时间复杂度都是 O(logn) 。

堆排序

我们借助于堆这种数据结构实现的排序方法就叫做堆排序,堆排序的时间复杂度非常稳定,是 O(nlogn) ,并且它还是原地排序算法,如此优秀,它是如何做到的?

我们可以把堆排序的过程大致分解成两个大步骤:建堆排序

1.建堆

我们首先将数组原地建成一个堆,有两种思路。

第一种,借助之前讲的,在堆中插入一个元素的思路。尽管数组中已经包含了 n 个数据,但是我们可以假设,起初堆中只有一个数据,就是下标为 1 的数据,然后我们调用前面的插入操作,将下标从 2 到 n 的数据依次插入到堆中。

第二种,我们先把数组中的数据依次放入堆中,然后开始进行堆化,由于叶子节点不需要堆化,所以我们从第一个非叶子节点开始,依次从上往下堆化。

代码实现:

@classmethod
def build_heap(cls, a: List[int]) -> None:
		"""Data in a needs to start from index 1."""
		for i in range((len(a) - 1)//2, 0, -1):
				cls._siftdown(a, len(a) - 1, i)

@classmethod
def _siftdown(cls, a: List[int], count: int, root_index: int = 1) -> None:
    i = larger_child_index = root_index
    while True:
    		left, right = cls._left(i), cls._right(i)
      	if left <= count and a[i] < a[left]:
        		larger_child_index = left
      	if right <= count and a[larger_child_index] < a[right]:
          	larger_child_index = right
        if larger_child_index == i: break
        a[i], a[larger_child_index] = a[larger_child_index], a[i]
        i = larger_child_index

建堆的时间复杂度:O(n)

2.排序

建堆结束之后,数组中的数据已经是按照大顶堆的特性来组织的,数组中的第一个元素就是堆顶,也就是最大的元素。我们把它和最后一个元素交换,那最大的元素就放到了下标为 n 的位置,然后我们对剩下的 n-1 个元素进行堆化,将他们重新构建成堆。堆化完成后,我们再取堆顶的元素,放到下标为 n-1 的位置,一直重复这个过程,直到最后堆中只剩下下标为 1 的一个元素,排序工作就完成了。

代码实现:

@classmethod
def sort(cls, a: List[int]) -> None:
		"""Data in a needs to start from index 1."""
		cls.build_heap(a)
		k = len(a) - 1
		while k > 1:
				a[1], a[k] = a[k], a[1]
				k -= 1
				cls._siftdown(a, k)

性能分析

整个堆排序过程,都只需要极个别的临时存储空间,所以堆排序是原地排序算法。

堆排序包括建堆和排序两个操作,建堆过程的时间复杂度为 O(n) ,排序过程的时间复杂度为 O(nlogn) ,所以堆排序整体的时间复杂度是 O(nlogn) 。

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

在实际开发中,为什么快速排序比堆排序性能好?

第一点,堆排序数据访问的方式没有快速排序友好。

对于快速排序来说,数据是顺序访问的,而对于堆排序,数据是跳着访问的,这样堆CPU缓存是不友好的。

第二点,对于同样的数据,在排序过程中,堆排序的数据交换次数要多于快速排序。

堆的应用

一、优先级队列

优先级队列,顾名思义,它首先应该是一个队列。我们前面讲过,队列最大的特性就是先进先出。不过,在优先级队列中,数据的出队顺序不是先进先出,而是按照优先级来,优先级最高的,最先出队。

如何实现一个优先级队列呢?方法有很多,但是用堆来实现是最直接、最高效的。这是因为,堆和优先级队列非常相似。一个堆就可以看作一个优先级队列。很多时候,它们只是概念上的区分而已。往优先级队列中插入一个元素,就相当于往堆中插入一个元素;从优先级队列中取出优先级最高的元素,就相当于取出堆顶元素。

你可别小看这个优先级队列,它的应用场景非常多。我们后面要讲的很多数据结构和算法都要依赖它。比如,赫夫曼编码、图的最短路径、最小生成树算法等等。

1.合并有序小文件

假设我们有100个小文件,每个文件的大小是100MB,每个文件中存储的都是有序的字符串。我们希望将这些100个小文件合并成一个有序的大文件。这里就会用到优先级队列。

整体思路有点像归并排序中的合并函数。我们从这100个文件中,各取第一个字符串,放入数组中,然后比较大小,把最小的那个字符串放入合并后的大文件中,并从数组中删除。

假设,这个最小的字符串来自于13.txt这个小文件,我们就再从这个小文件取下一个字符串,并且放到数组中,重新比较大小,并且选择最小的放入合并后的大文件,并且将它从数组中删除。依次类推,直到所有的文件中的数据都放入到大文件为止。

这里我们用数组这种数据结构,来存储从小文件中取出来的字符串。每次从数组中取最小字符串,都需要循环遍历整个数组,显然,这不是很高效。有没有更加高效方法呢?

这里就可以用到优先级队列,也可以说是堆。我们将从小文件中取出来的字符串放入到小顶堆中,那堆顶的元素,也就是优先级队列队首的元素,就是最小的字符串。我们将这个字符串放入到大文件中,并将其从堆中删除。然后再从小文件中取出下一个字符串,放入到堆中。循环这个过程,就可以将100个小文件中的数据依次放入到大文件中。

2.高性能定时器

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

但是,这样每过1秒就扫描一遍任务列表的做法比较低效,主要原因有两点:第一,任务的约定执行时间离当前时间可能还有很久,这样前面很多次扫描其实都是徒劳的;第二,每次都要扫描整个任务列表,如果任务列表很大的话,势必会比较耗时。

针对这些问题,我们就可以用优先级队列来解决。我们按照任务设定的执行时间,将这些任务存储在优先级队列中,队列首部(也就是小顶堆的堆顶)存储的是最先执行的任务。 这样,定时器就不需要每隔1秒就扫描一遍任务列表了。它拿队首任务的执行时间点,与当前时间点相减,得到一个时间间隔T。 这个时间间隔T就是,从当前时间开始,需要等待多久,才会有第一个任务需要被执行。这样,定时器就可以设定在T秒之后,再来执行任务。从当前时间点到 (T-1) 秒这段时间里,定时器都不需要做任何事情。 当T秒时间过去之后,定时器取优先级队列中队首的任务执行。然后再计算新的队首任务的执行时间点与当前时间点的差值,把这个值作为定时器执行下一个任务 需要等待的时间。

这样,定时器既不用间隔1秒就轮询一次,也不用遍历整个任务列表,性能也就提高了。

二、求Top K

我把这种求Top K的问题抽象成两类。一类是针对静态数据集合,也就是说数据集合事先确定,不会再变。另一类是针对动态数据集合,也就是说数据集合事先并不确定,有数据动态地加入到集合中。

针对静态数据,如何在一个包含n个数据的数组中,查找前K大数据呢?我们可以维护一个大小为K的小顶堆,顺序遍历数组,从数组中取出取数据与堆顶元素比较。如果比堆顶元素大,我们就把堆顶元素删除,并且将这个元素插入到堆中;如果比堆顶元素小,则不做处理,继续遍历数组。这样等数组中的数据都遍历完之后,堆中的数据就是前K大数据了。

遍历数组需要O(n)的时间复杂度,一次堆化操作需要O(logK)的时间复杂度,所以最坏情况下,n个元素都入堆一次,所以时间复杂度就是O(nlogK)。

针对动态数据求得Top K就是实时Top K。怎么理解呢?我举一个例子。一个数据集合中有两个操作,一个是添加数据,另一个询问当前的前K大数据。

如果每次询问前K大数据,我们都基于当前的数据重新计算的话,那时间复杂度就是O(nlogK),n表示当前的数据的大小。实际上,我们可以一直都维护一个K大小的小顶堆,当有数据被添加到集合中时,我们就拿它与堆顶的元素对比。如果比堆顶元素大,我们就把堆顶元素删除,并且将这个元素插入到堆中;如果比堆顶元素小,则不做处理。这样,无论任何时候需要查询当前的前K大数据,我们都可以里立刻返回给他。

三、求中位数

中位数,顾名思义,就是处在中间位置的那个数。如果数据的个数是奇数,把数据从小到大排列,那第 n2+1\frac{n}{2}+1 个数据就是中位数;如果数据的个数是偶数的话,那处于中间位置的数据有两个,第 n2\frac{n}{2} 个和第 n2+1\frac{n}{2}+1 个数据,这个时候,我们可以随意取一个作为中位数,比如取两个数中靠前的那个, 就是第 n2\frac{n}{2} 个数据。

对于一组静态数据,中位数是固定的,我们可以先排序,第 n2\frac{n}{2} 个数据就是中位数。每次询问中位数的时候,我们直接返回这个固定的值就好了。所以,尽管排序的代价比较大,但是边际成本会很小。但是,如果我们面对的是动态数据集合,中位数在不停地变动,如果再用先排序的方法,每次询问中位数的时候,都要先进行排序,那效率就不高了。

借助堆这种数据结构,我们不用排序,就可以非常高效地实现求中位数操作。我们来看看,它是如何做到的?

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

也就是说,如果有n个数据,n是偶数,我们从小到大排序,那前 n2\frac{n}{2} 个数据存储在大顶堆中,后 n2\frac{n}{2} 个数据存储在小顶堆中。这样,大顶堆中的堆顶元素就是我们要找的中位数。如果n是奇数,情况是类似的,大顶堆就存储 n2+1\frac{n}{2}+1 个数据,小顶堆中就存储 n2\frac{n}{2} 个数据。

我们前面也提到,数据是动态变化的,当新添加一个数据的时候,我们如何调整两个堆,让大顶堆中的堆顶元素继续是中位数呢?

如果新加入的数据小于等于大顶堆的堆顶元素,我们就将这个新数据插入到大顶堆;如果新加入的数据大于等于小顶堆的堆顶元素,我们就将这个新数据插入到小顶堆。

这个时候就有可能出现,两个堆中的数据个数不符合前面约定的情况:如果n是偶数,两个堆中的数据个数都是 n2\frac{n}{2} ;如果n是奇数,大顶堆有 n2+1\frac{n} {2}+1 个数据,小顶堆有 n2\frac{n}{2} 个数据。这个时候,我们可以从一个堆中不停地将堆顶元素移动到另一个堆,通过这样的调整,来让两个堆中的数据满足上面的约定。

于是,我们就可以利用两个堆,一个大顶堆、一个小顶堆,实现在动态数据集合中求中位数的操作。插入数据因为需要涉及堆化,所以时间复杂度变成了O(logn),但是求中位数我们只需要返回大顶堆的堆顶元素就可以了,所以时间复杂度就是O(1)。