C语言植物大战数据结构堆排序图文示例

 更新时间:2022年05月10日 17:53:57   作者:_奇奇  
这篇文章主要为大家介绍了C语言植物大战数据结构堆排序的图文示例详解,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步,早日升职加薪

“大弦嘈嘈如急雨,小弦切切如私语”“嘈嘈切切错杂弹,大珠小珠落玉盘”

C语言朱武大战数据结构专栏

C语言植物大战数据结构快速排序图文示例

C语言植物大战数据结构希尔排序算法

C语言植物大战数据结构二叉树递归

TOP.堆排序前言

什么是堆排序?假如给你下面的代码让你完善堆排序,你会怎么写?你会怎么排?

void HeapSort(int* a, int n)
{
}
int main()
{
	int arr[] = { 4,2,7,8,5,1,0,6 };
	int sz = sizeof(arr) / sizoef(arr[0]);
	HeapSort(arr, sz);
	return 0;
}

堆排序就是利用堆这个数据结构,对一组数据进行排序。

所以说,堆排序整体分两步完成。

第一步,建堆

第二步,进行排序

注意:以下代码针对的是对一组 数据 排升序

一、向下调整堆排序

对的,向下调整方法,是最优秀的堆排序。

不是太想介绍那种向上调整拉胯的堆排序,我们经常用的是这种优秀的向下排序。

二者区别在于建堆的方法不同。一个是向下建堆O(N),一个是向上建堆O(N*logN)。

具体证明用到了高中 简单的数列公式。

1.向下调整建堆

建堆的技巧

向下建堆也有两种情况。

1.建大堆

2.建小堆

那么到底建大堆还是小堆呢?

解释:建堆在于你是想要排升序,还是排降序。假如建的大堆,因为堆顶的数是最大的,在我们对堆 向下调整排序时,这时候每次都需要把最大的交换到堆底。所以导致最后堆的顺序是升序。

建大堆前

建大堆后

向下调整排序后

此时数组就有序了。

结论:实质是在数组上建堆。排升序建大堆,排降序建小堆。

建堆思路代码

思路:

因为叶子结点本身就是一个大堆,所以从最后一个叶子结点的父亲结点开始进行向下建堆。

这样就能够保证每次建的堆都是大堆。

注意:

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)

向下调整(N*LogN)

需要向下调整n-1次。每次需要调整的高度为LogN,N为节点的个数,因为节点个数每次少一个。

所以n-1次调整总次数 = log2+log3+…+log(n-1)+log(n)≈log(n!)

由数学知识得log(n!)和nlog(n)是同阶函数。

所以向下调整排序时间复杂度为N*LogN

所以堆排序时间复杂度为:N + N*LogN

大O渐进表示法为:O(N*LogN)

总结:堆排序时间复杂度 O(N*LogN)

二、向上调整堆排序

向上调整排序和向下调整排序的唯一不同在于建堆的不同,导致二者的建堆的时间复杂度略微不同。

1.向上调整建堆

向上调整建堆时间复杂度为N*LogN.具体原因还需要经过残酷的数学计算。孩子不会啊。但是经过网上查阅资料我又找到了计算方法。如图。

根据二叉树的性质:h = Log2(N+1)

可以将T(h) = 2h * (h-2) + 2换为:

所以总体来说就是向上调整的建堆时间复杂度为O(N * LogN).

2.建堆代码

思路:从第二个元素开始,只关注前两个元素建堆,然后再依次增加元素建堆,使它一直为堆。

向上调整建堆虽然时间复杂度略高,但是代码相对于向下调整简单一点点。

void AdjustUp(int* a, int child)
{
	//先把父亲节点表示出来。
	int parent = (child - 1) / 2;
	while (child > 0)
	{
		//比较孩子和父亲,开始向上调整。
		if (a[child] > a[parent])
		{
			swap(&a[child], &a[parent]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

以上就是C语言植物大战数据结构堆排序图文示例的详细内容,更多关于C语言数据结构堆排序的资料请关注脚本之家其它相关文章!

相关文章

  • c++11之std::async 和std::thread的区别小结

    c++11之std::async 和std::thread的区别小结

    std::async和std::thread都是C++11中提供的线程库,它们都可以用于创建新线程,本文主要介绍了c++11之std::async 和std::thread的区别小结,感兴趣的可以了解一下
    2024-02-02
  • C语言 深入理解动态规划之计数类DP

    C语言 深入理解动态规划之计数类DP

    动态规划可谓是大名鼎鼎,笔试面试中的高频考点,也是重点难点,动态规划类型题目灵活多变,难度系数也相对较高,往往我们做不好动态规划的题目就会与心仪的offer失之交臂,本篇文章我们就一起来研究一下动态规划的计数类DP
    2022-04-04
  • C++实现LeetCode(131.拆分回文串)

    C++实现LeetCode(131.拆分回文串)

    这篇文章主要介绍了C++实现LeetCode(131.拆分回文串),本篇文章通过简要的案例,讲解了该项技术的了解与使用,以下就是详细内容,需要的朋友可以参考下
    2021-07-07
  • VS2019配置BOOST的方法(v1.70.0库)

    VS2019配置BOOST的方法(v1.70.0库)

    这篇文章主要介绍了VS2019配置BOOST的方法(v1.70.0库),文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
    2020-08-08
  • 深入浅析 C++ 调用 Python 模块

    深入浅析 C++ 调用 Python 模块

    Python 提供了 C++ 库,使得开发者能很方便地从 C++ 程序中调用 Python 模块。接下来通过本文给大家介绍 C++ 调用 Python 模块的相关知识,需要的朋友参考下吧
    2016-03-03
  • C++库std::flush的具体使用

    C++库std::flush的具体使用

    std::flush是C++标准库中的一个操作符,用于刷新输出流,本文主要介绍了C++库std::flush的具体使用,具有一定的参考价值,感兴趣的可以了解一下
    2024-02-02
  • c++字符串char[]数组分割split问题

    c++字符串char[]数组分割split问题

    这篇文章主要介绍了c++字符串char[]数组分割split问题,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教
    2023-09-09
  • C++ 构造双向链表的实现代码

    C++ 构造双向链表的实现代码

    本篇文章是对C++中构造双向链表的实现代码进行了详细的分析介绍,需要的朋友参考下
    2013-05-05
  • Visual Studio Code上添加小程序自动补全插件的操作方法

    Visual Studio Code上添加小程序自动补全插件的操作方法

    这篇文章主要介绍了Visual Studio Code上添加小程序自动补全插件的操作方法,本文给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
    2021-04-04
  • C/C++函数的调用约定的使用

    C/C++函数的调用约定的使用

    本文主要介绍了C/C++函数的调用约定的使用,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
    2022-06-06

最新评论