算法（2.4 优先队列）

public class PQ<Key extends Comparable<Key>> {
private Key[] pq;
private static int N = 0;

public PQ(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(pq, 1, N--);	//	将其和最后一个节点交换
pq[N+1] = null;		//	防止对象游离
sink(1);			//	恢复堆的有序性
return max;
}

//	如果堆的有序状态因为某个节点变得比它的父节点更大而被打破，
//	那么我们就需要通过交换它和它的父节点来修复堆。
//	交换后，这个节点比它的两个子节点都大，但这个节点仍然可能比它现在的父节点更大。
//	我们可以一遍编地用同样的办法恢复秩序，将这个节点不断向上移动直到我们遇到了一个更大的父节点。
private void swim(int k){
while (k>1 && less(k/2, k)){
exch(pq, k/2, k);
k /= 2;
}
}

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

}
}

//这个比较算法相比之前的不同    之前的比较如果索引的对象为空会报错
private boolean less(int i, int j){
if (pq[i]==null && pq[j]!=null){
return true;
}else if (pq[i]!=null && pq[j]==null){
return false;
}
return pq[i].compareTo(pq[j]) < 0;
}

private void exch(Comparable[] a, int i, int j){
Comparable t = a[i];
a[i] = a[j];
a[j] = t;
}

public static void main(String[] args) {
int N = 10;
PQ<Integer> a = new PQ<Integer>(20);
for (int i=0; i<N; i++){
int t = (int)(Math.random()*100);
a.insert(t);
System.out.print(t + " ");
}
System.out.println();

while (a.size() != 0){
System.out.print(a.delMax() + " ");
}
}
}