1: 与前面说的最小优先队列相反
堆的排序也相反 :
package com.algorithm.common;
import java.util.Iterator;
import java.util.NoSuchElementException;
/**
* 大顶堆排序 最大优先队列
* @author lijunqing
*/
public class MaxPQ<Key> implements Iterable<Key> {
private int N;
private Key[] pq;
public MaxPQ() {
this(1);
N=0;
}
public MaxPQ(int initCapacity) {
pq=(Key[])new Object[initCapacity + 1];
N=0;
}
/**
* 添加一个到堆中
* @param key
*/
public void insert(Key key) {
if(N == pq.length - 1) { // 申请2培空间
resize(2 * pq.length);
}
N++;
pq[N]=key;
swim(N);
}
/**
* 递归调整当前节点和父节点的
* @param n2
*/
private void swim(int i) {
while(i > 1 && greater(i, i / 2)) {
exch(i, i / 2);
i=i / 2;
}
}
/**
* 堆顶出堆 重新调整堆
* @return
*/
public Key delMax() {
exch(1, N);
Key max=pq[N];
pq[N]=null;
N--;
skin(1);
return max;
}
/**
* 从i节点开始调整堆
* @param i
*/
private void skin(int i) {
while(2 * i <= N) {
int k=2 * i;
if(k < N && greater(k+1, k)) {
k++;
}
if(greater(i, k)){
break;
}
exch(i, k);
i=k;
}
}
/**
* i节点大于j节点
* @param i
* @param i2
* @return
*/
private boolean greater(int i, int j) {
return ((Comparable<Key>)pq[i]).compareTo(pq[j]) > 0;
}
/**
* 重新申请空间
* @param capacity
*/
private void resize(int capacity) {
Key[] temp=(Key[])new Object[capacity];
for(int i=0; i < pq.length; i++) {
temp[i]=pq[i];
}
pq=temp;
}
/**
* 交互节点值
* @param i
* @param j
*/
private void exch(int i, int j) {
Key temp=pq[i];
pq[i]=pq[j];
pq[j]=temp;
}
public int size() {
return N;
}
public boolean isEmpty() {
return N == 0;
}
@Override
public Iterator<Key> iterator() {
return new HeapIterator();
}
private class HeapIterator implements Iterator<Key> {
// 重新建一个
private MaxPQ<Key> copy;
public HeapIterator() {
copy=new MaxPQ<Key>(size());
for(int i=1; i <= N; i++)
copy.insert(pq[i]);
}
public boolean hasNext() {
return !copy.isEmpty();
}
public void remove() {
throw new UnsupportedOperationException();
}
public Key next() {
if(!hasNext())
throw new NoSuchElementException();
return copy.delMax();
}
}
public static void main(String[] agrs) {
MaxPQ<Integer> max=new MaxPQ<Integer>();
max.insert(22);
max.insert(1);
max.insert(56);
max.insert(41);
max.insert(3);
max.insert(27);
Iterator<Integer> m = max.iterator();
while(m.hasNext()){
System.out.println(m.next());
}
}
}
结果:
56
41
27
22
3
1