优先级队列 二叉堆

package huawei;

public class test7 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		MaxPQ<Character> youxianjiMaxPQ = new MaxPQ<Character>(5);
		youxianjiMaxPQ.insert('d');
		youxianjiMaxPQ.insert('c');
		youxianjiMaxPQ.insert('b');
		youxianjiMaxPQ.insert('a');
		youxianjiMaxPQ.insert('e');
		System.out.println(youxianjiMaxPQ);
		System.out.println(youxianjiMaxPQ.delMax());
		
		System.out.println(youxianjiMaxPQ);
	}

}

package huawei;
// 运用泛型，必须是可以比较的类型
// 最大堆，parent节点大于子节点
public class MaxPQ<T extends Comparable<T>> {
	T[] list;
	int N = 0;
	MaxPQ(int cap) {
		// TODO Auto-generated constructor stub
		list = (T[] )new Comparable[cap + 1];
	}
	
	public void insert(T e) {
		// add to the end and then swim
		N += 1; // 插入到最后
		list[N] = e; 
		swim(N); // 然后上浮
	}
	
	
	public T delMax() {
		T max = max(); // 第一个节点最大
		swip(1, N); // 交换第一和最后
		list[N] = null; // 删除最后
		sink(1); // 下沉第一个节点
		return max;
		
	}
	int parent(int root) {
	    return root / 2;
	}
	int left(int root) {
	    return root * 2;
	}
	int right(int root) {
	    return root * 2 + 1;
	}
	
	public void swip(int i, int j) {
		T temp = list[j];
		list[j] = list[i];
		list[i] = temp;
	}
	
	public String toString() {
		String listString = "";
		for (int i = 1; i < list.length; i++) {
			listString += list[i];
		}
		return listString;
	}
	
	public T max() {
		return list[1];
	}
	public boolean less(int i, int j) {
		return list[i].compareTo(list[j]) < 0 ;
	}
	// 上浮
	private void swim(int k) {
		while (k > 1 && less(parent(k), k)) { // 如果此节点大于母节点，则交换
			swip(k, parent(k));
			k = parent(k);

		}	
	}
	
	private void sink(int k) { 
	// 到树底之前
		while (left(k) <= N) {
			int order = left(k); //左节点
			if (list[right(k)] != null && less(left(k), right(k))) { //如果右节点大于左节点
				order = right(k); // 跟换最大节点为右
			}
			if (less(order, k)) { // 如果左右都小于此
				break; // 下沉结束
			}
			swip(k, order); // 交换，使最大成为母节点
			k = order;
		}
	}
}