binary-heap（二叉堆）原理及C++代码实现

二叉堆可以看做一个近似的完全二叉树，所以一般用数组来组织。

二叉堆可以分为两种形式：最大堆和最小堆。最大堆顾名思义，它的每个结点的值不能超过其父结点的值，因此堆中最大元素存放在根结点中。最小堆的组织方式刚好与最大堆相反，它的最小元素存放在根结点中。

维护堆性质最重要的两个算法就是向上维护和向下维护。简而言之，例如最大堆中根结点的值小于其子结点的值，这个时候就要向下维护，把根结点逐级下降到适合的位置。显而易见地，向上维护就是子结点的值比其父结点大时（最大堆中），将结点逐级上升到合适的位置。这两个方法保证堆的性质不会被破坏。

堆经常用来实现优先队列，最大堆就对应最大优先队列，最小堆同上。因为通过关键字来查找堆中具体元素的位置比较麻烦，所以一般通过在堆中存储对象的句柄，在对应的对象中也存储对应堆元素的句柄来直接定位到元素的位置。

二叉堆是堆中最容易实现的一种，也算是用的比较广泛的一种。我下面的代码给出了最大堆和最小堆的一部分关键操作，另外一部分则挑选其中一种来实现。

代码如下：（仅供参考）

class Node {
public :
    int value;
public :
    Node(int v = 0) : value(v) {}
};

class Heap {
    vector<Node> heap;
    int heap_size;

    int Left(int i) {return (i << 1) + 1;}  //下标从0开始
    int Right(int i) {return Left(i) + 1;}
    int Parent(int i) {return (i - 1) >> 1;}
    void MaxHeapify(int i);  //使结点i维持最大堆性质(向下维护)
    void MinHeapify(int i);  //使结点i维持最小堆性质(向下维护)
    void IncreaseKey(int i, int k);  //将结点i的value上升到k(向上维护)
public :
    Heap() : heap_size(0) {}
    Heap(vector<Node> &t) : heap(t), heap_size(t.size()) {}
    void BuildMaxHeap();     //建立最大堆，时间复杂度O(n);
    void BuildMinHeap();     //建立最小堆，时间复杂度O(n);
    void MinHeapSort();     //从小到大排序，时间复杂度O(nlgn);
    void MaxHeapSort();     //从大到小排序，时间复杂度O(nlgn);
    //以下函数仅在最大堆下进行
    void Insert(int k); //插入一个元素（最大堆）
    void Delete(int i);    //删除一个元素（最大堆）
    Node Maximum();         //返回value最大的元素
    Node ExtractMax();     //去掉并返回value最大的元素
    //union two heap:union the vector of the two heaps, and call BuildMaxHeap()
    int Size() {return heap.size();} //返回vector的元素个数
    void PrintAll() {
        for (auto i : heap)
            cout << i.value << ends;
        cout << endl;
    }
};

void Heap::MaxHeapify(const int i) {
    int largest;
    if (Left(i) < heap_size && heap[Left(i)].value > heap[i].value)
        largest = Left(i);
    else
        largest = i;
    if (Right(i) < heap_size && heap[Right(i)].value > heap[largest].value)
        largest = Right(i);
    if (largest != i) {
        swap(heap[i], heap[largest]);
        MaxHeapify(largest);
    }
}

void Heap::MinHeapify(const int i) {
    int least;
    if (Left(i) < heap_size && heap[Left(i)].value < heap[i].value)
        least = Left(i);
    else
        least = i;
    if (Right(i) < heap_size && heap[Right(i)].value < heap[least].value)
        least = Right(i);
    if (least != i) {
        swap(heap[i], heap[least]);
        MinHeapify(least);
    }
}

void Heap::BuildMaxHeap() {
    heap_size = heap.size();
    for (int i = Parent(heap_size - 1); i >= 0; --i)
        MaxHeapify(i);
}

void Heap::BuildMinHeap() {
    heap_size = heap.size();
    for (int i = Parent(heap_size - 1); i >= 0; --i)
        MinHeapify(i);
}

void Heap::MinHeapSort() {
    BuildMaxHeap();
    for (int i = heap.size() - 1; i > 0; --i) {
        swap(heap[i], heap[0]);
        --heap_size;
        MaxHeapify(0);
    }
}

void Heap::MaxHeapSort() {
    BuildMinHeap();
    for (int i = heap.size() - 1; i > 0; --i) {
        swap(heap[i], heap[0]);
        --heap_size;
        MinHeapify(0);
    }
}

void Heap::Insert(int k) {
    heap.push_back(INT_MIN);
    IncreaseKey(heap.size() - 1, k);
}

void Heap::Delete(int i) {
    if (heap[heap.size() - 1].value > heap[i].value) {
        IncreaseKey(i, heap[heap.size() - 1].value);
        heap.pop_back();
    } else {
        heap[i] = heap[heap.size() - 1];
        heap.pop_back();
        heap_size = heap.size();
        MaxHeapify(i);
    }
}

Node Heap::Maximum() {
    return heap[0];
}

Node Heap::ExtractMax() {
    Node max = heap[0];
    heap[0] = heap[heap.size() - 1];
    heap.pop_back();
    MaxHeapify(0);
    return max;
}

void Heap::IncreaseKey(int i, int k) {
    if (k <= heap[i].value)
        return ;
    while (i > 0 && heap[Parent(i)].value < k) {
        heap[i] = heap[Parent(i)];
        i = Parent(i);
    }
    heap[i].value = k;
}