简单用heap实现优先队列

        首先是priority_queue的定义，T1是存储的数据类型，T2是仿函数类，即用来判断是大根堆还是小根堆。

        简单实现了stl中常用的push，pop，top，empty方法

/*priority_queue.h*/

#define MAX 100

template<typename T1,typename T2>
class priority_queue{
public:
    priority_queue();
    void push(T1& val);
    void pop();
    const T1& top();
    bool empty();
private:
    T1 arr[MAX];
    int size;
};

接下来是priority_queue的实现

有一些溢出条件我就简单地用cerr判断了

/*priority_queue.hpp*/

#include <iostream>
#include "priority_queue.h"

template<typename T1,typename T2>
priority_queue<T1,T2>::priority_queue():size(0){
}

template<typename T1,typename T2>
void priority_queue<T1,T2>::push(T1& val){
    if(size==MAX){
        std::cerr<<"overflow!"<<std::endl;
        exit(EXIT_FAILURE);
    }
    arr[++size]=val;
    int i=size;
    while(i>=2&&T2()(val,arr[i/2])){
        std::swap(arr[i],arr[i/2]);
        i/=2;
    }
}

template<typename T1,typename T2>
void priority_queue<T1,T2>::pop(){
    if(size==0){
        std::cerr<<"underflow!"<<std::endl;
        exit(EXIT_FAILURE);
    }
    int parent=1;
    arr[parent]=arr[size];
    while(parent*2<=size){
        int child=parent*2;
        if(child+1<=size)
            child=T2()(arr[child],arr[child+1])?child:child+1;
        std::swap(arr[parent],arr[child]);
        parent=child;
    }
    size--;
}

template<typename T1,typename T2>
const T1& priority_queue<T1,T2>::top(){
    if(size==0){
        std::cerr<<"memory can't be printed!"<<std::endl;
        exit(EXIT_FAILURE);
    }
    return arr[1];
}

template<typename T1,typename T2>
bool priority_queue<T1,T2>::empty(){
    return size==0;
}

下面看一组测试效果

/*test.cpp*/
#include <iostream>
#include "priority_queue.hpp"
using namespace std;

int main()
{
    priority_queue<int,greater<int>> q;
    q.push(45);
    q.push(78);
    q.push(23);
    q.push(17);
    q.push(95);
    q.push(53);
    q.push(9);
    q.push(31);
    q.push(65);
    q.push(87);
    while(!q.empty()){
        cout<<q.top()<<endl;
        q.pop();
    }
}

结果为