最大优先队列

1.知识储备：

2.编码实现：

package PriorityQueue;

public class maxPriorityQueue<T extends Comparable<T>>{
   //存储堆中的元素
	private T[] items;
	//记录堆中元素个数
	private int N;
	public maxPriorityQueue(int capacity) {
		// TODO Auto-generated constructor stub
		this.items=(T[])new Comparable[capacity+1];  //+1是为了废除0索引
	}
	
	//获取队列中元素个数
	public int size(){
		return N;
	}
	
	//判读队列是否为空
	public boolean isEmpty(){
		return N==0;
	}
	
	//判读队列i处索引值是否小于j处索引值
	public boolean less(int i,int j){
		return items[i].compareTo(items[j])<0;
	}
	
	//交换队列中i索引处和j索引处的值
	public void exch(int i,int j){
		T temp=items[i];
		items[i]=items[j];
		items[j]=temp;
	}
	
	//往堆中插入一个元素
	public void insert(T t){
		items[++N]=t;
		swim(N);
	}
	
	//删除堆中的最大元素，并返回这个最大元素
	public T delMax(){
		T max=items[1];
		items[1]=items[N];
		N--;
		sink(1);
		return max;
	}
	
	//使用上浮算法，使索引k处的元素能在堆中处于一个正确的位置
	private void swim(int k){
		while(k>1){
			if(less(k/2,k)){
				exch(k/2,k);
			}
			k=k/2;
		}
	}
	
	//使用下沉算法，使索引k处的元素能在堆中处于一个正确的位置
	private void sink(int k){
		while(2*k<=N){
			int max;
			if(2*k+1<=N){
				if(less(2*k,2*k+1)){
					max=2*k+1;
				}
				else{
					max=2*k;
				}
			}
			else{
				max=2*k;
			}
			if(less(k,max)){
				exch(k,max);
				k=max;
			}
			else{
				break;
			}
		}
	}
}

3.测试类：

package PriorityQueue;

public class maxPriorityQueueTest {
    public static void main(String[] args) {
		//创建队列
    	maxPriorityQueue<String> queue =new maxPriorityQueue<String>(10);
    	//插入元素
    	queue.insert("A");
    	queue.insert("D");
    	queue.insert("G");
    	queue.insert("B");
    	queue.insert("H");
    	queue.insert("C");
    	queue.insert("E");
    	queue.insert("F");
    	//循环删除
    	while(!queue.isEmpty()){
    		String value=queue.delMax();
    		System.out.print(value+" ");
    	}
	}
}

4.测试结果：