最大堆/最小堆/优先队列 实现代码（c++）

class Max_Heap{
    typedef int index;
public:
    Max_Heap(const vector<int> &vec) :v(vec){
        Build_Heapify(v);
    }
    ~Max_Heap(){};
    void Heap_Sort();
    int Heap_Max() { return v[0]; }
    int Heap_Extract_Max();
    void Insert(int key);
private:
    vector<int> v;
    void Max_Heapify(vector<int> &vec, index i, int hs);
    void Build_Heapify(vector<int> &vec);
};

void
Max_Heap::Max_Heapify(vector<int> &vec, index i, int hs){
    int l = 2 * i + 1, r = 2 * i + 2;
    int largest = i;
    if (l < hs&&vec[l] > vec[i])
        largest = l;
    if (r < hs&&vec[r] > vec[largest])
        largest = r;
    if (largest != i){
        swap(vec[i], vec[largest]);
        Max_Heapify(vec, largest, hs);
    }
}

void
Max_Heap::Build_Heapify(vector<int> &vec){
    int hs = vec.size();
    for (int i = (hs / 2) - 1; i >= 0; --i)
        Max_Heapify(vec, i, hs);
}

void
Max_Heap::Heap_Sort(){
    int hs = v.size();
    Build_Heapify(v);
    for (int i = hs - 1; i >= 0; --i){
        swap(v[0], v[i]);
        Max_Heapify(v, 0, i);
    }
}
int
Max_Heap::Heap_Extract_Max() {
    if (v.size() == 0)
    {
        std::cout << "over flow";
        return 0;
    }
    else {
        int temp = v[0];
        swap(v[0], v[v.size() - 1]);
        v.pop_back();
        Max_Heapify(v, 0, v.size());
        return temp;
    }
}
void
Max_Heap::Insert(int key){
    v.push_back(key);
    int sz = v.size();
    while (sz>=2&&key > v[sz / 2 - 1]){
        swap(v[sz - 1], v[sz / 2 - 1]);
        sz = sz / 2;
    }
}