大(小)根堆：优先队列的基石

大(小)根堆：优先队列的基石

堆（Heap）是一种特殊的树形数据结构，具有许多应用，其中之一是优先队列。大根堆（Max Heap）是堆的一种形式，具有许多独特的特性，使其在许多算法和数据结构中发挥着关键作用。

概述

大根堆是一种完全二叉树，其中每个节点的值都大于或等于其子节点的值。堆总是一棵完全二叉树，这意味着除了最底层，其他所有层都被完全填满，且最底层的节点从左向右连续排列。

结构

大根堆通常是通过数组来实现的，数组中的元素按照树的层序遍历顺序排列。具体来说，对于任意节点的索引 i，其左子节点、右子节点、父节点的索引分别为：
$$index=\{\begin{array}{r}2\ast i+1(左子节点)\\ 2\ast i+2(右子节点)\\ (i-1)/2(父节点)\end{array}$$

功能

大根堆支持以下基本操作：

• 插入：将新元素插入到堆中，并保持堆的性质。
• 提取最大值：从堆中移除并返回最大值（根节点），然后重新组织堆以保持其性质。
• 堆化：从一个任意的数组构建一个大根堆。

这些操作通常在对数时间内完成，使得大根堆成为高效地查找最大值的数据结构。

应用

大根堆在计算机科学中有许多重要的应用，包括但不限于：

• 优先队列：大根堆可以用作优先队列的实现，其中最大值可以很容易地被访问和删除。优先队列在任务调度、图算法等领域有广泛应用。
• 堆排序：堆排序是一种高效的排序算法，它利用大根堆的特性进行排序。堆排序是不稳定的排序算法，但具有原地排序和 O(n log n) 时间复杂度的特点。
• 中位数查找：利用大根堆和小根堆可以在常数时间内查找一组数据的中位数，这在统计学和数据处理中很常见。

C++ 实现大根堆

类定义

下面以 int 型为例，通用型应使用 template 实现

#ifndef MAXHEAP_H
#define MAXHEAP_H

#include <vector>

class MaxHeap 
{
private:
    std::vector<int> heap; 			// 保存大根堆的数组

    void heapifyUp(int index);		// 将指定索引的节点向上调整，使得堆重新满足大根堆的性质

    void heapifyDown(int index);	// 将指定索引的节点向下调整，使得堆重新满足大根堆的性质

public: 
    void insert(int value);			// 向大根堆中插入一个新元素

    int extractMax();				// 从大根堆中提取并返回最大值（根节点）
    
    bool isEmpty();					// 大根堆是否为空
};

#endif // MAXHEAP_H

类实现

#include "MaxHeap.h"

// 将指定索引的节点向上调整，使得堆重新满足大根堆的性质
void MaxHeap::heapifyUp(int index) 
{
    int parent = (index - 1) / 2;
    while (index > 0 && heap[parent] < heap[index]) 
    {
        std::swap(heap[parent], heap[index]);
        index = parent;
        parent = (index - 1) / 2;
    }
}

// 将指定索引的节点向下调整，使得堆重新满足大根堆的性质
void MaxHeap::heapifyDown(int index) 
{
    int leftChild = index * 2 + 1;
    int rightChild = index * 2 + 2;
    int largest = index;

    if (leftChild < heap.size() && heap[leftChild] > heap[largest]) 
    {
        largest = leftChild;
    }
    if (rightChild < heap.size() && heap[rightChild] > heap[largest]) 
    {
        largest = rightChild;
    }

    if (largest != index) 
    {
        std::swap(heap[index], heap[largest]);
        heapifyDown(largest);		// 继续向下调整
    }
    
    // 如果该元素大于左右子节点、不再需要额外的操作，直接结束函数
}

// 向大根堆中插入一个新元素
void MaxHeap::insert(int value) 
{
    heap.push_back(value);
    heapifyUp(heap.size() - 1);
}

// 从大根堆中提取并返回最大值（根节点）
// 如果堆为空，则返回一个特定的值（这里为 -1）
int MaxHeap::extractMax() 
{
    if (heap.empty()) 
    {
        return -1; // 堆为空，返回一个特定的值
    }

    int maxValue = heap.front();
    heap[0] = heap.back();
    heap.pop_back();
    heapifyDown(0);

    return maxValue;
}

// 检查大根堆是否为空
bool MaxHeap::isEmpty() 
{
    return heap.empty();
}

例子：C++堆排序

// 下沉操作
void heapifyDown(std::vector<int>& arr, int index, int size) 
{
    int largest = index;
    int leftChild = 2 * index + 1;
    int rightChild = 2 * index + 2;

    if (leftChild < size && arr[leftChild] > arr[largest]) 
    {
        largest = leftChild;
    }

    if (rightChild < size && arr[rightChild] > arr[largest]) 
    {
        largest = rightChild;
    }

    if (largest != index) 
    {
        std::swap(arr[index], arr[largest]);
        heapifyDown(arr, largest, size);
    }
}

// 堆排序
void heapSort(std::vector<int>& arr) 
{
    int size = arr.size();

    // 建堆，从最后一个非叶子节点开始进行下沉操作
    for (int i = size / 2 - 1; i >= 0; --i) 
    {
        heapifyDown(arr, i, size);
    }

    // 不断提取最大值，并进行堆调整，直到堆为空
    for (int i = size - 1; i > 0; --i) 
    {
        std::swap(arr[0], arr[i]);
        heapifyDown(arr, 0, i);
    }
}

总结

大根堆是一种重要的数据结构，具有许多有用的性质和应用。它不仅可以用作优先队列的基础，还可以用于高效的排序和中位数查找等问题。了解大根堆的基本概念和操作，有助于我们更好地理解和应用这个强大的数据结构。