开头元素动态的多叉堆实现

//动态多叉堆排序
class MaxPQ< Key extends Comparable<Key>>{
	 Key[] pq;
	
	private int treeSize;//几叉树
	private int start;//起始位置
	private int N;//
	public MaxPQ(int maxSize) {
		treeSize=2;
		start=1;
		N=start-1;
		//初始化
		pq=(Key[])new Comparable[maxSize+1];
	}
	/**
	 * 
	 * @param maxSize 最大长度
	 * @param start 起始位置
	 * @param treeSize 几叉树
	 */
	public MaxPQ(int maxSize,int start,int treeSize) {
		this.start=start;
		this.treeSize=treeSize;
		this.N=start-1;
		//初始化
		pq=(Key[])new Comparable[maxSize+1];
	}
	public boolean isEmpty() {
		return this.N==start-1;
	}
	public int size() {
		return this.N;
	}
	public void insert(Key key) {
		pq[++N]=key;
		swim(N);
	}
	/**
	 * 删除最大元素,并返回
	 * @return
	 */
	public Key delMax() {
		Key max=pq[start];
		exch(start,N);
		pq[N]=null;
		N--;
		sink(start);
		return max;
	}
	/**
	 * 上浮操作
	 * @param k
	 */
	public void swim(int k) {
		//当k不是根节点 且 k的父节点比k小,则交换位置,一直循环
		int j;
		while(k>start && less(j=getFather(k),k)) {
			exch(j,k);
			k=j;
		}
	}
	/**
	 * 下沉操作
	 * @param k
	 */
	public void sink(int k) {
		//若k有子节点
		int j;
		while((j=getSon(k))+1<N) {
			//选择子节点中较大的那一个
			int max=j;
			for(int i=0;i<treeSize-1;i++) {
				if(less(max,j+1)) {
					max=++j;
				}else {
					++j;
				}		
			}
			
			//比较子节点和父节点大小
			if(!less(k,j))
				break;
			//交换位置
			exch(k,j);
			//继续循环
			k=j;
		}
	}
	/**
	 * 比较大小  k<j true
	 * @param k
	 * @param j
	 * @return
	 */
	public boolean less(int k,int j) {
		return pq[k].compareTo(pq[j]) < 0;
	}
	/**
	 * 交换两元素
	 * @param k
	 * @param j
	 */
	public void exch(int k,int j) {
		Key t=pq[k];
		pq[k]=pq[j];
		pq[j]=t;
	}
	/**
	 * 删除指定位置的元素
	 * @param k
	 * @return
	 */
	public Key delete(int k) {
		if(k>N) {
			return null;
		}
		if(k<start) {
			return null;
		}
		Key item=pq[k];
		exch(k,N);
		N--;
		swim(k);
		sink(k);
		pq[N+1]=null;
		return item;
		
	}
	//获取父节点 根据最基本的情况分析
	public int getFather(int son) {
		return (son-(start-1)+(treeSize-2))/treeSize+start-1;
	}
	//获取子节点  根据最基本的情况分析
	public int getSon(int father) {
		return (father-(start-1))*treeSize+(start-1)-(treeSize-2);
	}
	
	public List getAll() {
		return Arrays.asList(pq);
	}
	
}