[数据结构]-堆

总结整理自 数据结构与算法之美

什么是堆

堆是一种特殊的树，只要满足这两点，就是一个堆。

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

第一点：完全二叉树要求，除了最后一层，其他层的节点个数都是满的，且最后一层的节点都靠左排列。
第二点：对于每个节点的值都大于等于子树中每个节点值的堆，我们叫作大顶堆。对于每个节点的值都小于等于子树中每个节点值的堆，我们叫作小顶堆。

如何实现一个堆

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

由于完全二叉树比较适合用数组来存储。用数组来存储完全二叉树是非常节省存储空间的。因为我们不需要存储左右子节点的指针，单纯地通过数组的下标，就可以找到一个节点的左右子节点和父节点。
如下图所示:

数组中下标为i的节点的左子节点，就是下标为$i\ast 2$的节点，右子节点就是下标为$i\ast 2+1$的节点，父节点就是下标为$\frac{x}{2}$

---

知道了如何存储一个堆，那再来看看堆上的操作有哪些？

1.往堆中插入一个元素

往堆中插入一个元素后，我们需要继续满足堆的两个特性。
如果我们把新插入的元素放到堆的最后，如果不满足特性就要进行调整，这个过程我们起名为堆化

堆化实际上有两种，从下往上和从上往下。这里先讲从下往上的堆化方法。

堆化就是顺着节点所在的路径，向上或者向下，对比，然后交换。如下图所示交换过程

翻译成代码

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个节点的完全二叉树，树的高度不会超过$lo{g}_{2}n$。堆化的过程是顺着节点所在路径比较交换的，所以堆化的时间复杂度跟树的高度成正比，也就是O($lo{g}_{2}n$)。插入数据和删除堆顶元素的主要逻辑就是堆化，所以时间复杂度都是O($lo{g}_{2}n$)。

堆排序

堆排序的过程大致分解成两个大的步骤，建堆和排序。

1.建堆

从后往前处理数组，并且每个数组都是从上往下堆化。如图所示，因为叶子节点往下堆化只能自己跟自己比较，所以我们直接从第一个非叶子节点开始，依次堆化就行了。


代码如下:

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

由于下标是$\frac{n}{2}+1$到$n$的节点是叶子节点，我们不需要堆化，所以只需要对下标从$\frac{n}{2}$开始到1的数据进行堆化。实际上，对于完全二叉树来说，下标从$\frac{n}{2}+1$到$n$的节点都是叶子节点

我们来看看建堆的时间复杂度是多少呢？
每个节点堆化的时间复杂度是O($logn$)，那$\frac{n}{2}+1$个节点堆化的总时间复杂度是不是就是O(nlogn)呢？这个答案虽然也没错，但是这个值还是不够精确。实际上，堆排序的建堆过程的时间复杂度是O(n)。下面来推导一下
因为叶子节点不需要堆化，所以需要堆化的节点从倒数第二层开始。每个节点堆化的过程中，需要比较和交换的节点个数，跟这个节点的高度k成正比。所以我们只需要将每个节点的高度求和，得出的就是建堆的时间复杂度。

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

利用错位相减法来解决

$S$的中间部分是一个等比数列，所以最后可以用等比数列的求和公式来计算，最终的结果就是下图:

因为$h=lo{g}_{2}n$，代入公式$S$，就能得到$S=O(n)$，所以，建堆的时间复杂度就是$O(n)$。

2.排序

建堆结束之后，数组中数据已经是按照大顶堆的特性来组织的。数组中第一个元素就是堆顶，也就是最大元素。我们把它跟最后一个元素交换，那最大元素就放到了下标为$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)$。
堆排序不是稳定的排序算法，因为在排序的过程，存在将堆得最后一个节点跟堆顶节点互换的操作，所以就有可能改变值相同数据的原始相对顺序。

注:上面讲的堆中数据是从数组下标为1的位置开始存储。那如果从0开始存储，如果节点的下标为i,那左子节点的下标就是$2\ast i+1$，右子节点的下标就是$2\ast i+2$,父节点的下标就是$\frac{i-1}{2}$。

---

PS:实际开发中，快速排序要比堆排序性能好。

• 第一点，堆排序数据访问的方式没有快速排序友好。
  对于快速排序来说，数据是顺序访问的。而对于堆排序来说，数据是跳着访问的。这样对CPU缓存是不友好的。
• 第二点，对于同样的数据，在排序过程中，堆排序算法的数据交换次数要多于快速排序。
  根据有序度和逆序度进行比较后，由于堆排序会打乱数据原有相对先后顺序，导致原数据的有序度降低