算法导论第六章__实现优先队列

public class Priority_Queue {
    //储存的数组
	private int A[];
	//堆的大小
	private int pile_Size=0;
	//如果没找到指定值，返回 -1
	private int NOT_FIND = -1;
	//堆容器的大小增量
	private int INCREAT_CAPCITY=20;
	//堆容器大小
	private static int INT_NUM=20;
	
	//构造函数1__不指定堆容器的大小，容器大小设置为默认大小,值:INT_NUM:20;
	public Priority_Queue(){
		this(INT_NUM);
	}
	
	//构造函数2__指定堆容器的大小
	public Priority_Queue(int capcity){
		A=new int[capcity];
	}
	//往容器里插入值，考虑到多线程，于是加入synchronized
	public synchronized void  Insert(int value){
		if(getHeap_size()==A.length){
			increate_Capcity();
		}
        A[pile_Size]=value;
        query_suitable_index(pile_Size++);
        
	}
	
	//修改堆容器里面的值
	public synchronized boolean modify(int index,int value){
		if(index<0||index>pile_Size){
			return false;
		}
		if(value<A[index]){
			return false;
		}
		A[index]=value;
		query_suitable_index(index);
		return true;
		
	}
	//修改或者增加元素，引起容器不满足堆的性质，所以需要进行“初始化”，使容器满足堆的性质
	public void query_suitable_index(int index){
		while(Parent(index)!=NOT_FIND && index>=1 && A[Parent(index)]<A[index]){
			int exchange=A[index];
			A[index]=A[Parent(index)];
			A[Parent(index)]=exchange;
			index=Parent(index);
		}
	}
	//增加容器的大小
	public void increate_Capcity(){
		int []B=new int[A.length+INCREAT_CAPCITY];
		for (int i = 0; i < A.length; i++) {
			B[i]=A[i];
		}
		A=B;
	}
	//得到容器元素的个数
	public int getHeap_size() {
		return pile_Size;
	}
	//得到左孩子
	public int Left_Chiren(int i) {
		int left = i * 2 + 1;
		return (left < pile_Size) ? left : NOT_FIND;
	}
	//得到右孩子
	public int Right_Chiren(int i) {
		int right = i * 2 + 2;
		return (right < pile_Size) ? right : NOT_FIND;
	}
    //得到父子节点
	public int Parent(int i) {
		int parent = (i - 1) / 2;
		return (parent >= 0) ? parent : NOT_FIND;
	}

	//对堆容器从指定的节点往下"初始化"！
	public void Max_Pile(int i) {
		int left_Chiren = Left_Chiren(i);
		int right_Chiren = Right_Chiren(i);
		int largest;
		if (left_Chiren!=-1&&A[i] < A[left_Chiren]) {
			largest = left_Chiren;
		} else {
			largest = i;
		}
		if(right_Chiren!=-1&&A[largest]<A[right_Chiren]){
			largest=right_Chiren;
		}
		if(largest!=i){
		    int largetValue=A[largest];
		    A[largest]=A[i];
		    A[i]=largetValue;
		    Max_Pile(largest);
		}
	}
	//将这个堆进行排序
	public void Heap_Sort(){
	     //从小到大的排序
		for (int i = pile_Size-1; i >=1; i--) {
		    int exchange=A[i];
		    A[i]=A[0];
		    A[0]=exchange;
		    
		    pile_Size--;
		    
		    Max_Pile(0);
		}
	}
	//得到堆中最大的元素
	public int getMax(){
		return A[0];
	}
	//得到堆中最大的元素，并删除最大的元素
	public int extract_Max(){
		if(pile_Size<1){
		   return NOT_FIND;
		}
		int Max=A[0];
		A[0]=A[pile_Size--];
		Max_Pile(0);
		return Max;
	}
	//打印
	@Override
	public String toString() {
		StringBuilder sb=new StringBuilder();
		for(int i=0;i<pile_Size;i++)
			sb.append(A[i]+"  ");
		return sb.toString();
	}
	//测试
	public static void main(String[] args) {
		Priority_Queue pile=new Priority_Queue();
		
		System.out.println("---------------测试insert（）方法--------------------------");
		for (int i = 1; i < 5; i++) {
			pile.Insert(i);
			System.out.println("增加新元素:"+i);
			System.out.println(pile);
		}

		System.out.println("---------------测试extract_Max（）方法---------------------");
		System.out.println("堆容器中最大的数："+pile.extract_Max());
		System.out.println("删除堆中最大的数，之后，容器变为：");
		System.out.println(pile);
	}
}

输出：

---------------测试insert（）方法--------------------------
增加新元素:1
1  
增加新元素:2
2  1  
增加新元素:3
3  1  2  
增加新元素:4
4  3  2  1  
---------------测试extract_Max（）方法---------------------
堆容器中最大的数：4
删除堆中最大的数，之后，容器变为：
3  0  2