14：堆和堆排序

堆Heap==》堆排序：原地、O(nlogn)

堆==》堆是一个完全二叉树；堆中每一个节点的值都必须大于等于（或小于等于）其子树中每个节点的值==》大顶堆（小顶堆）

实现一个堆==》完全二叉树比较适合用数组来存储

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

往堆中插入一个元素==》heapify  堆化==》顺着节点所在的路径，向上或者向下，对比，然后交换

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

堆排序=建堆+排序

1、建堆==》将数组原地建成一个堆。“原地”就是不借助另一个数组，就在原数组上操作

思路一-->在堆中插入一个元素的思路：假设起初堆中只包含一个数据，就是下标为1的数据。然后调用插入操作，将下标从2到n的数据依次插入到堆中。这样就将包含n个数据的数组，组织成了堆

建堆是从前往后处理数组数据，在每个数据插入堆中时，从下往上堆化

思路二-->从后往前处理数组，每个数据都是从上往下堆化

private static void buildHeap(int[] a, int n) {
    //对下标从n/2开始到1的数据进行堆化，下标是n/2+1到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 成正比。

2、排序

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

//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)。

那如果从 0 开始存储，实际上处理思路是没有任何变化的，唯一变化的，可能就是，代码实现的时候，计算子节点和父节点的下标的公式改变了。如果节点的下标是 i，那左子节点的下标就是 2∗i+1，右子节点的下标就是 2∗i+2，父节点的下标就是 (i−1)/2​。

堆排序为什么没有快速排序快？==》

堆排序数据访问的方式没有快速排序友好==》对于快速排序来说，数据是顺序访问的。而对于堆排序来说，数据是跳着访问的。对CPU缓存是不友好的

对于同样的数据，在排序过程中，堆排序算法的数据交换次数要多于快速排序==》快速排序数据交换的次数不会比逆序度多。但是堆排序的第一步是建堆，建堆的过程会打乱数据原有的相对先后顺序，导致原数据的有序度降低。

=================================

堆的应用==》优先级队列、top k、中位数

快速获取到TOP10最热门的搜索关键词==>分片+散列表+堆

 

优先级队列==》Java的PriorityQueue

合并有序小文件==》假设我们有 100 个小文件，每个文件的大小是 100MB，每个文件中存储的都是有序的字符串。我们希望将这些 100 个小文件合并成一个有序的大文件。

高性能定时器

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

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

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

求中位数==》求动态数据集合中的中位数。需要维护两个堆，一个大顶堆，一个小顶堆。大顶堆中存储前半部分数据，小顶堆中存储后半部分数据，且小顶堆中的数据都大于大顶堆中的数据。如果有 n 个数据，n 是偶数，从小到大排序，那前 n/2​ 个数据存储在大顶堆中，后 n/2​ 个数据存储在小顶堆中。这样，大顶堆中的堆顶元素就是要找的中位数。如果 n 是奇数，情况是类似的，大顶堆就存储 n/2​+1 个数据，小顶堆中就存储 n/2​ 个数据。