堆基于数据的实现

堆

堆是完全二叉树
底层数组实现-------k结点的两个子节点 2k和2k+1
每个结点都大于他的子节点

Api

public void insert(T t){
	//0索引被废弃
	items[++N] = t;
	swim(N);
}

public void swim(int k){
	//上浮    
	while(k>1){
		if(less(k/2,k)){
			exch(k/2,k);
		}
	}
	k=k/2;
}

public T delMax(){
	T max = item[1];
	exch(1,N);
	items[N] = null;
	N--;
	sink(1);
	return max;
	
	
}

public void sink(int k){
	//下沉
	while(2*k <= N){
		int max ;
		if(2*k+1<=N){
			if(less(2k,2k+1)){
				max = 2*k+1;	
			}else{
				max = 2*k;
			}
			if(!less(k,max)){
			break;
			}
			exch(k,max);
			k=max;
		}
		
	}
}

-堆排序

private static void createHeap(Comparable[] source ,Comparable[] heap){
	System.arraycopy(source,0,heap,1,source.length);
	for(int i =heap.length/2 ; i>0;i--){
		sink(heap,i,heap.length-1);
	}
}

public static void sort(Comparable[] source){
	Comparable[] heap = new Comparable[source.length+1];
	createHeap(source,heap);
	int N = heap.length-1;
	while(N!=1){
		exch(heap,1,N);
		N--;	
		sink(heap,1,N);
	}
	System.arraycopy(heap,1,source,0,source.length); 
}

public static void sink (Comparable[] heap, int target, int range){
	while(2*target<range){
		int max;
		if(2*target+1<=range){
			if(less(heap,a*target,2*target+1)){
				max = 2*target +1 ;
			}else{
				max = 2*target; 
			}
		}else{
			max = 2*target;
		}
		if(!less(heap , target,max)){
		break;}
		exch(heap,target,max);
		target = max ;
	}
}