数据结构实现之最大优先队列（最大堆）

package xwq.dt;

import java.util.Comparator;
import java.util.Iterator;
import java.util.NoSuchElementException;

import xwq.util.StdIn;
import xwq.util.StdOut;
/**
*****************************************************************
**************** 最大优先队列API ****************
1、构造函数
public MaxPQ();
public MaxPQ(int capacity);
public MaxPQ(Comparator cmp);
public MaxPQ(int capacity,Comparator cmp);
public MaxPQ(Key[] keys);
public MaxPQ(Key[] keys,Comparator);

2、队列操作
public boolean isEmpty();
public int size();
public void push(Key key); 动态扩容*2
public Key pop();
public Key peek();
private void resize(int capacity);

3、堆辅助操作
private void adjustDown(int index);
private void adjustUp(int index);
private boolean less(Key k1,Key k2);
private void swap(Key[] keys,int i,int j);

******************************************************************
*/
public class MaxPQ<Key extends Comparable<Key>> implements Iterable<Key> {

private Key[] keys; //关键字集合
private int N;  //目前关键字容量
private Comparator comparator; //比较器

/**
* 初始化空最大优先队列
*/
public MaxPQ() {
this(1);
}

/**
* 初始化容量为capacity的最大优先队列
* @param capacity 容量
*/
public MaxPQ(int capacity) {
this(capacity,null);
}

/**
* 初始化含有Key比较器的空最大优先队列
* @param cmp 自定义Key比较器
*/
public MaxPQ(Comparator cmp) {
this(1,cmp);
}

/**
* 初始化含有Key比较器,容量为capacity的最大优先队列
* @param capacity 容量
* @param cmp Key比较器
*/
public MaxPQ(int capacity,Comparator cmp) {
keys = (Key[]) new Comparable[capacity+1];
this.comparator = cmp;
N = 0;
}

/**
* 初始化数组来自数组的最大优先队列
* @param keys 数组
*/
public MaxPQ(Key[] keys) {
this(keys,null);
}

/**
* 初始化数组来自数组的最大优先队列,含有Key比较器
* @param keys 数组
* @param cmp Key比较器
*/
public MaxPQ(Key[] ks,Comparator cmp) {
this(ks.length,cmp);
N = ks.length;
for(int i = 1;i <= N;i++)
keys[i] = ks[i-1];
for(int i=N/2 ;i >= 1;i--)
adjustDown(i);
}

/****************************************************************
队列操作
****************************************************************/
/**
* 判断队列是否为空
* @return
*/
public boolean isEmpty() {
return N == 0;
}

/**
* 获取队列大小
* @return
*/
public int size() {
return N;
}

/**
* 进队，向最大堆插入key
* @param keys2
*/
public void push(Key k) {
//队列容量已满，扩容
if(N == keys.length-1)
resize(N*2);
keys[++N] = k;
adjustUp(N);
}

/**
* 出队，删除最大堆的根节点
* @return
*/
public Key pop() {
if(isEmpty()) throw new NoSuchElementException("queue is empty.");
Key max = keys[1];
swap(1,N--);
adjustDown(1);
keys[N+1]=null;//* 避免指针游走，以帮助尽快垃圾回收
if(N>0 && N == (keys.length-1)/4 )  resize((keys.length-1)/2);
return max;
}

/**
* 获取队首元素，最大堆的根节点
* @return
*/
public Key peek() {
if(isEmpty()) throw new NoSuchElementException("queue is empty.");
return keys[1];
}

/**
* 重定义堆容量大小
* @param capacity
*/
private void resize(int capacity) {
assert capacity>N;
Key[] news = (Key[]) new Comparable[capacity+1];
for(int i=1;i<=N;i++)
news[i] = keys[i];
keys = news;
}

/****************************************************************
堆辅助操作
****************************************************************/
/**
* 向下调整最大堆
* @param index 待调整堆起始索引
*/
private void adjustDown(int index) {
while(2*index <= N) {
int l = index*2;
//选择左右孩子节点中较大的一个
if(l<N && less(keys[l],keys[l+1]))
l++;
//判断index是否已经满足最大堆性质
if(less(keys[l],keys[index]))
break;
//向下调整
swap(index,l);
index = l;
}
}

/**
* 向上调整最大堆
* @param index 待调整堆起始索引
*/
private void adjustUp(int index) {
while(index > 1) {
int parent = index/2;
//判断index是否已经满足最大堆性质
if(less(keys[index],keys[parent]))
break;
//向上调整
swap(index,parent);
index = parent;
}
}

/**
* k1<k2 返回true
* @param k1
* @param k2
* @return
*/
private boolean less(Key k1,Key k2) {
if(this.comparator != null)
return comparator.compare(k1, k2) < 0;
else
return ((Comparable)k1).compareTo(k2) < 0;
}

/**
* 交换元素
* @param i
* @param j
*/
private void swap(int i,int j) {
Key t = keys[i]; keys[i] = keys[j]; keys[j] = t;
}

@Override
public Iterator<Key> iterator() {
return new HeapIterator();
}

/***************************************************************************
* Iterator.
***************************************************************************/

/**
* Returns an iterator that iterates over the keys on this priority queue
* in descending order.
* The iterator doesn't implement remove() since it's optional.
*
* @return an iterator that iterates over the keys in descending order
*/
private class HeapIterator implements Iterator<Key > {
//创建一个新的最大优先队列
private MaxPQ<Key> copy;

// copy堆中的所有元素
// 由于原顺序已满足堆性质，所以只需花费线性时间
public HeapIterator() {
if(comparator == null) copy = new MaxPQ<Key>(N);
else    copy = new MaxPQ<Key>(N,comparator);
for(int i=1;i<=N;i++)
copy.push(keys[i]);
}

@Override
public boolean hasNext() {
return copy.size() > 0;
}

@Override
public Key next() {
if(copy.size() == 0)
throw new NoSuchElementException("has not next element.");
return copy.pop();
}

@Override
public void remove() {
throw new UnsupportedOperationException("not support remove.");
}

}

/**
* Unit tests the MaxPriorityQueue data type.
*/
public static void main(String[] args) {
MaxPQ<String> pq = new MaxPQ<String>();
while (!StdIn.isEmpty()) {
String item = StdIn.readString();
if (!item.equals("-")) pq.push(item);
else if (!pq.isEmpty()) StdOut.print(pq.pop() + " ");
}
//使用迭代器
for(String s:pq) {
StdOut.print(s+" ");
}
StdOut.println("(" + pq.size() + " left on pq)");
}

}