优先队列 堆实现 java

package keepthinker.sort;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.ListIterator;
import java.util.PriorityQueue;
import java.util.Random;



public class MyPriorityQueue<T> {
	private static final int SIZE=10;
	Comparator<T> cp;
	ArrayList<T> list=new ArrayList<T>();
	public MyPriorityQueue(Comparator<T> cp){
		this.cp=cp;
	}
	/**取最大优先元素：获取根元素，并且使其与最堆底元素相交换，删除堆底元素，进行一次最大堆运算。
        */
	public T extractMax(){
		if(list.size()==0) return null;
		T max= list.get(0);
		Collections.swap(list, 0, list.size()-1);
		list.remove(list.size()-1);

		Object[] ls=list.toArray();
		HeapList<T> hList=new HeapList(ls);
		maxHeapify(hList, 0);

		ListIterator<T> i = list.listIterator();
		for (int j=0; j<ls.length; j++) {
			i.next();
			i.set((T)ls[j]);
		}
		return max;

	}
        /**插入新元素：插入元素于最堆底，然后递归与父节点比较大小，满足条件就交换
        */
	public void insert(T elem){
		list.add(elem);
		increaseKey(list.size()-1, elem);
	}
	/** 修改队列中元素：若修改的优先级小于原来则返回false，若大于则与父节点递归交换
         */
	public boolean increaseKey(int i,T elem){
		if(cp.compare(elem, list.get(i))<0) return false;
		list.set(i, elem);
		int j;
		while(i!=0){
			j=((i-1)>>1);//>>1 意思为除以2（性能优化），获取父节点位置
			if(cp.compare(list.get(i),list.get(j))>0)
				Collections.swap(list, i, j);
			i=j;
		}
		return true;
	}
	private  void maxHeapify(HeapList<T> a,int i){
		int l=2*i+1;//left leaf
		int r=2*i+2;//right leaf
		int largest;
		if(l<a.heapSize&&cp.compare(a.arr[l],a.arr[i])>0){
			largest=l;
		}else{
			largest=i;
		}
		if(r<a.heapSize&&cp.compare(a.arr[r],a.arr[largest])>0){
			largest=r;
		}
		if(largest!=i){
			T temp=a.arr[i];
			a.arr[i]=a.arr[largest];
			a.arr[largest]=temp;
			maxHeapify(a,largest);
		}
	}
	private  static class HeapList<T>{
		public T[] arr;
		public int heapSize;
		public HeapList(T[] arr){
			this.arr= arr;
			this.heapSize=arr.length;
		}
	}
	
	public static void main(String[] args){
		MyPriorityQueue<Integer> que=new MyPriorityQueue<Integer>(new IntegerCondition());
		Random ra=new Random();
		for(int i=0;i<SIZE;i++)
			que.insert(ra.nextInt(1000));
		for(int i=0;i<SIZE;i++){
			System.out.println(que.extractMax());
		}
	}
}
/**
 * the absolute value of elem must not bigger than Integer.MAX_VALUE/2.
 * 11 12 5 28 92 9 8
 * @author KESHENGKAI
 *
 * @param <Integer>
 */
class IntegerCondition<Integer> implements Comparator<Integer>{
	@Override
	public int compare(Integer arg0, Integer arg1) {
		// TODO Auto-generated method stub
		int a1=(java.lang.Integer) arg0;
		int a2=(java.lang.Integer) arg1;
		return  a1-a2;
	}

}
class StringCondition<String> implements Comparator<String>{

	@Override
	public int compare(String o1, String o2) {
		// TODO Auto-generated method stub
		return ((java.lang.String)o1).compareTo((java.lang.String)o2);
		
	}
	
}