优先队列和二叉堆

优先队列是一种常用的ADT，其中的元素有序排列，入队的元素会插入到正确的位置，队首元素始终为最小(大)值，队首出队后优先队列仍然保持原来的性质。

这里我们规定优先队列以升序排列。

优先队列提供的接口包括：

• insert 插入元素
• top 得到队首元素
• pop 删除队首元素

二叉堆是优先队列一种常用的实现，二叉堆是一种完全二叉树，完全二叉树除最低一层外其它层均被填满，最低一层的节点全部集中在左侧。完全二叉树的性质决定它可以很容易地由二叉数组来实现。

二叉堆满足堆序性，即任意一个节点X的父节点不大于X(最小堆)。由堆序性可知，二叉堆的根节点一定为最小值或最大值，根节点为最小值的堆称为最小堆，根节点为最大值的堆称为最大堆。

最小堆类的声明：

template<typename val_t>
class MinHeap {
protected:
    const static size_t capcity = 10000;
    size_t size;
    val_t vec[capcity];
public:
    MinHeap();
    void insert(val_t val);
    bool empty();
    void rmMin();
    val_t getMin() {
        return vec[1];
    };
    ~MinHeap() = default;
};

插入元素

插入元素采用上滤的方法:

(1)在数组超出末端(size位置)创建一个空穴

(2)比较新元素与空穴父节点的大小，若新元素较大则将原父节点填入空穴，原父节点的位置变为空穴

(3)直至新元素不大于空穴父节点时停止空穴上溯

template<typename val_t>
void MinHeap<val_t>::insert(val_t val) {
    size_t  i;
    for (i = ++size; vec[i/2] > val; i /= 2) { 
        vec[i]  =  vec[i / 2];
    }
    vec[i] =  val;
}

在实现过程中，我们只是用i标记了空穴的位置，并没有交换空穴与父节点的位置。

删除根元素

删除元素采用恰好相反的下滤策略:

(1) 移除根节点后在根节点处产生了一个空穴

(2) 比较空穴的左右子节点，较大的一个与空穴交换位置，直至空穴到达最下层

(3) 将原来最后一个元素填入空穴的位置

template<typename val_t>
void MinHeap<val_t>::rmMin() {
    size_t  i, next;
    val_t min, last;
    if (empty()) {
        return;
    }
    min  = vec[1];
    last = vec[size--];
    for (i = 1; i * 2 <= size; i = next) {
        //find smaller next
        next = i * 2;
        if (next != size && vec[next + 1] < vec[next]) {
            next++;
        }
        //
        if (last > vec[next]) {
            vec[i] = vec[next];
        }
        else {
            break;
        }
    }
    vec[i] = last;
}

一言不发就丢代码：

#include <iostream>
//#include <vector>

using namespace std;

template<typename val_t>
class MinHeap {
protected:
    const static size_t capcity = 10000;
    size_t size;
    val_t vec[capcity];
public:
    MinHeap();
    void insert(val_t val);
    bool empty();
    void rmMin();
    val_t getMin() {
        return vec[1];
    };
    ~MinHeap() = default;
};

template<typename val_t>
MinHeap<val_t>::MinHeap() {
    size = 0;
}

template<typename val_t>
bool MinHeap<val_t>::empty() {
    if (size) {
        return false;
    }
    else {
        return true;
    }
}

template<typename val_t>
void MinHeap<val_t>::insert(val_t val) {
    size_t  i;
    for (i = ++size; vec[i/2] > val; i /= 2) { //covert > to <, to get a max heap
        vec[i]  =  vec[i / 2];
    }
    vec[i] =  val;
}

template<typename val_t>
void MinHeap<val_t>::rmMin() {
    size_t  i, next;
    val_t min, last;
    if (empty()) {
        return;
    }
    min  = vec[1];
    last = vec[size--];
    for (i = 1; i * 2 <= size; i = next) {
        //find smaller next
        next = i * 2;
        if (next != size && vec[next + 1] < vec[next]) {
            next++;
        }
        //
        if (last > vec[next]) {
            vec[i] = vec[next];
        }
        else {
            break;
        }
    }
    vec[i] = last;
}