优先队列（C++实现）

优先队列（堆）满足先进先出，而且每次出队的都是队列中最小的（也可以是最大的，看实现过程）。
堆是一棵完全二叉树，所以优先队列一般用二叉堆实现。
C++有自带的PriorityQueue，但是C#没有。所以写一下

分析：
1.一棵完全二叉树，所以可以用一个数组表示而不需要用指针。但是用数组就要事先估计堆的大小，所以用一个Capacity表示最大值。
2.因为保持堆序性质，最小元就是在根上，删除后还得做一些调整来保持完全二叉树的结构（实际就是删除最后一个元素，然后把它插入到队列中）。
3.若当前节点下标为i，则i*2和i*2+1就是它的左右孩子，我们在data[0]处放了一个MIN_INT。
4.入队：首先size++，如果data[size]插入不破坏结构，结束。否则，不断用父亲的值赋给当前节点，直到合适的位置。时间复杂度O(logN)。

5.出队：首先根节点置空，记录size点（last）的值然后size–，last能放入当前空穴就结束，否则，不断用儿子中最小的值赋给当前节点。时间复杂度O(logN)。

6.队首：直接返回根节点的值，为最小值，O(1)。

PriorityQueue.h

template<class T>
class PriorityQueue
{
private:
    int Capacity = 100;    //队列容量
    int size;                 //队列大小
    T* data;             //队列变量

public:
    PriorityQueue();
    ~PriorityQueue();

    int Size();
    bool Full();   //判满
    bool Empty(); //判空
    void Push(T key); //入队
    void Pop();//出队
    void Clear(); //清空
    T Top();//队首
};

template<class T>
PriorityQueue::PriorityQueue()
{
    data = (T*) malloc((Capacity + 1)*sizeof(T));
    if (!data)
    {
        perror("Allocate dynamic memory");
        return;
    }

    size = 0;
}

template<class T>
PriorityQueue::~PriorityQueue()
{
    while (!Empty())
        Pop();
}

template<class T>
//判空
bool PriorityQueue::Empty()
{
    if (size > 0)
        return false;
    return true;
}

template<class T>
//清空
void PriorityQueue::Clear()
{
    while (!Empty())
        Pop();
}

template<class T>
//判满
bool PriorityQueue::Full()
{
    if (size == Capacity)
        return true;
    return false;
}

template<class T>
//大小
int PriorityQueue::Size()
{
    return size;
}

template<class T>
//入队
void PriorityQueue::Push(T key)
{
    // 空则直接入队  不能省略
    if (Empty())
    {
        data[++size] = key;
        return;
    }

    int i;

    if (Full())
    {
        perror("Priority queue is full\n");
        return;
    }

    for (i = ++size; data[i / 2] > key; i /= 2)
        data[i] = data[i / 2];
    data[i] = key;

    //if (key != data[i / 2])          //如果不能插入重复值 用下面的
    //  data[i] = key;
    //else
    //{
    //  size--;
    //  perror("Same value");
    //}

}

template<class T>
//出队
void PriorityQueue::Pop()
{
    int i, child;
    T min, last;

    if (Empty())
    {
        perror("Empty queue\n");
        return;
    }

    min = data[1];
    last = data[size--];

    for (i = 1; i * 2 <= size; i = child)
    {
        child = i * 2;
        if (child != size && data[child + 1] < data[child])
            child++;

        if (last > data[child])
            data[i] = data[child];
        else
            break;
    }
    data[i] = last;
}

template<class T>
//队首
T PriorityQueue::Top()
{
    if (Empty())
    {
        perror("Priority queue is full\n");
        return data[0];
    }
    return data[1];
}

银行有1个服务员，n名顾客，每位顾客有到达时间和服务时间。
先到的顾客先服务，求总服务时间。
输入n 和 n 行 输出服务时间

样例输入：
3
1 3
3 5
10 4
样例输出：14

PriorityQueue.cpp

#include"PriorityQueue.h"
#include
#include
using namespace std;
const int MAXN = 1000;

//事件 
struct Event
{
    int arrive;        //到达时间
    int service;      //服务时间

    Event(){}
    Event(int a, int s)
    {
        arrive = a;
        service = s;
    }
}cus[MAXN];

int operator > (const Event& a, const Event& b) {
    return a.arrive > b.arrive;
}

int operator < (const Event& a, const Event& b) {
    return a.arrive < b.arrive;
}

int main()
{
    Event minCustomer(INT_MIN,0);
    PriorityQueue request;      //顾客

    int n, time;
    while (cin >> n)
    {
        for (int i = 0; i < n; i++)
        {
            cin >> cus[i].arrive >> cus[i].service;
            request.Push(cus[i]);   //顾客入队
        }
        time = 0;     //服务时间
        while (!request.Empty())
        {
            Event current = request.Top();
            request.Pop();
            time = max(current.arrive + current.service, time + current.service);
        } 

        cout << time << endl;
    }
    return 0;
}