2024年C C++最新植物大战堆排序——纯C_堆排序每层最坏调整多少次，循序渐进-CSDN博客

本文链接：https://blog.csdn.net/2401_84978559/article/details/138786754

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

注意：
1.注意循环结束条件，和if语句里的边界问题child + 1 < n
2.注意完全二叉树父子关系公式

#include <stdio.h>
//交换
void swap(int\* x, int\* y)
{
	int t = 0;
	t = \*x;
	\*x = \*y;
	\*y = t;
}
//向下调整
void AdjustDown(int\* a, int n, int root)
{
	int parent = root;
	int child = parent \* 2 + 1;
	
	while (child  < n)
	{
		//每次调整都需要从左右两边选出孩子最大的那个
		//假设坐孩子较大，选出左右孩子大的那个
		if (child + 1 < n && a[child + 1] > a[child])
		{
			++child;
		}
		//开始调整。
		if (a[child] > a[parent])
		{
			swap(&a[child], &a[parent]);
			parent = child;
			child = parent \* 2 + 1;
		}
		//不满足就跳出，开始下次for循环调整。
		else
		{
			break;
		}
	}

}
void HeapSort(int\* a, int n)
{
	//向下调整建堆
	int i = 0;
	for (i = (n - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(a, n, i);
	}
}
int main()
{
	int arr[] = { 4,2,7,8,5,1,0,6 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	HeapSort(arr, sz);
	return 0;
}

2.向下调整排序

调整思路

1.从堆底依次和堆顶的数据进行交换。
2.对交换后的 堆顶的值 进行向下调整。向下调整时请无视交换到堆底那个最大的值。
3.继续循环第一步和第二步，直到到正数第二个数结束。

排序整体代码

void swap(int\* x, int\* y)
{
	int t = 0;
	t = \*x;
	\*x = \*y;
	\*y = t;
}
void AdjustDown(int\* a, int n, int root)
{
	int parent = root;
	int child = parent \* 2 + 1;
	
	while (child  < n)
	{
		//每次调整都需要从左右两边选出孩子最大的那个
		//假设坐孩子较大，选出左右孩子大的那个
		if (child + 1 < n && a[child + 1] > a[child])
		{
			++child;
		}
		//开始调整。
		if (a[child] > a[parent])
		{
			swap(&a[child], &a[parent]);
			parent = child;
			child = parent \* 2 + 1;
		}
		//不满足就跳出，开始下次for循环调整。
		else
		{
			break;
		}
	}

}
void HeapSort(int\* a, int n)
{
	//向下调整建堆
	int i = 0;
	for (i = (n - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(a, n, i);
	}
	//向下调整排序
	int end = 0;
	for (end = n-1; end > 0; end--)
	{
		swap(&a[0], &a[end]);
		//向下调整时无视最大的那个值，所以end是n-1。
		AdjustDown(a, end, 0);
	}
}
int main()
{
	int arr[] = { 4,2,7,8,5,1,0,6 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	HeapSort(arr, sz);
	return 0;
}

3.时间复杂度(难点)

向下建堆O(N)

//向下调整建堆
	int i = 0;
	for (i = (n - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(a, n, i);
	}

很多人的误区在于他的时间复杂度是N*Log2N。这是错误的。
时间复杂度的计算是看思想，而不是看循环猜测。
当是满二叉树，在最坏的情况下，除了最后一层，上面所有层都需要进行向下调整。
最坏情况下的调整次数 = 每层数据个数 * 向下调整次数

第一层向下调整次数是h-1，节点个数是21-1
第二层向下调整次数是h-2, 节点个数是22-1
第h-1层向下调整次数是1,节点个数是2h-1-1

所以总的调整次数为n：
n = 20*(h-1) + 21 *(h-2)+… + 2h-1-1 *(1)
根据高中错位相减得到
n = 1−h+21+22+…+2h−2+2h−1
由等比数列前n项和得到
n = 2h−h−1
由二叉树性质N=2h−1和 h = log2(N+1) 得到
n=N−log2(N+1)
大O渐进表示法为n= O(N)