二叉堆的解读

二叉堆

目录

• 二叉堆
  • 1、思考
  • 2、堆（Heap）
  • 3、堆的基本接口设计
  • 4、二叉堆
  • 5、获取最大值
  • 6、最大堆——添加
    • 6.1、总结
    • 6.2、最大堆——添加——交换位置的优化
  • 7、最大堆——删除
    • 7.1、最大堆——删除——总结
  • 8、replace
  • 9、最大堆——批量建堆（Heapify）
    • 9.1、最大堆 – 批量建堆 – 自上而下的上滤
    • 9.2、最大堆 – 批量建堆 – 自下而上的下滤
    • 9.3、最大堆 – 批量建堆 – 效率对比
    • 9.4、批量建堆
  • 10、Top K问题

1、思考

• 设计一种数据结构，用来存放整数，要求提供 3 个接口
  • 添加元素
  • 获取最大值
  • 删除最大值
• 有没有更优的数据结构？
  • 堆
    • 获取最大值：O(1)、删除最大值：O(logn)、添加元素：O(logn)

2、堆（Heap）

• 堆（Heap）也是一种树状的数据结构（不要跟内存模型中的“堆空间”混淆），常见的堆实现有
  • 二叉堆（Binary Heap，完全二叉堆）
  • 多叉堆（D-heap、D-ary Heap）
  • 索引堆（Index Heap）
  • 二项堆（Binomial Heap）
  • 斐波那契堆（Fibonacci Heap）
  • 左倾堆（Leftist Heap，左式堆）
  • 斜堆（Skew Heap）
• 堆的一个重要性质：任意节点的值总是 ≥（ ≤ ）子节点的值
  • 如果任意节点的值总是 ≥ 子节点的值，称为：最大堆、大根堆、大顶堆
  • 如果任意节点的值总是 ≤ 子节点的值，称为：最小堆、小根堆、小顶堆
• 由此可见，堆中的元素必须具备可比较性（跟二叉搜索树一样）

3、堆的基本接口设计

• int size(); // 元素的数量
• boolean isEmpty(); // 是否为空
• void clear(); // 清空
• void add(E element); // 添加元素
• E get(); // 获得堆顶元素
• E remove(); // 删除堆顶元素
• E replace(E element); // 删除堆顶元素的同时插入一个新元素

4、二叉堆

• 二叉堆的逻辑结构就是一棵完全二叉树，所以也叫完全二叉堆

• 鉴于完全二叉树的一些特性，二叉堆的底层（物理结构）一般用数组实现即可

• 索引 i 的规律（ n 是元素数量）

  • 如果 i = 0 ，它是根节点

  • 如果 i > 0 ，它的父节点的索引为 floor( (i – 1) / 2 )

  • 如果 2i + 1 ≤ n – 1，它的左子节点的索引为 2i + 1

  • 如果 2i + 1 > n – 1 ，它无左子节点

  • 如果 2i + 2 ≤ n – 1 ，它的右子节点的索引为 2i + 2

  • 如果 2i + 2 > n – 1 ，它无右子节点

5、获取最大值

private void emptyCheck() {
    if (size == 0) {
        throw new IndexOutOfBoundsException("Heap is empty");
    }
}

@Override
public E get() {
    emptyCheck();
    return elements[0];
}

6、最大堆——添加

6.1、总结

• 循环执行以下操作（图中的 80 简称为 node）
  • 如果 node ＞ 父节点
    • 与父节点交换位置
  • 如果 node ≤ 父节点，或者 node 没有父节点
    • 退出循环
• 这个过程，叫做上滤（Sift Up）
  • 时间复杂度：O(logn)

@Override
public void add(E element) {
    elementNotNullCheck(element);
    ensureCapacity(size + 1);
    elements[size++] = element;
    siftUp(size - 1);
}

/**
 * 让index位置的元素上滤
 */
private void siftUp(int index) {
    E element = elements[index];
    while (index > 0) {
        // 父节点索引 = (子节点索引-1) / 2
        int parentIndex = (index - 1) >> 1;
        E parent = elements[parentIndex];
        if (compare(element, parent) <= 0) break;

        // 将父元素存储在index位置
        elements[index] = parent;

        // 重新赋值index
        index = parentIndex;
    }
    elements[index] = element;
}

6.2、最大堆——添加——交换位置的优化

• 一般交换位置需要3行代码，可以进一步优化
  • 将新添加节点备份，确定最终位置才摆放上去
• 仅从交换位置的代码角度看
  • 可以由大概的 3 * O(logn) 优化到 1 * O(logn) + 1

7、最大堆——删除

7.1、最大堆——删除——总结

1. 用最后一个节点覆盖根节点
2. 删除最后一个节点
3. 循环执行以下操作（图中的 43 简称为 node）
   • 如果 node < 最大的子节点
     • 与最大的子节点交换位置
   • 如果 node ≥ 最大的子节点， 或者 node 没有子节点
     • 退出循环
4. 这个过程，叫做下滤（Sift Down），时间复杂度：O(logn)
5. 同样的，交换位置的操作可以像添加那样进行优化

/**
 * 删除堆顶元素
 */
public E remove() {
    emptyCheck();

    int lastIndex = --size;
    E root = elements[0];
    elements[0] = elements[lastIndex];
    elements[lastIndex] = null;

    siftDown(0);
    return root;
}

/**
 * 让index位置的元素下滤
 * @param index
 */
private void siftDown(int index) {
    E element = elements[index];
    int half = size >> 1; // 非叶子节点的数量
    // 第一个叶子节点的索引 == 非叶子节点的数量
    // index < 第一个叶子节点的索引
    // 必须保证index位置是非叶子节点
    while (index < half) {
        // index的节点有2种情况
        // 1.只有左子节点
        // 2.同时有左右子节点

        // 默认为左子节点跟它进行比较
        int childIndex = (index << 1) + 1;
        E child = elements[childIndex];

        // 右子节点
        int rightIndex = childIndex + 1;

        // 选出左右子节点最大的那个
        if (rightIndex < size && compare(elements[rightIndex], child) > 0) {
            child = elements[childIndex = rightIndex];
        }

        if (compare(element, child) >= 0) break;

        // 将子节点存放到index位置
        elements[index] = child;
        // 重新设置index
        index = childIndex;
    }
    elements[index] = element;
}

8、replace

@Override
public E replace(E element) {
    elementNotNullCheck(element);

    E root = null;
    if (size == 0) {
        elements[0] = element;
        size++;
    } else {
        root = elements[0];
        elements[0] = element;
        siftDown(0);
    }
    return root;
}

9、最大堆——批量建堆（Heapify）

• 批量建堆，有 2 种做法
  • 自上而下的上滤
  • 自下而上的下滤

9.1、最大堆 – 批量建堆 – 自上而下的上滤

for(int i = 1; i < size; i++){
	siftUp(i);
}

9.2、最大堆 – 批量建堆 – 自下而上的下滤

for(int i = (size >> 1) - 1; i >= 0; i--){
	siftDown(i);
}

9.3、最大堆 – 批量建堆 – 效率对比

• 所有节点的深度之和
  • 仅仅是叶子节点，就有近 n/2 个，而且每一个叶子节点的深度都是 O(logn) 级别的
  • 因此，在叶子节点这一块，就达到了 O(nlogn) 级别
  • O(nlogn) 的时间复杂度足以利用排序算法对所有节点进行全排序
• 所有节点的高度之和
  • 假设是满树，节点总个数为 n，树高为 h，那么 n = 2 h − 1
  • 所有节点的树高之和 H(n) = 2 0 ∗ h − 0 + 2 1 ∗ h − 1 + 2 2 ∗ h − 2 + ⋯ + 2 h −1 ∗ h − h − 1)]
  • H(n) = h ∗ 2 0 + 2 1 + 2 2 + ⋯ + 2 h −1 − 1 ∗ 2 1 + 2 ∗ 2 2 + 3 ∗ 2 3 + ⋯ + h − 1 ∗ 2 h−1]
  • H(n) = h ∗ 2 h − 1 − h − 2 ∗ 2 h + 2]
  • H(n) = h ∗ 2 h − h − h ∗ 2 h + 2 h+1 − 2
  • H(n) = 2 h+1 − h − 2 = 2 ∗ (2 h − 1) − h = 2n − h = 2n − log2(n + 1) = O(n)

公式推导

• S(h) = 1 ∗ 2 1 + 2 ∗ 2 2 + 3 ∗ 2 3 + ⋯ + h − 2 ∗ 2 h−2 + h − 1 ∗ 2 h−1
• 2S(h) = 1 ∗ 2 2 + 2 ∗ 2 3 + 3 ∗ 2 4 + ⋯ + h − 2 ∗ 2 h−1 + h − 1 ∗ 2 h
• S(h) – 2S(h) = [2 1 + 2 2 + 2 3 + ⋯ + 2 h−1 ] − h − 1 ∗ 2 h = (2 h − 2) − h − 1 ∗ 2 h
• S(h) = h − 1 ∗ 2 h − (2 h − 2) = h − 2 ∗ 2 h + 2

9.4、批量建堆

public BinaryHeap(E[] elements, Comparator<E> comparator)  {
    super(comparator);

    if (elements == null || elements.length == 0) {
        this.elements = (E[]) new Object[DEFAULT_CAPACITY];
    } else {
        size = elements.length;
        int capacity = Math.max(elements.length, DEFAULT_CAPACITY);
        this.elements = (E[]) new Object[capacity];
        for (int i = 0; i < elements.length; i++) {
            this.elements[i] = elements[i];
        }
        heapify();
    }
}

/**
 * 批量建堆
 */
private void heapify() {
    // 自上而下的上滤
//		for (int i = 1; i < size; i++) {
//			siftUp(i);
//		}

    // 自下而上的下滤
    for (int i = (size >> 1) - 1; i >= 0; i--) {
        siftDown(i);
    }
}

10、Top K问题

• 从 n 个整数中，找出最大的前 k 个数（ k 远远小于 n ）
• 如果使用排序算法进行全排序，需要 O(nlogn) 的时间复杂度
• 如果使用二叉堆来解决，可以使用 O(nlogk) 的时间复杂度来解决
  • 新建一个小顶堆
  • 扫描 n 个整数
    • 先将遍历到的前 k 个数放入堆中
    • 从第 k + 1 个数开始，如果大于堆顶元素，就使用 replace 操作（删除堆顶元素，将第 k + 1 个数添加到堆中）
  • 扫描完毕后，堆中剩下的就是最大的前 k 个数
• 如果是找出最小的前 k 个数呢？
  • 用大顶堆
  • 如果小于堆顶元素，就使用 replace 操作