最大（小）堆的实现

//当前节点的父亲节点
int parent(int i) {
	return (i-1)>>1;
}

//当前节点的左儿子
int left(int i) {
	return (i<<1) + 1;
}

//当前节点的右儿子
int right(int i) {
	return (i<<1) + 2;
}

#ifdef RECURRENCE	//使用递归调整节点，使其满足最大（小）堆性质

template<typename T>
void Max_Heapify(T* a, int n, int i) 
{
	int l = left(i);
	int r = right(i);
	int largest;
	if(l<n && a[l]>a[i]) {
		largest = l;
	} else {
		largest = i;
	}
	if(r<n && a[r]>a[largest]) {
		largest = r;
	}

	if(largest != i) {
		swap(a[largest],a[i]);
		Max_Heapify(a,n,largest);
	}
}

template<typename T>
void Min_Heapify(T* a, int n, int i) 
{
	int l = left(i);
	int r = right(i);
	int minest;
	if(l<n && a[l]<a[i]) {
		minest = l;
	} else {
		minest = i;
	}
	if(r<n && a[r]<a[minest]) {
		minest = r;
	}

	if(largest != i) {
		swap(a[minest],a[i]);
		Max_Heapify(a,n,minest);
	}
}


#else		//使用非递归调整节点，使其满足最大（小）堆性质

template<typename T>
void Max_Heapify(T* a, int n, int i) 
{
	int pointer = i;
	while(pointer < n/2) {
		int l = left(pointer);
		int r = right(pointer);
		int largest;
		if(l<n && a[l]>a[pointer]) {
			largest = l;
		} else {
			largest = pointer;
		}
		if(r<n && a[r]>a[largest]) {
			largest = r;
		}

		if(largest != pointer) {
			swap(a[largest],a[pointer]);
			pointer = largest;
		} else {
			break;
		}
	}
}

template<typename T>
void Min_Heapify(T* a, int n, int i) 
{
	int pointer = i;
	while(pointer < n/2) {
		int l = left(pointer);
		int r = right(pointer);
		int minest;
		if(l<n && a[l]>a[pointer]) {
			minest = l;
		} else {
			minest = pointer;
		}
		if(r<n && a[r]>a[minest]) {
			minest = r;
		}

		if(largest != pointer) {
			swap(a[minest],a[pointer]);
			pointer = minest;
		} else {
			break;
		}
	}
}
#endif

//建立最大堆
template<typename T>	
void Build_MaxHeap(T *a, int n) {
	int pointer = n/2 - 1;
	while(pointer >= 0) {
		Max_Heapify(a,n,pointer);
		pointer --;
	}
}

//建立最小堆
template<typename T>
void Build_MinHeap(T *a, int n) {
	int pointer = n/2 - 1;
	while(pointer >= 0) {
		Min_Heapify(a,n,pointer);
		pointer --;
	}
}