天天看点

数据结构与算法之美-10 堆 优先级队列 [MD]

博文地址

我的GitHub 我的博客 我的微信 我的邮箱
baiqiantao bqt20094 [email protected]

目录

  • 28 | 堆和堆排序:为什么说堆排序没有快速排序快?
    • 堆的概念
    • 如何存储一个堆
    • 堆上的主要操作
      • 堆化
      • 插入一个元素:从下往上的堆化
      • 删除堆顶元素:从上往下的堆化
        • 错误的方法
        • 正确的方法
    • 堆排序算法
      • 建大顶堆
        • 建堆图解
        • 建堆代码
        • 建堆的时间复杂度
      • 排序过程:循环堆化
    • 堆排序图解及代码
    • 堆排序性能分析
    • 为什么快速排序比堆排序性能好
  • 29 | 堆的应用:如何快速获取到Top 10最热门的搜索关键词?
    • 堆的应用一:优先级队列
      • 合并有序小文件
        • 方案一:利用数组
        • 方案二:利用堆
      • 高性能定时器
    • 堆的应用二:利用堆求 Top K
      • 静态数据集
      • 动态数据集合
    • 堆的应用三:利用堆求中位数
      • 求动态数据集合中的中位数
      • 求百分位的数据
    • 解答开篇

堆是一种特殊的树

,只要满足下面这两点,它就是一个堆。

  • 堆是一个

    完全二叉树

    • 完全二叉树要求,除了最后一层,其他层的节点个数都是满的,最后一层的节点都靠左排列
  • 堆中每一个节点的值都必须大于等于(或小于等于)其子树中每个节点的值
    • 等价于,堆中每个节点的值都大于等于(或者小于等于)其左右子节点的值
    • 每个节点的值都大于等于子树中每个节点值的堆,叫做“大顶堆”
    • 每个节点的值都小于等于子树中每个节点值的堆,叫做“小顶堆”

完全二叉树比较适合用

数组

来存储,因为我们不需要存储左右子节点的指针,单纯地通过数组的

下标

,就可以找到一个节点的左右子节点和父节点。

数据结构与算法之美-10 堆 优先级队列 [MD]

数组中下标为 i 的节点的:

  • 左子节点就是下标为

    i∗2

    的节点
  • 右子节点就是下标为

    i∗2 + 1

  • 父节点就是下标为

    i/2

  • 往堆中插入一个元素
  • 获取、删除堆顶元素

往堆中插入一个元素或删除堆顶元素后,为了继续满足堆的两个特性,我们需要对堆进行调整,这个过程就叫做

堆化

(heapify)。

堆化实际上有两种,

从下往上

从上往下

堆化非常简单,就是顺着节点所在的路径,向上或者向下,对比,然后交换。

一个包含 n 个节点的完全二叉树,树的高度不会超过 logn。堆化的过程是顺着节点所在路径比较交换的,所以堆化的时间复杂度跟树的高度成正比,也就是

O(logn)

。插入数据和删除堆顶元素的主要逻辑就是堆化,所以,往堆中插入一个元素和删除堆顶元素的时间复杂度都是

O(logn)

我们让新插入的节点与父节点

对比

大小,如果不满足子节点小于等于父节点的大小关系,我们就

互换

两个节点。一直重复这个过程,直到父子节点之间满足刚说的那种大小关系。

数据结构与算法之美-10 堆 优先级队列 [MD]
数据结构与算法之美-10 堆 优先级队列 [MD]
public class Heap {
	private int[] a; // 数组,从下标1开始存储数据
	private int n;  // 堆可以存储的最大数据个数
	private int count; // 堆中已经存储的数据个数
	
	public Heap(int capacity) {
		a = new int[capacity + 1];
		n = capacity;
		count = 0;
	}
	
	public void insert(int data) {
		if (count >= n) return; // 堆满了
		++count;
		a[count] = data;
		int i = count;
		while (i / 2 > 0 && a[i] > a[i / 2]) { // 自下往上堆化
			swap(a, i, i / 2); // 交换元素
			i = i / 2;
		}
	}
}
           

堆顶元素存储的就是堆中数据的最大值或者最小值。

假设我们构造的是大顶堆,堆顶元素就是最大的元素。当我们删除堆顶元素之后,就

需要把第二大的元素放到堆顶

,那第二大元素肯定会出现在

左或右子节点

中。然后我们再

迭代

地删除第二大节点,以此类推,直到叶子节点被删除。

数据结构与算法之美-10 堆 优先级队列 [MD]

不过这种方法有点问题,就是最后堆化出来的堆并不满足

完全二叉树

的特性。

实际上,我们稍微改变一下思路,就可以解决这个问题。

我们

把最后一个节点放到堆顶

,然后利用同样的父子节点对比方法。对于不满足父子节点大小关系的,互换两个节点,并且重复进行这个过程,直到父子节点之间满足大小关系为止。这就是从上往下的堆化方法。

因为我们移除的是数组中的最后一个元素,而在堆化的过程中,都是

交换

操作,不会出现数组中的“空洞”,所以这种方法堆化之后的结果,肯定满足完全二叉树的特性。

数据结构与算法之美-10 堆 优先级队列 [MD]
public void removeMax() {
	if (count == 0) return -1; // 堆中没有数据
	a[1] = a[count];
	--count;
	heapify(a, count, 1);
}

private void heapify(int[] a, int n, int i) { // 自上往下堆化
	while (true) {
		int maxPos = i;
		if (i * 2 <= n && a[i] < a[i * 2]) maxPos = i * 2;
		if (i * 2 + 1 <= n && a[maxPos] < a[i * 2 + 1]) maxPos = i * 2 + 1;
		if (maxPos == i) break;
		swap(a, i, maxPos);
		i = maxPos;
	}
}
           

借助于堆这种数据结构实现的排序算法,就叫做

堆排序

这种排序方法的时间复杂度非常稳定,是

O(nlogn)

,并且它还是

原地排序算法

我们首先将数组

原地

建成一个

大顶堆

。所谓

原地

就是,不借助另一个数组,就在原数组上操作。

建堆的过程,有两种思路。

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

第二种实现思路,跟第一种截然相反

  • 第一种建堆思路的处理过程是,

    从前往后

    处理数组数据,并且每个数据插入堆中时,都是

    从下往上堆化

  • 而第二种实现思路是,

    从后往前

    处理数组,并且每个数据都是

    从上往下堆化

因为叶子节点往下堆化只能自己跟自己比较,所以我们直接从

最后一个非叶子节点

开始,依次堆化就行了。

下标为

n/2 + 1

n

的节点是

叶子节点

1

n/2

非叶子节点

n/2

最后一个非叶子节点

数据结构与算法之美-10 堆 优先级队列 [MD]
数据结构与算法之美-10 堆 优先级队列 [MD]

private static void buildHeap(int[] a, int n) {
	for (int i = n / 2; i >= 1; --i) {
		heapify(a, n, i); //循环堆化
	}
}

private static void heapify(int[] a, int n, int i) {
	while (true) {
		int maxPos = i; //找左右子节点的最大节点
		if (i * 2 <= n && a[i] < a[i * 2]) maxPos = i * 2;
		if (i * 2 + 1 <= n && a[maxPos] < a[i * 2 + 1]) maxPos = i * 2 + 1;
		if (maxPos == i) break; //当前结点比左右子节点都大,不需要再找了
		swap(a, i, maxPos); //【当前结点】和【左右子节点的最大节点】交换
		i = maxPos; //对【交换后的结点】继续进行上述操作
	}
}
           

堆排序的建堆过程的时间复杂度是

O(n)

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

每一层的节点个数和对应的高度如下图所示

数据结构与算法之美-10 堆 优先级队列 [MD]

将每一层的节点个数,乘以相应的高度,求和,就是算法时间复杂度:

数据结构与算法之美-10 堆 优先级队列 [MD]

把公式左右都乘以 2,就得到另一个公式 S2。我们将 S2 错位对齐,并且用 S2 减去 S1,可以得到 S:

数据结构与算法之美-10 堆 优先级队列 [MD]

S 的中间部分是一个等比数列,所以最后可以用等比数列的求和公式来计算:

数据结构与算法之美-10 堆 优先级队列 [MD]

因为

h = logn

,代入公式 S,就能得到

S = O(n)

,所以,建堆的时间复杂度就是

O(n)

建堆结束之后,数组中的数据已经是按照

大顶堆

的特性来组织的,数组中的第一个元素就是堆顶,也就是最大的元素。

  • 我们把

    堆顶元素

    最后一个元素

    交换,那最大元素就放到了下标为

    n

    的位置
  • 交换以后,我们将剩下的

    n−1

    个元素通过

    堆化

    的方法重新构建成

    大顶堆

  • 重新堆化完成之后,我们再将

    堆顶元素

    跟下标是

    n−1

    的元素交换
  • 重复这个过程,直到最后堆中只剩一个元素,排序工作就完成了

数据结构与算法之美-10 堆 优先级队列 [MD]
// n 表示数据的个数,数组 a 中的数据从下标 1 到 n 的位置
public static void sort(int[] a, int n) {
	buildHeap(a, n); //建大顶堆
	int k = n; //代表待排序元素总数
	while (k > 1) {
		swap(a, 1, k); //将堆顶元素和最后一个元素交换
		--k; //待排序元素总数减一
		heapify(a, k, 1); //将剩下的待排序元素通过堆化的方法,重新构建成大顶堆
	}
}
           

  • 空间复杂度:整个堆排序的过程,都只需要极个别临时存储空间,所以堆排序是

    原地排序算法

  • 时间复杂度:堆排序包括建堆和排序两个操作
    • 建堆过程的时间复杂度是

      O(n)

    • 排序过程的时间复杂度是

      O(nlogn)

    • 堆排序整体的时间复杂度是

      O(nlogn)

  • 稳定性:堆排序

    不是稳定的排序算法

    ,因为在排序的过程,存在

    将堆的最后一个节点跟堆顶节点互换

    的操作,所以就有可能改变值相同数据的原始相对顺序。

堆排序是一种原地的、时间复杂度为

O(nlogn)

的排序算法。快速排序平均情况下的时间复杂度也为

O(nlogn)

,甚至堆排序比快速排序的时间复杂度还要

稳定

。但是,在实际的软件开发中,快速排序的性能要比堆排序好,这是为什么呢?

主要有两方面的原因。

  • 第一点,堆排序

    数据的访问方式

    没有快速排序友好

对于快速排序来说,数据是

顺序访问

的。而对于堆排序来说,数据是

跳着访问

的。

堆排序中,最重要的一个操作就是数据的

堆化

,对堆顶节点进行堆化,会依次访问数组下标是 1,2,4,8 的元素,而不是像快速排序那样,局部顺序访问,这样对

CPU 缓存

是不友好的。

数据结构与算法之美-10 堆 优先级队列 [MD]
  • 第二点,对于同样的数据,在排序过程中,堆排序算法的数据

    交换次数

    要多于快速排序

对于基于比较的排序算法来说,整个排序过程就是由两个基本的操作组成的,比较和交换(或移动)。快速排序数据交换的次数不会比

逆序度

多。

但是堆排序的第一步是

建堆

,建堆的过程会打乱数据原有的相对先后顺序,导致原数据的有序度降低。比如,对于一组已经有序的数据来说,经过建堆之后,数据反而变得更无序了。

数据结构与算法之美-10 堆 优先级队列 [MD]

优先级队列首先应该是一个

队列

,队列最大的特性就是

先进先出

。但是,在优先级队列中,数据的出队顺序不是先进先出,而是按照优先级来,

优先级最高的,最先出队

实现一个优先级队列的方法有很多,但是用堆来实现是

最直接、最高效

的。这是因为,堆和优先级队列非常相似。

一个堆就可以看作一个优先级队列

。很多时候,它们只是概念上的区分而已。

  • 往优先级队列中

    插入

    一个元素,就相当于往堆中插入一个元素
  • 从优先级队列中

    取出

    优先级最高的元素,就相当于取出

    堆顶元素

优先级队列的应用场景非常多,后面要讲的很多数据结构和算法都要依赖它。比如,

赫夫曼编码

图的最短路径

最小生成树算法

等等。

很多语言中都提供了优先级队列的实现,比如,Java 的

PriorityQueue

,C++ 的 priority_queue 等。

假设我们有 k 个小文件,每个文件的大小是 100MB,每个文件中存储的都是

有序

的字符串。我们希望将这 k 个小文件合并成一个有序的大文件。

我们从这 k 个文件中,各取第一个字符串,放入

数组

中,然后比较大小,把最小的那个字符串放入合并后的大文件中,并从数组中删除。

假设,这个最小的字符串来自于

m.txt

这个小文件,我们就再从这个小文件取下一个字符串,放到数组中,

重新比较大小

,并且选择最小的放入合并后的大文件,将它从数组中删除。依次类推,直到所有的文件中的数据都放入到大文件为止。

时间复杂度分析

  • 假设每个小文件中有 n 个字符串,则需要遍历

    k * n

  • 每次遍历需要插入一个新元素,并对有序的 k 个字符串重新排序
    • 利用二分查找,查找插入位置时间复杂度为

      logk

    • 插入新元素并移动后面的元素位置时间复杂度为

      k

  • 整体时间复杂度为

    k * n * (logk + k)

    k^2 * n

首先,每次从各个文件中拿出第一个字符串,然后将这 k 个字符串组成一个小顶堆。此时堆顶元素,也就是优先级队列队首的元素,就是最小的字符串,我们将这个字符串放入到大文件中,并将其从堆中删除。

m.txt

这个小文件,我们就再从这个小文件取下一个字符串,放入到堆中。循环这个过程,就可以将 k 个小文件中的数据依次放入到大文件中。

  • k * n

  • 每次遍历需要往堆中插入一个新元素,并重新堆化,时间复杂度为常数

    logk

  • k * n * logk

    klogk * n

比原来数组存储的方式高效了一些,具体高效多少取决于 k 的大小。

假设我们有一个定时器,定时器中维护了很多

定时任务

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

针对这个问题,我们就可以用

优先级队列

来解决。我们按照任务设定的执行时间,将这些任务存储在优先级队列中,队列首部(也就是

小顶堆

的堆顶)存储的是最先执行的任务。

这样,定时器就不需要每隔 1 秒就扫描一遍任务列表了。它拿队首任务的执行时间点,与当前时间点相减,得到一个时间间隔 T。

这个时间间隔 T 就是,从当前时间开始,需要等待多久,才会有第一个任务需要被执行。这样,定时器就可以设定在 T 秒之后,再来执行任务。从当前时间点到(T-1)秒这段时间里,定时器都不需要做任何事情。

当有新的任务插入时,先重新堆化,如果堆顶元素有变化,更新下定时器下次的查询时间即可

当 T 秒时间过去之后,定时器取优先级队列中队首的任务执行。然后再计算新的队首任务的执行时间点与当前时间点的差值,把这个值作为定时器执行下一个任务需要等待的时间。

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

也就是说数据集合事先确定,不会再变。

  • 我们先从数组中取出前 k 个元素,利用这些元素维护一个大小为 K 的

    小顶堆

  • 然后顺序遍历数组,从数组中取出数据与堆顶元素比较
    • 如果比堆顶元素大,我们就把堆顶元素删除,并且将这个元素插入到堆中
    • 如果比堆顶元素小,则不做处理,继续遍历数组
  • 这样等数组中的数据都遍历完之后,堆中的数据就是前 K 大数据了

遍历数组需要

O(n)

的时间复杂度,一次堆化操作需要

O(logK)

的时间复杂度,整体时间复杂度就是

O(nlogK)

也就是说数据集合事先并不确定,有数据动态地加入到集合中。

实际上,我们可以一直都维护一个 K 大小的小顶堆,当有数据被添加到集合中时,我们就拿它与堆顶的元素对比。如果比堆顶元素大,我们就把堆顶元素删除,并且将这个元素插入到堆中;如果比堆顶元素小,则不做处理。这样,无论任何时候需要查询当前的前 K 大数据,我们都可以立刻返回给他。

中位数就是处在中间位置的那个数。

假设数据是从 0 开始编号的

  • 如果数据的个数是奇数,把数据从小到大排列,那第

    n/2 + 1

    个数据就是中位数
  • 如果数据的个数是偶数,那处于中间位置的数据有两个,第

    n/2

    个和第

    n/2 + 1

    个数据,这个时候,我们可以随意取一个作为中位数
数据结构与算法之美-10 堆 优先级队列 [MD]

对于一组静态数据,中位数是固定的,我们可以先排序,第

n/2

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

借助堆这种数据结构,我们不用排序,就可以非常高效地实现求中位数操作。

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

小顶堆中的数据都大于大顶堆中的数据

如果有 n 个数据,我们先从小到大排序,然后将前

n/2 + n%2

个数据存储在大顶堆中,后

n/2

个数据存储在小顶堆中。这样,

大顶堆中的堆顶元素

就是我们要找的

中位数

数据结构与算法之美-10 堆 优先级队列 [MD]

当新添加一个数据的时候,我们如何调整两个堆,让大顶堆中的堆顶元素继续是中位数呢?

  • 如果新加入的数据小于等于大顶堆的堆顶元素,我们就将这个新数据插入到大顶堆;否则,我们就将这个新数据插入到小顶堆。
  • 插入后,如果两个堆中的数据个数不符合前面的约定,我们可以

    将一个堆的堆顶元素移动到另一个堆中

数据结构与算法之美-10 堆 优先级队列 [MD]

于是,我们就可以利用一个大顶堆和一个小顶堆,实现在动态数据集合中求中位数的操作。

插入数据因为需要涉及堆化,所以时间复杂度为

O(logn)

,但是求中位数我们只需要返回大顶堆的堆顶元素就可以了,所以整体时间复杂度就是

O(logn)

利用两个堆不仅可以快速求出中位数,还可以快速求其他百分位的数据,原理是类似的。

中位数的概念就是将数据从小到大排列,处于中间位置,就叫中位数,这个数据会大于等于前面

50%

的数据。99 百分位数的概念可以类比中位数,如果将一组数据从小到大排列,这个 99 百分位数就是大于前面

99%

数据的那个数据。

数据结构与算法之美-10 堆 优先级队列 [MD]

如果有 n 个数据,将数据从小到大排列之后,99 百分位数大约就是第

n * 99%

个数据。

假设当前总数据的个数是 n,我们维护两个堆,一个大顶堆,一个小顶堆。大顶堆中保存

n*99%

个数据,小顶堆中保存

n*1%

大顶堆堆顶的数据

99%

响应时间。

每次插入一个数据的时候,我们要判断这个数据跟大顶堆和小顶堆堆顶数据的大小关系,然后决定插入到哪个堆中。如果这个新插入的数据比大顶堆的堆顶数据小,那就插入大顶堆,否则就插入小顶堆。

但是,为了保持大顶堆中的数据占

99%

,小顶堆中的数据占

1%

,在每次新插入数据之后,我们都要重新计算大顶堆和小顶堆中的数据个数是否还符合

99:1

这个比例。如果不符合,我们就

将一个堆的堆顶数据移动到另一个堆

,直到满足这个比例。

假设现在我们有一个包含 10 亿个搜索关键词的日志文件,如何快速获取到 Top 10 最热门的搜索关键词呢?

  • 因为用户搜索的关键词,有很多可能都是重复的,所以我们首先要统计每个搜索关键词出现的频率。我们可以通过

    散列表

    来记录关键词及其出现的次数。
  • 分片:10 亿条关键词太多,消耗的内存太大,需要先通过哈希算法分片到 10 个文件中
    • 我们先遍历这 10 亿个关键词,并且通过某个哈希算法对其求哈希值
    • 然后将哈希值同 10 取模,这样就可以将 10 亿条搜索关键词分片到 10 个文件中
    • 并且,相同的搜索关键词都会被分到同一个小文件中
  • 散列表:我们顺序扫描每个包含 1 亿条搜索关键词的文件,当扫描到某个关键词时,先去散列表中查询
    • 如果存在,我们就将对应的次数 +1
    • 如果不存在,我们就将它插入到散列表,并记录次数为 1
    • 遍历完后,散列表中就存储了不重复的搜索关键词以及出现的次数
  • 小顶堆:我们针对每个散列表,建立一个大小为 10 的小顶堆
    • 遍历散列表,依次取出每个搜索关键词及对应出现的次数,然后与堆顶的搜索关键词对比
    • 如果出现次数比堆顶搜索关键词的次数多,那就删除堆顶的关键词,将这个出现次数更多的关键词加入到堆中
    • 当遍历完整个散列表中的搜索关键词之后,堆中的搜索关键词就是当前散列表中出现次数最多的 Top 10 搜索关键词了
  • 小顶堆:把这个 10 个 Top 10 放在一块,然后取这 100 个关键词中的 Top 10 个关键词即可

2021-09-03

本文来自博客园,作者:白乾涛,转载请注明原文链接:https://www.cnblogs.com/baiqiantao/p/15224654.html

继续阅读