优先队列

        在现实的生活工作中，有许多情况下都要处理有序的元素，但又不要求全部有序，再或者不要求一次就将它们全部排序，这种情况下一种叫“优先队列”的算法就派上了用场。比如说，不要求全排序一个大数据集合的数据，或内存一次装不下整个数据集，但是要求获得最大或最小的M有序的数组。
       本节我们会学习基于二叉堆数据结构的优先队列的实现。优先队列最重要的操作就是删除最大元素和插入元素两种操作。数据结构二叉堆能够很好地实现优先队列的基本操作。在二叉堆的数组中，每个元素都要保证大于等于两外2个特定位置的元素。(当一颗二叉的每个节点都大于等于它的两个孩子节点时，被称为堆有序。)
       用数组(堆)实现的完全二叉树，结构严格有灵活，能实现对数级别的插入元素和删除最大元素的操作。代码如下：

 /**
 * 基于数组(堆)实现的完全二叉树的优先队列
 * @author jacky
 *
 */
 public class MaxPriorityQueue<Key extends Comparable<Key>>{
	//基于堆的完全二叉树
	private Key[] pq; 
	//将数据存储在pq[1 ... N]中，pq[0]不使用
	private int size = 0;
	
	/**
	 * 默认创建一个大小为Integer.MAX_VALUE的队列
	 */
    public MaxPriorityQueue(){
    	pq = (Key[])new Comparable[Integer.MAX_VALUE];
    }
    
    public MaxPriorityQueue(int max){
    	pq = (Key[])new Comparable[max + 1];
    }
    
    /**
     * 向优先队列中添加元素，将元素添加到数组的pq[++size]
     * @param v
     */
    public void push(Key v){
    	pq[++size] = v;
    	//由下至上的对有序化
    	swim(size);
    }
    /**
     * 由下至上的对有序化：循环比较pq[size/2]和pq[k]，若pq[size/2] < pq[k]则
     * 交换数据，知道k = 1
     * @param k
     */
    private void swim(int k){
    	int cmp = k/2;
    	while(k > 1 && less(cmp,k)){
    		exch(cmp,k);
    		cmp = k/2;
    	}
    }
    
    /**
     * 将最大的元素从优先队列中取出
     * @return
     */
    public Key delMax(){
    	Key max = pq[1];//从根节点得到最大的元素
    	exch(1,size--);//将其和最后一个节点交换
    	pq[size+1] = null;//防止越界
    	sink(1);//由上到下恢复对的有序性
    	return max;
    }
    /**
     * 由上到下的对有序化
     * @param k
     */
    private void sink(int k){
    	while(2 * k <= size){
    		int j = 2 * k;
    		if(j < size && less(j,j+1)){
    			j++;
    		}else if(!less(k,j)){
    			break;
    		}
    		exch(k,j);
    		k = j;
    	}
    }
    
    private boolean less(int i,int j){
    	return pq[i].compareTo(pq[j]) < 0;
    }
    private void exch(int i,int j){
    	Key tmp = pq[i];
    	pq[i] = pq[j];
    	pq[j] = tmp;
    }
    public boolean isEmpty(){
    	return size == 0;
    }    
    public int size(){
    	return size;
    }
 }