优先队列

      很多情况下我们会收集一些元素，处理当前键值最大的元素，然后再收集更多的元素，再处理当前键值最大的元素，如此这般。在这种情况下，一个合适的数据结构应该支持如下操作：删除最大元素和插入元素。这种数据类型叫做优先队列。

     优先队列基于有序数组和无序数组的实现都比较简单，我们主要介绍优先队列基于堆的实现。

1.堆的定义

     数据结构二叉堆能够很好地实现优先队列的基本操作。定义：当一棵二叉树的每个节点都大于等于它的子节点时，它被称为堆有序。二叉堆是一组能用堆有序的完全二叉树排序的元素，并且在数组中按层级存储(不使用数组的第一个位置）。

   在一个二叉堆中，位置为k的节点的父节点的位置为k/2，而它的两个子节点的位置分别为2k和2k+1。用数组(堆)实现的完全二叉树是很严格的，但它的灵活性已经足够我们实现优先队列了。

2.堆的算法

    我们用长度为N+1的私有数组pq[]来表示一个大小为N的堆，我们不使用pq[0],堆元素放在pq[1]至pq[N]中。

    堆的操作首先会进行一些简单的改动，打破堆的状态，然后再遍历堆并按照要求将堆的状态恢复。我们称这个过程为堆的有序化。

2.1从下至上的堆有序化(上浮)

private void swim(int k)
{
  while(k>1 && less(k/2,k))
  {         
     exch(k,k/2);
     k = k/2;
  }
}

2.2从上至下的堆有序化(下沉)

private void sink(int k)
{
  while(2*k<=N)
 {
   int j = 2*k;
   if(j < N && less(j,j+1)) j++;
   if(!less(k,j))  break;
    exch(k,j);
   k = j;
  }
}

插入元素。我们将新元素加在数组末尾，增加堆的大小并让这个新元素上浮到合适的位置。

删除最大的元素。我们从数组顶端删去最大的元素并将数组的最后一个元素放到顶端，减小堆的大小并让这个元素下沉到合适的位置。

//基于堆的优先队列
public class MaxPQ<Key extends Comparable<Key>> 
{
	private Key[] pq;
	private int N = 0;
	public MaxPQ(int maxN)
	{
	    pq = (Key[])new Comparable[maxN+1];
    }
	public boolean isEmpty()
	{
		return N==0;
	}
	public int size()
	{
		return N;
	}
	public void insert(Key v)
	{
		pq[++N] = v;
		swim(N);
	}
	public Key delMax()
	{
		Key max = pq[1];
		exch(1,N--);
		pq[N+1] = null; //防止越界
		sink(1);
		return max;
	}
	private void exch(int i, int j)
	{
		Key temp = pq[i];
		pq[i] = pq[j];
		pq[j] = temp;
	}
	private boolean less(int i, int j)
	{
		return (pq[i].compareTo(pq[j]))<0;
	}
	private void swim(int k)
	{
		while(k>1 && less(k/2,k))
		{ 		
			    exch(k,k/2);
		        k = k/2;
		}
	}
	private void sink(int k)
	{
		while(2*k<=N)
		{
			int j = 2*k;
			if(j < N && less(j,j+1)) j++;
			if(!less(k,j))  break;
			exch(k,j);
			k = j;
		}
	}
}