数据结构与算法系列19--堆

什么是堆(Heap)

堆其实就是一种特殊的树，那它特殊在哪里呢？只要满足了以下两点的，我们就可以称之为堆。
1.堆是一个完全二叉树
2.堆中每一个节点的值都必须大于等于（或者小于等于）其子树中每个节点的值。
这里稍作解释，对于第一点，我们前面讲过，完全二叉树就是除了最后一层，其他层的节点个数都是满的，最后一层的节点都靠左排列。
对于第二点，其实我们可以换一种说法，堆中每一个节点的值都必须大于等于（或者小于等于）其左右子节点的值。对于堆中每一个节点的值都大于等于子树中每一个节点值的堆，我们叫做 “大顶堆”，对于堆中每一个节点的值都小于等于子树中每一个节点值的堆，我们叫做 “小顶堆”。

如何储存堆

前面我们说过，完全二叉树适合使用数组来储存，用数组来储存可以非常的节省储存空间，因为我们不用像使用链表那样，需要储存左右子节点的指针，单纯的通过数组的下标，就可以找到一个节点的左右子节点和父节点。下面这张图是用数组储存堆的一个例子，可以看下（图片来自极客时间《数据结构与算法之美》）

从图中我们可以看到，下标为i的节点的左子节点，就是下标为i2的节点，右子节点就是下标为i2+1的节点，父节点就是下标为i/2的节点。

堆的一些操作

1.插入一个元素
插入一个元素后，我们仍然必须满足堆的两个特性，所以要想插入一个元素，我们必须先查找到一个合适的位置再给它插入，这样也就需要不断调整，让其满足堆的特性，这个进行调整的过程，我们叫做堆化(heapify)
堆化的过程是这样的，我们顺着节点所在的路径，向上或者向下，对比，然后交换。例如：我们可以让新插入的节点与父节点对比大小，如果不满足子节点小于等于父节点的大小关系，我们就互换两个节点。一直重复这个过程，直到父子节点之间满足刚才说的那种大小关系。（这里以大顶堆作为例子）
结合着代码看下：

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); // swap() 函数作用：交换下标为 i 和 i/2 的两个元素
      i = i/2;
    }
  }
 }

2.删除堆顶元素
从堆的定义的第二条中，任何节点的值都大于等于（或小于等于）子树节点的值，我们可以发现，堆顶元素存储的就是堆中数据的最大值或者最小值。
具体怎么做呢？
我们把最后一个节点放到堆顶，然后利用同样的父子节点对比方法。对于不满足父子节点大小关系的，互换两个节点，并且重复进行这个过程，直到父子节点之间满足大小关系为止。
因为我们移除的是数组中的最后一个元素，而在堆化的过程中，都是交换操作，不会出现数组中的“空洞”，所以这种方法堆化之后的结果，肯定满足完全二叉树的特性。
代码实例：

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;
  }
}

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

基于堆实现排序

所谓的堆排序，就是我们借助于堆这种数据结构实现的排序算法，就叫作堆排序。这种排序方法的时间复杂度非常稳定，是O(nlogn)（和快排一样），并且它还是原地排序算法。
假设现在我们有一个大顶堆，数组中的第一个元素就是堆顶，也就是最大的元素。我们把它跟最后一个元素交换，那最大元素就放到了下标为n的位置。
这个过程有点类似上面讲的“删除堆顶元素”的操作，当堆顶元素移除之后，我们把下标为n的元素放到堆顶，然后再通过堆化的方法，将剩下的n−1个元素重新构建成堆。堆化完成之后，我们再取堆顶的元素，放到下标是n−1的位置，一直重复这个过程，直到最后堆中只剩下标为1的一个元素，排序工作就完成了。
实例代码：

// 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)。
堆排序不是稳定的排序算法，因为在排序的过程，存在将堆的最后一个节点跟堆顶节点互换的操作，所以就有可能改变值相同数据的原始相对顺序。

堆的应用

堆排序（这个我们上面讲过），优先级队列，求TopK，求中位数。

应用一：优先级队列

优先级队列它本身是一个队列，我们知道队列的特性就是先进先出，但是对于优先级队列，数据的出队顺序并不是先进先出，而是安装优先级来的，优先级高的，最先出队。
实现优先级队列的方法有很多，但是用堆来实现最直接，最高效。这是因为堆和优先级队列很相似，一个堆可以看作一个优先级队列。往优先级队列中插入一个元素，就相当于往堆中插入一个元素；从优先级队列中取出优先级最高的元素，就相当于取出堆顶元素。
例1合并有序小文件：
假设我们有100个小文件，每个文件的大小是100MB，每个文件中存储的都是有序的字符串。我们希望将这些100个小文件合并成一个有序的大文件。这里就会用到优先级队列，也可以说是堆。将从小文件中取出来的字符串放入到小顶堆中，那堆顶的元素，也就是优先级队列队首的元素，就是最小的字符串。我们将这个字符串放入到大文件中，并将其从堆中删除。然后再从小文件中取出下一个字符串，放入到堆中。循环这个过程，就可以将100个小文件中的数据依次放入到大文件中。
删除堆顶数据和往堆中插入数据的时间复杂度都是O(logn)，n表示堆中的数据个数，这里就是100。
例2高性能定时器：
假设我们有一个定时器，定时器中维护了很多定时任务，每个任务都设定了一个要触发执行的时间点。定时器每过一个很小的单位时间（比如1秒），就扫描一遍任务，看是否有任务到达设定的执行时间。如果到达了，就拿出来执行。但是这种每过1秒就扫描一遍任务列表的做法比较低效，主要原因有两点：第一，任务的约定执行时间离当前时间可能还有很久，这样前面很多次扫描其实都是徒劳的；第二，每次都要扫描整个任务列表，如果任务列表很大的话，势必会比较耗时。
看看如何用优先级队列来解决，按照任务设定的执行时间，将这些任务存储在优先级队列中，队列首部（也就是小顶堆的堆顶）存储的是最先执行的任务。这样就不用每隔1s去扫描了，拿到队首任务的执行时间与当前的时间点相减，得到一个时间间隔T。这个时间间隔T就是从当前时间开始，需要等待多久，才会有第一个任务需要被执行。这样我们的定时器就可以设定在T秒后再来执行这个任务，而不需要每隔一秒去扫描，整体性能就提高了。

应用二：求TOP K问题

求TOP K问题可以分为两类，一种是针对静态数据集合，一种是针对动态数据集合。
针对静态数据集合，如何在一个包含n个数据的数组中，查找前K大数据呢？
可以通过维护一个大小为K的小顶堆，顺序遍历数组，从数组中取出取数据与堆顶元素比较。如果比堆顶元素大，我们就把堆顶元素删除，并且将这个元素插入到堆中；如果比堆顶元素小，则不做处理，继续遍历数组。这样等数组中的数据都遍历完之后，堆中的数据就是前K大数据了。
遍历数组需要O(n)的时间复杂度，一次堆化操作需要O(logK)的时间复杂度，所以最坏情况下，n个元素都入堆一次，所以时间复杂度就是O(nlogK)。
针对动态数据集合，我们可以一直都维护一个K大小的小顶堆，当有数据被添加到集合中时，我们就拿它与堆顶的元素对比。如果比堆顶元素大，我们就把堆顶元素删除，并且将这个元素插入到堆中；如果比堆顶元素小，则不做处理。这样，无论任何时候需要查询当前的前K大数据，我们都可以里立刻返回给他。

应用三：求中位数

如何求动态数据集合中的中位数？
针对动态数据集合，中位数在不停地变动，如果采用先排序的方法，每次询问中位数的时候，都要先进行排序，那效率就不高了。
事实上，借助堆这种数据结构，我们不用排序，就可以非常高效地实现求中位数操作。具体如何做呢？
我们需要维护两个堆，一个大顶堆，一个小顶堆。大顶堆中存储前半部分数据，小顶堆中存储后半部分数据，且小顶堆中的数据都大于大顶堆中的数据。这样，大顶堆中的堆顶元素就是我们要找的中位数。
那当新添加一个数据的时候，我们如何调整两个堆，让大顶堆中的堆顶元素继续是中位数呢？
如果新加入的数据小于等于大顶堆的堆顶元素，我们就将这个新数据插入到大顶堆；否则插入小顶堆中。
但是这样就有可能出现，两个堆中的数据个数不符合前面约定的情况，那怎样解决呢？我们可以从一个堆中不停地将堆顶元素移动到另一个堆，通过这样的调整，来让两个堆中的数据满足上面的约定。
插入数据因为需要涉及堆化，所以时间复杂度变成了O(logn)，但是求中位数我们只需要返回大顶堆的堆顶元素就可以了，所以时间复杂度就是O(1)。