为什么在BuildHeap中siftdown要优于siftup

一.定义一个Array-based MaxHeap

class MaxHeap{
private:
	int size;
	int n;
	int* Heap;
	void siftdown(int);
	void siftup(int);
public:
	void BuildHeapDown();
	void BuildHeapUp();
	bool RemoveMax();
	bool isleaf(int pos){
		return (pos > (n/2 - 1));
	}
	int parent(int pos){
		return floor((pos-1)/2);
	}
}

二. 使用siftdown构建BuildHeap

void MaxHeap::siftdown(int pos){
	while(!isleaf(pos)){
		int j = 2*pos+1;
		int rc = 2*pos+2;
		if(Heap(j) < Heap(rc)) j = rc;  //取两子之大
		if(Heap[pos] < Heap[j]){  //如果pos处值小于子值，那么调换位置
			int temp = Heap[j];
			Heap[j] = Heap[pos];
			Heap[pos] = temp;
			pos = j; //继续向下比较
		}
	}
}
void MaxHeap::BuildHeapDown(){
	//对于非叶子结点，从最后一个节点开始往前依次进行siftdown
	for(int i = (n/2 - 1); i>=0; i--) siftdown(i);
}

时间复杂度: 假设现在有一个满二叉树，node数量为$n$, 最差情况下的时间复杂度为
$$\because Tn=\sum _{i=1}^{\log (n+1)}\left(\log (n+1)-i\right)\ast 2^{i-1}$$$$\text{令d = log(n+1),展开之后利用错位相减法可以求出 }Tn=\frac{n+1}{2}$$$$\therefore Tn=O(n)$$

三. 使用siftup构建BuildHeap

void MaxHeap::siftup(int pos){
	while(pos!=0){//只要不是root，都和自己的parent比较
		if(Heap[pos] > Heap[parent(pos)]){
			int temp = Heap[pos];
			Heap[pos] = Heap[parent(pos)];
			Heap[parent(pos)] = temp;
			pos = parent(pos); //继续向上比较
		}
	}
}
void MaxHeap::BuildHeapUp(){
	for(int i = 1; i<n; i++) siftup(i); // 从第二行开始，逐个进行siftup
}

时间复杂度: 假设现在有一个满二叉树，node数量为$n$, 最差情况下的时间复杂度为
$$\because Tn=\sum _{i=1}^{\log n}{2}^i\cdot i$$$$\therefore Tn=O(n\log n)$$

四.综合分析

（一）时间复杂度方面

首先，我们通过分析，分别计算出了两种建堆方式的时间复杂度。通过计算结果，我们看出通过$siftdown$来进行建堆的时间复杂度更低，为$O(n)$。
其实，从直观角度也可以得到这一结论。首先，我们要明确一点：节点数量随着深度增加是呈指数级增长的，而随着深度的加深，$BuildHeapDown$的调用时间是逐渐变低的。而$BuildHeapUp$的调用时间则会逐渐增加，所以根据$T={\sum }_{i=1}^{n}Time(i)$我们也可以得出$BuildHeapDown$的时间复杂度更低。

（二）对于实现ADT方面

我们采用$siftdown$是更有利于其他算法的实现的。比如在进行$RemoveMax$操作的时候，只需要将root节点和末尾节点换位并修改$n=n-1$，然后进行$siftdown$就可以了。只需要$O(\log n)$的时间；

bool MaxHeap::RemoveMax(int &t){
	if(n==0) return false;
	t = Heap[0]; //保存max
	Heap[0] = Heap[--n] 
	Heap[n] = t;
	if(n!=0) siftdown(0);
	return true;
}