【堆排】为何使用向下调整法建堆比向上调整法建堆更好呢?

文章目录

  • 前言
  • 一、堆排代码
  • 一、计算使用==向上调整法==建堆的时间复杂度
  • 二、计算使用==向下调整法==插入的时间复杂度
  • 总结

前言

在博主的上一篇博客堆排(链接在这里点击即可)的总结中提出啦使用向下调整法建堆比使用向上调整法建堆更好,是因为使用向上调整法建堆的时间复杂度为O(n*logn),使用向下调整法建堆的时间复杂度为O(n)。接下来博主就教大家如何计算它们的时间复杂度。


一、堆排代码

c 复制代码
void Swap(int* x, int* y)
{
	int tmp = *x;
	*x = *y;
	*y = tmp;
}
//向上调整法
void AdjustUp(HPDataType* arr, int child)
{
	int parent = (child - 1) / 2;

	while (child > 0)//不需要等于,child只要走到根节点的位置,根节点没有父节点不需要交换
	{
		if (arr[child] < arr[parent])//若孩子结点比父结点小则交换
		{
			Swap(&arr[parent], &arr[child]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}
//向下调整法
void AdjustDown(HPDataType* arr, int parent, int n)
{
	int child = parent * 2 + 1;//左孩子

	while (child < n)
	{
		//找左右孩子中找最小的
		if (child + 1 < n && arr[child] > arr[child + 1])
		{
			child++;
		}
		if (arr[child] < arr[parent])
		{
			Swap(&arr[child], &arr[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}
//堆排
void HeapSort(int* arr, int n)
{
	//向上调整法建堆
	for (int i = 0; i < n; i++)
	{
		AdjustUp(arr, i);
	}

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

	//循环将堆顶数据跟最后位置的数据进行交换
	int end = n - 1;
	while (end > 0)
	{
		Swap(&arr[0], &arr[end]);
		AdjustDown(arr, 0, end);
		end--;
	}
}

一、计算使用向上调整法建堆的时间复杂度

c 复制代码
for (int i = 0; i < n; i++)
{
	AdjustUp(arr, i);
}
  • 第1层,20个结点,最多需要向上移动0次。
  • 第2层,21个结点,最多需要向下移动1次。
  • 第3层,22个结点,最多需要向上移动2次。
  • ...
  • 第h-1层,2h-2个结点,最多需要向上移动h-2次。
  • 第h层,2h-1个结点,最多需要向上移动h-1次。
    所以最多移动的次数总和为:
    (1) T(h) = 20(0)+21 (1)+22(2)+...+2h-2 (h-2)+2h-1(h-1)
    (2) 2T(h) = 21(0)+22 (1)+23(2)+...+2h-1 (h-2)+2h(h-1)
    (2)-(1) 得
    T(h) = -(21+22+23+...+2h-2+2h-1+2h-1)+2hh
    使用高中阶段学过的等比数列求和公式:S = a1
    (1-qn)/1-q可得
    T(h) = 2(1-2h)+2hh = 2+2h(h-2)
    再根据二叉树的性质:n = 2h-1,h = log2(n+1)可得
    T(n) = 2 + (n+1)(log2(n+1)-2) = (n+1)log2(n+1)-2
    n
    所以向上调整法建堆的时间复杂度为O(logn*n)

二、计算使用向下调整法插入的时间复杂度

c 复制代码
for (int i = (n-1-1)/2; i >= 0; i--)
{
	AdjustDown(arr, i , n);
}
  • 第1层,20个结点,最多需要向下移动h-1次。
  • 第2层,21个结点,最多需要向下移动h-2次。
  • 第3层,22个结点,最多需要向下移动h-3次。
  • ...
  • 第h-1层,2h-2个结点,最多需要向下移动1次。
  • 第h层,2h-1个结点,最多需要向下移动0次。

所以最多移动的次数总和为:
(1) T(h) = 20(h-1)+21 (h-2)+22(h-3)+...+2h-2 (1)
(2) 2T(h) = 21(h-1)+22 (h-2)+23(h-3)+...+2h-1 (1)
(2)-(1) 得
T(h) = 21+22+23+...+2h-2+2h-1-20(h-1)
T(h) =20+ 21+22+23+...+2h-2+2h-1-h
使用高中阶段学过的等比数列求和公式:S = a1
(1-qn)/1-q可得
T(h) = 2h-1-h
再根据满二叉树的性质:n = 2h-1,h = log2(n+1)可得
T(n) = n-log2(n+1)
*
所以向下调整法建堆的时间复杂度为O(n)


总结

通过这篇博客相信柚柚们已经清楚向下调整法建堆和向上调整法建堆的时间复杂度怎么计算啦,后期博主还会更新有关数据结构的博客,感兴趣的柚柚们可以关注博主喔~

相关推荐
好易学·数据结构9 小时前
可视化图解算法56:岛屿数量
数据结构·算法·leetcode·力扣·回溯·牛客网
Ashlee_code15 小时前
裂变时刻:全球关税重构下的券商交易系统跃迁路线图(2025-2027)
java·大数据·数据结构·python·云原生·区块链·perl
闻缺陷则喜何志丹15 小时前
【带权的并集查找】 P9235 [蓝桥杯 2023 省 A] 网络稳定性|省选-
数据结构·c++·蓝桥杯·洛谷·并集查找
jie*15 小时前
python(one day)——春水碧于天,画船听雨眠。
开发语言·数据结构·python·算法·线性回归
草莓熊Lotso17 小时前
【LeetCode刷题指南】--数组串联,合并两个有序数组,删除有序数组中的重复项
c语言·数据结构·其他·刷题
weixin_4196583117 小时前
数据结构之B-树
java·数据结构·b树
H_HX_xL_L17 小时前
数据结构的算法分析与线性表<1>
数据结构·算法
overFitBrain17 小时前
数据结构-2(链表)
数据结构
xienda17 小时前
数据结构排序算法总结(C语言实现)
数据结构·算法·排序算法
科大饭桶17 小时前
数据结构自学Day8: 堆的排序以及TopK问题
数据结构·c++·算法·leetcode·二叉树·c