优先队列（堆）

优先队列（priority model）模型

  insert：等价enqueue（入队）操作

  deleteMin：它的工作是找出、返回并删除优先队列中最小的元素，等价dequeue（出队）操作

优先队列基本模型：

  

优先队列可以用外部排序。在贪婪算法（greedy algorithm）的实现方面优先队列也是很重要的，该算法通过反复求出最小元来进行操作。

一些简单的实现

  1）使用一个简单链表在表头以O(1)执行插入操作，并变量该链表以删除最小元，这需要O(N)时间。

  2）始终让链表保持排序状态，这使得插入代价高昂（O(N)）而deleteMin花费低廉（O(1)）。方法1比方法2好。

  3）使用二叉查找树，它对这两种操作（插入、删除）的平均运行时间都是O(logN)。尽管插入是随机的，而删除则不是，但这个结论还是成立的。

二叉堆（binary heap）

  就是平时所说的堆（heap）。性质：结构性和堆序性。堆的操作必须到堆的所有性质都被满足时才能终止。

结构性质

  堆是一颗被完全填满的二叉树，有可能的例外是在底层，底层上的元素从左到右填入。这样的树称为完全二叉树（complete binary tree）。

一颗高为h的完全二叉树有2^h到2^h+1-1个节点。这意味着完全二叉树的高是小于等于logN的整数值，显然它是O(logN)。

完全二叉树的数组实现：

一个堆结构将由一个（Comparable对象的）数组和一个代表当前堆大小的整数组成。类架构如下：

public class BinaryHeap<AnyType extends Comparable<? super AnyType>> {public BinaryHeap(){}public BinaryHeap(int capacity){}public BinaryHeap(AnyType[] items){}public BinaryHeap(AnyType x){}public AnyType findmin(){}public AnyType deleteMin(){}public boolean isEmpty(){}public void makeEmpty(){}private static final int DEFAULT_CAPACITY = 10;private int currentSize;  //堆中元素数量private AnyType[] array;  //堆数组private void percolateDown(int hole){}private void buildHeap(){}private void enlargeArray(int newSize){}}

堆序性质（heap-order property）

  让操作快速执行的性质是堆序性质。在一个堆中，对于每一个节点X，X的父亲中的关键字小于（或等于）X中的关键字，根节点除外（它没有父亲）。

基本的堆操作

insert（插入）

  为将一个元素X插入到堆中，我们在下一个可用位置创建一个空穴，否则该堆将不是完全树。如果X可以放在该空穴中而并不破坏堆的序，那么插入完成。否则，我们把空穴的父节点上的元素移入该空穴中，这样，空穴就朝着根的方向上冒一步。继续该过程直到X能被放入空穴中为止。这种策略叫做上滤（precolate up）。

插入到一个二叉堆的过程：

    /**     * Insert into the priority queue,maintaining heap order.     * Duplicates are allowed     * @param x the item to insert     */    public void insert(AnyType x){    if(currentSize==array.length-1){    enlargeArray(array.length*2+1);    }        //Percolate up    int hole = ++currentSize;    for(;hole>1 && x.compareTo(array[hole/2])<0;hole/=2){    array[hole] = array[hole/2];    }    array[hole] = x;    }

deleteMin(删除最小元)

  当删除一个最小元时，要在根节点建立一个空穴。由于现在堆少了一个元素，因此堆中最后一个元素X必须移动到该堆的某个地方。如果X可以被放到空穴中，那么deleteMin完成。不过这一般不太可能，因此我们将空穴的两个儿子中较小者移入空穴，这样就把空穴向下推了一层。重复该步骤直到X可以被放入空穴中。因此，我们的做法是将X置入沿着从根开始包含最小儿子的一条路径上一个正确的位置。这种策略叫做下滤（percolate down）。

在二叉堆中执行deleteMin的方法：

    /**     * Remove the smallest item from the priority queue     * @return the smallest item,or throw UnderflowException,if empty     */    public AnyType deleteMin(){    if(isEmpty()){    throw new UnderflowException();    }        AnyType minItem = findMin();    array[1] = array[currentSize--];    percolateDown(1);    return minItem;    }        /**     * Internal method to percolate down in the heap     * @param hole the index at which the perolate begins     */    private void percolateDown(itn hole){    int child;    AnyType tmp = array[hole];    for(;hole*2<=currentSize;hole=child){    child = hole*2;    if(child!=currentSize&&array[child+1].compareTo(array[child])<0){    child++;    }    if(array[child].compareTo(tmp)<0){    array[hole] = array[child];    }else{    break;    }        }    array[hole] =tmp;    }

decreaseKey(降低关键字的值)

  decreaseKey(p,)操作降低在位置p处的项的值，降值的幅度为正的量。由于这可能破坏堆序性质，因此必须通过上滤对堆进行调整。

increaseKey(增加关键字的值)

  increateKey(p,)操作增加在位置p处的项的值，增值的幅度为正的量。这可以用下滤来完成。

delete(删除)

  delete(p)操作删除堆中位置p上的节点。该操作通过首先执行decreaseKey(p,无穷)然后再执行deleteMin()来完成。当一个进程被用户中止（而不是正常终止）时，它必须从优先队列中除去。

buildHeap(构建堆)

  

    /**     * Construct the binary heap given an array of items     */    public BinaryHeap(AnyType[] items){    currentSize = items.length;    array = (AnyType[])new Comparable[(currentSize+2)*11/10];    int i = 1;    for(AnyType item:items){    array[i++] = item;    }    buildHeap();    }    /**     * Establish heap order property from an arbitrary     * arrangment of items. Runs in linear time     */    private void buildHeap(){    for(int i=currentSize/2;i>0;i--){    percolateDown(i);    }    }

包含2^h+1 - 1 个节点，高为h的理想二叉树（perfect binary tree）的节点的高度的和为2^h+1 - 1 - (h+1)。