二叉树，堆排序，向上调整.向下调整算法的实现

树的概念及结构

树是一种非线性的数据结构，有一个特殊的结点，称为根结点，树是递归定义的。表示树结构最优方法：左孩子右兄弟方法

特殊二叉树有以下结构

二叉树的性质

1.若规定根节点的层数为1，则一颗非空二叉树的第i层上最多有2^(i-1)个节点

2.若规定根节点的层数为1，则深度为h的二叉树的最大节点是2^h-1

3.对任何一颗二叉树，如果度为0其叶节点个树为n0，度为2的分支节点个数n2，则有n0=n2+1。4。若规定根节点的层数为1，具有n个节点的满二叉树的深度，h=log2^(n+1)

顺序存储

顺序存储就是用数组来存储，一般使用数组只适合表示完全二叉树，因为不是完全二叉树会有空间的浪费。二叉树顺序存储在物理上是一个数组，在逻辑上是一颗二叉树。

leftchild=parent*2+1    rightchild=parent*2+2    parent=(child-1)/2

堆

逻辑结构：想象出来的--完全二叉树

物理结构：实实在在内存中存储的结构--数组

堆初始化

void HeapInit(HP* hp)
{
	assert(hp);
	hp->a = NULL;
	hp->size = hp->capacity = 0;
}

向上调整算法

void AdjustUp(int* a, int child)
{
	assert(a);
	int parent = (child - 1) / 2;
	while (child>0)//child=0时终止
	{
		if (a[child] > a[parent])
		{
			swap(&a[child], &a[parent]);
			child = parent;
			parent = (child-1)/2;
		}
		else
		{
			break;
		}

	}
}

堆插入

void HeapPush(HP* hp,HPDataType x)
{
	assert(hp);
	if (hp->size == hp->capacity)
	{
		size_t newcapacity = hp->capacity == 0 ? 4 : hp->capacity * 2;
		HPDataType* tmp =realloc(hp->a,sizeof(HPDataType) * newcapacity);
		if (tmp == NULL)
		{
			printf("realloc fail");
			exit(-1);
		}
		hp->a = tmp;
		hp->capacity = newcapacity;
	}
	hp->a[hp->size] = x;
	hp->size++;
	AdjustUp(hp->a, hp->size-1);
}

向下调整算法（前提是左右子树都是小堆）

void AdjustDown(int* a, int n, int parent)
{
	
	int child = parent * 2 + 1;
	while (child < n)
	{
		if (child+1<n&&a[child] > a[child + 1])
		{
			++child;
		}
		if (a[parent] > a[child])
		{
			swap(&a[parent], &a[child]);
			parent = child;
			child = parent * 2 + 1;

		}
		else
		{
			break;
		}
	}
}

堆删除

void HeapPop(HP* hp)
{
	assert(hp);

	swap(hp->a[0], hp->a[hp->size - 1]);
	hp->size--;
	AdjustDown(hp->a, hp->size, hp->a[0]);
}

堆排序

首先如果排降序就得用小堆，为什么呢？

如果排降序用大堆，虽然第一个数是对的，但是第二个数就要通过建堆去确认，但第二个数去建堆就会打乱原来所有后面堆的排布关系，只能重新建堆。如果我们建小堆，第一个数就是最小的，将第一个数与最后一个数交换，然后将最后一个数（此时最后一个数是最小的一个数）排除在堆之外，再进行向下调整算法，就能排出降序了，堆排序的时间复杂度是（n*log^n）

向下调整前提：左右子树都是堆

代码如下

void HeapSort(int* a, int n)
{
	/*for (int i = 1; i < n; i++)
	{
		AdjustUp(a, i);
	}*/
	for (int i = (n - 1 - 1) / 2; i >= 0; i--)//一定要走到根上去>0就是错的
	{
		AdjustDown(a,n,i);//排降序建小堆
	}
	for (int end = n - 1; end > 0; end--)
	{
		swap(&a[0], &a[end]);
//将最小的一个放到最后一个去，此时最大的数在堆顶，执行下一步AdjustDown
		AdjustDown(a, end, 0);
	
	}
}

建堆既可以用向下调整算法也可以用向上调整算法，但用向下调整算法建堆是用向下调整算法，排序也是用向下调整算法只用一个向下调整算法就可以

topK问题。在n个数中找出最大(最小)的前K个数

1.先排降序，前k个就是最大的，时间复杂度是（n*log^n),但这个把全部都排好了

2.排大堆，如果数大于堆顶就删除堆顶，每次取堆顶就前k个，时间复杂度（n+k*log^n）

3.假设n非常大，内存中存不下这些数，方法1.2都不能用了

方法3：建k个值的小堆，如果剩下n-k个值有值大于堆顶就入数据，然后向下调整，时间复杂度（k+(n-k)*log^k),因为k很小所以时间复杂度就是n*log^k

topK代码

void PrintTopK(int* a,int n,int k)
{
	HP hp;
	HeapInit(&hp);
	//建立一个大小为k的小堆
	for (int i = 0; i < k; i++)
	{
		HeapPush(&hp,a[i]);
	}
	//剩下n-k个数与栈顶比较，比他大就替换进堆
	for (int i = k; i < n; i++)
	{
		if (a[i] > HeapTop(&hp))
		{
			hp.a[0] = a[i];
			AdjustDown(hp.a, hp.size, 0);
		}
	}
	HeapPrint(&hp);
	HeapDestory(&hp);
}

建堆时间复杂度证明