优先级队列

示例：

　　1.夜间门诊

　　2.多任务操作系统

　　3.Huffman编码

A 问题模式：循优先级访问（call by priority）, 按照这种优先级通过调度器将最高优先级的元素输入给服务端。

B 操作接口：

template <typename T>struct PQ {
    virtual void insert(T) = 0;  //按照优先级次序插入词条
    virtual T getMax() = 0 ; //取出优先级最高的词条 
    virtual T delMax()  = 0; //删除优先级最高的词条
};

Stack和Queue,都是PQ的特例——其优先级完全取决于元素的插入次序。对于栈而言，越是晚到的元素，其优先级越高，更早的出栈被处理。而队列相反。

C 实现尝试：

　efficiency and cost

　C1 实现为Vector: 将每个新加入的元素放在向量的末尾。

　　　插入的时间成本：O（1）获得元素值的时间成本是：O(n) 删除元素的时间成本是： O（n）

　C2 实现为Sorted Vector: 即优先级最大的元素放入向量的末尾。

　　　插入的时间成本：O（n）获得元素值的时间成本是：O(1) 删除元素的时间成本是： O（1）

　C3 实现为List:

　　　插入的时间成本：O（1）获得元素值的时间成本是：O(n) 删除元素的时间成本是： O（n）

　C4 实现为Sorted List:

　　插入的时间成本：O（n）获得元素值的时间成本是：O(1) 删除元素的时间成本是： O（1）

　C5 实现为BBST: AVL Splay Red-black 杀鸡用了牛刀

　　　 PQ = 1 x insert() + 0.5 x search() + 0.5 x remove() = 2/3 x BBST

　若只需要查找极值元素，则不必维护所有元素之间的全序关系，偏序足以。找一种实现简单、维护成本更低的实现方式。

D最终尝试：完全二叉堆

　以向量为形，以树形结构为神，完全二叉树

逻辑上，等同于完全二叉树。物理上，直接借助向量实现。

　逻辑节点与物理元素依层次遍历次序彼此对应：

　　完全二叉堆实现：

template <typename T> class PQ_ComplHeap : pubilc PQ<T>, public Vector<T> {

protected:
    Rank percolateDown(Rank n, Rank i); //下滤
    Rank percolateUp(Rank i); //上滤
    void heapify(Rank n); //Floyd 建堆方法
public:
    PQ_ComplHeap(T* A, Rank n)  {//批量构造
       copyForm(A,0,n); heapify(n);     }
    
    void insert(T); //按照比较器确定的优先次序，插入词条
    T getMax() {return _elem[0] ; } //读取优先级最高的词条
    T delMax();  //删除优先级最高的词条
};

堆序性：

　　H[i] <= H[Parent(i)] : 任何一个节点在数值上都不会超过它的父亲。所以根据优先级队列的特性，最大元必然位于根节点位置。所以H[0]是全局最大元素。

template <typename T> T
PQ_Complate<T> :: getMax() {return _elem[0];}

E完全二叉堆插入(上滤操作）：

　　 E1：算法

　　为插入词条e，只需要将e作为末元素接入向量：1.结构性自然保持。2.若堆序性也被破坏，则完成。否则只能是e与其父节点违反堆序性，则只需要将e与其父节点互换位置即可。

　　　如果交换后，仍然违反逆序性，则只需要将e与新的父节点互换位置即可。如此反复交换的过程满足单调性。这一过程即所谓的上滤过程。

　　　而一旦过程终止，则堆序性在整个完全二叉堆中得到了完全的恢复。　　　　

　　E2实例：

　　E3实现：

　　E4效率：

　　　O（logn），但其中swap操作包含3次赋值操作。所以效率为3*logn.

　　　所以当新插入节点与其父节点需要交换时，我们只需将新插入词条e先备份，然后将其不断上移，最后与其父亲交换。

F完全二叉堆删除：

　　 F1：算法

　　最大元素始终在堆顶，所以我们只需将其摘除。

　　在摘除之后，完全二叉堆的堆序性被破坏，此时我们先将末尾元素放置于堆顶。

　　最后采用下滤操作：　　

　　　　1）e与孩子中的大者互换，若堆序性完成，则结束。

　　　　2）否则e与孩子中的最大者继续交换，若堆序性完成，则结束。

　　F2：实例

　　F3：实现

　　F4：效率

　　其效率与树的高度O（h）具有关系，所以其时间复杂度应为3* O（logn），同样在这里，常数项系数可以得到改进，可以先保存根节点，然后再下滤，最终只做一次实质上的交换操作（3次赋值）

　　在上滤过程中，新插入的节点e只需要与其父节点进行比价。在下滤过程中，根节点要与其孩子做两次比较。这在二叉堆中并不至关重要，但是在多叉堆中就至关重要。

G完全二叉堆批量建堆：

　　 G1：算法

　　　对于任给的n个元素，我们希望将它们构建成一个堆，这样一个过程称之为heapification

　　 G2：自上而下的上滤实现　　　

PQ_ComplHeap(T*A， Rank n) {copyFrom(A,0,n); heapify(n);}
template <typename T> void PQ_ComplHeap<T>: heapify(Rank n) {
  for (int i =1; i < n; ++i)  //按层次遍历次序逐一
     percolateUp(i); //经过上滤插入各个节点
}

　　 G3：自上而下的上滤的效率