C语言实现堆排序

已于 2024-04-16 23:23:16 修改
阅读量1.1k 收藏 21
点赞数 24
分类专栏： 数据结构从入门到入土 文章标签： c语言 开发语言 c++ 数据结构 算法
于 2023-12-03 23:15:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73975164/article/details/134756607
版权

目录

前言

数组建堆

堆排序

利用向上/下调整算法将数组中的数字在虚拟逻辑上重新变为大/小堆与重新建堆的区别是？

利用向上调整算法实现堆排序（升序）

利用向下调整算法实现堆排序（降序） 

利用向下调整算法实现堆排序（升序） 

序列文章

初识树（C语言）：http://t.csdnimg.cn/eqFmT

二叉树的基本概念（C语言）：http://t.csdnimg.cn/AkwTC

大小堆的实现（C语言）：http://t.csdnimg.cn/yoXVC

看了就会的堆排序（C语言）：http://t.csdnimg.cn/EWzgM

top K问题（借你五分钟）：http://t.csdnimg.cn/1YLT8

堆的相关时间复杂度计算（C语言）：http://t.csdnimg.cn/OSAr4

二叉树的前、中、后序遍历的实现：http://t.csdnimg.cn/xNHrs

计算二叉树结点个数、叶子结点个数的代码实现：http://t.csdnimg.cn/kiBpd

二叉树查找值为x的结点、树的高度、第k层结点个数的代码实现：http://t.csdnimg.cn/BcFEW

二叉树的创建、销毁、层序遍历、层序遍历进阶的代码实现： http://t.csdnimg.cn/Qlxu0

二叉树的OJ练习（一）：http://t.csdnimg.cn/jhOWW

二叉树的OJ练习（二） ：http://t.csdnimg.cn/sl7kl

<你想看的我这里都有😎 >

数组建堆

我们能不能不消耗空间就完成一次建堆？直接将所给的数组建堆可以吗？

这些数字在物理逻辑上是一个数组，而在虚拟逻辑上是一个完全二叉树，那么将这个完全二叉树进行一些调整后是不是就能得到一个堆呢？我们尝试利用之前的向上调整算法，完成建堆的操作：

上述操作的本质就是模拟堆插入的过程建堆

（第一个视为堆，第二个插入然后向上调堆、第一个和第二个视为堆，第三个插入然后向上调堆）

可以发现我们在没有申请内存空间的前提下，仅利用一个向上调整算法就完成了将数组建小堆的操作，但是如果我们在选出这个小堆中的最小值后，再想要选出这个堆中的次小值就会出现问题：

可以发现当要选出次小值时，缺少了”1“的小堆的剩余元素并不能算作是一个小堆，所以为了选出次小值，我们还要建堆，以此类推这就相当于选一次值就要建一次堆，那还不如直接选用时间复杂度为O（n）的暴力遍历数组选取最小或次小值，而我们建堆的目的就是为了方便我们选出我们想要的最大/小、次大/小的值，但是很明显如果仅利用向上调整算法建立一个小堆是无法满足我们的需求的，所以我们应该利用向上调整算法去建立一个大堆

关于为什么要重新建堆而不是调整的解释：

        当我们取出最大值1后，小堆的性质被破坏了。由于元素1被移除，并且无法通过向下调整操作来恢复小堆性质（即使你将大于号与小于号互换），所以我们需要重新建立一个有效的小堆，这就显得很麻烦了。

结论：仅用向上调整算法建小堆，若取出最小值，那么剩下的数有可能不是堆，故应建大堆 

只需要该算法做一些调整，将(a[child] < a[parent])变为(a[child] > a[parent])，就可以建大堆：

调整后的结果是我们得到了一个大堆，此时即使将堆顶的“9”删除，剩余的两个子树也仍然保留大堆的性质，这就意味着我们在选出最小数及次小数后只需要进行向下调整即可不需要考虑重新建堆，当我们想要最大值，只需要交换首尾元素的位置，然后将尾部元素不再视为堆的一部分即可，此时就相当于获取了堆中的最大值，想要获取次大值重复以上操作即可：

取出（不再视为堆的一部分）即选出该数

堆排序

        其实上述的内容，就是我们实际中堆排序的一种实现方式，即利用向上调整算法建大堆然后再利用向下调整算法将挑选后剩余的元素重新调整为虚拟逻辑上的大堆以便下一次的选取。

堆排序本质上是一种选择排序（Selection Sort）

利用向上/下调整算法将数组中的数字在虚拟逻辑上重新变为大/小堆与重新建堆的区别是？

在堆排序算法中，我们需要构建一个最大/小堆来进行排序。这可以通过两种方式实现：

1. 重新建堆：这是一种直接的方法，从数组的首元素开始逐个插入到空堆中，步骤如下：

  • 创建一个空的堆
  • 将数组中的元素逐个插入到空堆中
  • 最终得到了一个满足最大（或最小）堆性质的完整二叉树

2. 向上/下调整：这是一种当已有部分构成的近似完全二叉树进行调整来达到目标状态的方法

  • 向上调整：从某节点开始，将其与父节点比较并交换位置，直至满足最大/小堆性质。该过程会将当前节点及其祖先节点推向正确位置，并保持子树仍然满足对应性质
  • 向下调整：从某节点开始，将其与左右子节点比较并交换位置，直至满足最大/小堆性质。该过程会使当前节点及其后代子树变为有序树，并保持其他部分仍然满足对应性质

3、区别：

  1. 重新建堆是一种从零开始构建堆的方法，它将整个数组视为初始状态，并按顺序插入元素来构建最大（或最小）堆。这种方法需要较多的时间和空间复杂度。
  2. 向上调整和向下调整算法是在已有部分近似完全二叉树的基础上进行调整，通过比较节点与其父节点或子节点来达到维护最大（或最小）堆性质的目标。这两种算法可以在不重建完全二叉树的情况下对特定位置进行优化操作，因此具有更高效率。

4、总结：

  1. 如果已拥有一个无序数组并希望将其转换为一个满足最大/小堆性质的完全二叉树，则可以使用重新建堆方法
  2. 如果你已经拥有一个近似完全二叉树，并且只需对其中某些位置进行修正以满足最大（或最小）堆性质，则应使用向上调整或向下调整算法

利用向上调整算法实现堆排序（升序）

使用向上调整算法实现堆排序的步骤如下：

  1. 构建大堆：从数组的第一个非叶子节点开始，依次对每个节点进行向上调整操作，使其满足最大堆性质。

  2. 维护：交换首尾元素，并将末尾元素从堆中移除。然后对新的根节点进行一次向下调整操作，以维持最大堆性质，重复这个过程直到所有元素都被移除并排好序。

具体代码如下：

#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <stdbool.h>

typedef int HPDataType;
typedef struct Heap
{
	HPDataType* a;  //指向存储元素的指针
	int capacity;	//当前顺序表容量
	int size;		//当前顺序表的长度
}HP;

//交换父子位置
void Swap(HPDataType* p1,HPDataType* p2)
{
	HPDataType* tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

//向上调整，此时传递过来的是最后一个孩子的元素下标我们用child表示
void AdjustUP(HPDataType* a,int child)
{
	//由于我们要调整父亲与孩子的位置所以此时也需要父亲元素的下标，而0父亲元素的下标值 = （任意一个孩子的下标值-1）/ 2 
	int parent = (child - 1) / 2;
	//当孩子等于0的时位于树顶（数组首元素的位置），树顶元素没有父亲，循环结束
	while(child > 0)
	{
		//如果孩子还未到顶且它的下标对应的元素值小于它的父亲的下标对应的元素值，就将父子位置交换，交换玩后还要将下标对应的值“向上移动”
		if (a[child] > a[parent])
		{
			Swap(&a[child], &a[parent]);
			child = parent;
			parent = (child - 1) / 2;
		}
		//由于这是一个小堆，所以当孩子大于等于父亲时不需要交换，直接退出循环即可
		else
		{
			break;
		}
	
	}
}

//向下调整算法
void AdjustDown(HPDataType* a, int size, int parent)
{
	//根据之前的推论，左孩子的下标值为父亲下标值的两倍+1，左孩子的下标值为父亲下标值的两倍+2
	int child = parent * 2 + 1;
	//循环结束的条件是走到叶子结点
	while (child < size)
	{
		//假设左孩子小，若假设失败则更新child，转换为右孩子小，同时保证child的下标不会越界
		if (child + 1< size && a[child + 1] > a[child])
		{
			++child;
		}

		if (a[child] > a[parent])
		{
			//如果此时满足孩子小于父亲则交换父子位置，同时令父亲的下标变为此时的儿子所在下标，儿子所在下标变为自己的儿子所在的下标（向下递归）
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		//如果父亲小于等于左孩子就证明删除后形成的新堆是一个小堆，不再需要向下调整算法，循环结束
		else
		{
			break;
		}
	}
}

//降序堆排序
void HeapSort(int* a, int n)
{
	//构建大堆
	for (int i = 1; i < n; i++)
	{
		AdjustUP(a, i);
	}
	
    //维护
	int end = n - 1;
	while (end > 0)
	{
		Swap(&a[0], &a[end]);
		AdjustDown(a, end, 0);
		--end;
	}

}

int main()
{
	int a[] = { 4,6,2,1,5,8,2,9 };
	HeapSort(a, sizeof(a) / sizeof(int));
	for (int i = 0; i < sizeof(a) / sizeof(int); i++)
	{
		printf("%d ", a[i]);
	}
	//HeapSort(a, i);
	return 0;
}

仅利用向上调整算法建大堆的结果： 

建大堆后利用向下调整算法升序堆排序的结果：

画图演示如下：

向上调整算法建大堆

向下调整算法升序堆排序：

 

由于是手绘的，字迹不好看请见谅 

但其实相比于写一个向上调整算法去建堆，然后再写一个向下调整算法去维护堆，最后完成升序堆排序，我们其实可以仅利用向下调整算法实现这些内容，并不需要额外的编写向上调整算法，同时向下调整算法的时间复杂度为O（N）而向上调整算法的时间复杂度为O（N*logN），向下调整算法的时间复杂度要小于向上调整算法的时间复杂度......

利用向下调整算法实现堆排序（降序） 

使用向下调整算法实现降序堆排序的步骤如下：

  1. 构建小堆：从数组的最后一个非叶子节点开始，向上遍历到根节点，对于当前节点，比较它与其左右子节点的值，并找到其中最小的值和对应索引，如果当前节点的值大于子节点，则将两者交换位置，将当前节点更新为被交换过后的子节点，并重复步骤2和3，直到达到叶子结点或不需要再进行交换。

  2. 维护：将根节点（数组首元素）与末尾元素交换位置，并将末尾元素从堆中移除。然后对新的根节点进行一次向下调整操作，以维持最小堆性质。重复这个过程直到所有元素都被移除并排好序。

#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <stdbool.h>

typedef int HPDataType;
typedef struct Heap
{
	HPDataType* a;  //指向存储元素的指针
	int capacity;	//当前顺序表容量
	int size;		//当前顺序表的长度
}HP;

//交换父子位置
void Swap(HPDataType* p1,HPDataType* p2)
{
	HPDataType* tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

//向下调整算法
void AdjustDown(HPDataType* a, int size, int parent)
{
	//根据之前的推论，左孩子的下标值为父亲下标值的两倍+1，左孩子的下标值为父亲下标值的两倍+2
	int child = parent * 2 + 1;
	//循环结束的条件是走到叶子结点
	while (child < size)
	{
		//简单来说就是看俩子结点谁更小
		//假设左孩子小，若假设失败则更新child，转换为右孩子小，同时保证child的下标不会越界
		if (child + 1< size && a[child + 1] < a[child])
		{
			++child;
		}

		if (a[child] < a[parent])
		{
			//如果此时满足孩子小于父亲则交换父子位置，同时令父亲的下标变为此时的儿子所在下标，儿子所在下标变为自己的儿子所在的下标（向下递归）
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		//如果父亲小于等于左孩子就证明删除后形成的新堆是一个小堆，不再需要向下调整算法，循环结束
		else
		{
			break;
		}
	}
}


//堆排序
void HeapSort(int* a, int n)
{
    //构建小堆
	for(int i = (n-1-1)/2;i>=0;--i)
    {
        AdjustDown(a,n,i);
    }
	
    //维护
	int end = n - 1;
	while (end > 0)
	{
		Swap(&a[0], &a[end]);
		AdjustDown(a, end, 0);
		--end;
	}

}

int main()
{
	int a[] = { 4,6,2,1,5,8,2,9 };
	HeapSort(a, sizeof(a) / sizeof(int));
	for (int i = 0; i < sizeof(a) / sizeof(int); i++)
	{
		printf("%d ", a[i]);
	}
	//HeapSort(a, i);
	return 0;
}

仅利用向下调整算法建小堆的结果： 

建小堆后利用向下调整算法降序堆排序的结果：

画图演示如下：

至于为什么在一颗子树上调整的时候就不需要考虑另一颗子树，这是因为我们选出根节点的两个子结点中的最小值了，那么另一个根结点就不可能是整个堆的次小值，所以我们转换为从另一子结点开始......

利用向下调整算法实现堆排序（升序） 

使用向下调整算法实现升序堆排序的步骤如下：

  1. 构建大堆：从数组的最后一个非叶子节点开始，向上遍历到根节点，对于当前节点，比较它与其左右子节点的值，并找到其中最大的值和对应索引，如果当前节点的值小于子节点，则将两者交换位置，将当前节点更新为被交换过后的子节点，并重复步骤2和3，直到达到叶子结点或不需要再进行交换。

  2. 维护：将根节点（数组首元素）与末尾元素交换位置，并将末尾元素从堆中移除。然后对新的根节点进行一次向下调整操作，以维持最大堆性质。重复这个过程直到所有元素都被移除并排好序。

#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <stdbool.h>

typedef int HPDataType;
typedef struct Heap
{
	HPDataType* a;  //指向存储元素的指针
	int capacity;	//当前顺序表容量
	int size;		//当前顺序表的长度
}HP;

//交换父子位置
void Swap(HPDataType* p1,HPDataType* p2)
{
	HPDataType* tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

//向下调整算法
void AdjustDown(HPDataType* a, int size, int parent)
{
	//根据之前的推论，左孩子的下标值为父亲下标值的两倍+1，左孩子的下标值为父亲下标值的两倍+2
	int child = parent * 2 + 1;
	//循环结束的条件是走到叶子结点
	while (child < size)
	{
		//简单来说就是看俩子结点谁更小
		//假设左孩子小，若假设失败则更新child，转换为右孩子小，同时保证child的下标不会越界
		if (child + 1< size && a[child + 1] > a[child])
		{
			++child;
		}

		if (a[child] > a[parent])
		{
			//如果此时满足孩子小于父亲则交换父子位置，同时令父亲的下标变为此时的儿子所在下标，儿子所在下标变为自己的儿子所在的下标（向下递归）
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		//如果父亲小于等于左孩子就证明删除后形成的新堆是一个小堆，不再需要向下调整算法，循环结束
		else
		{
			break;
		}
	}
}


//堆排序
void HeapSort(int* a, int n)
{
    //构建小堆
	for(int i = (n-1-1)/2;i>=0;--i)
    {
        AdjustDown(a,n,i);
    }
	
    //维护
	int end = n - 1;
	while (end > 0)
	{
		Swap(&a[0], &a[end]);
		AdjustDown(a, end, 0);
		--end;
	}

}

int main()
{
	int a[] = { 4,6,2,1,5,8,2,9 };
	HeapSort(a, sizeof(a) / sizeof(int));
	for (int i = 0; i < sizeof(a) / sizeof(int); i++)
	{
		printf("%d ", a[i]);
	}
	//HeapSort(a, i);
	return 0;
}

仅利用向下调整算法建大堆的结果： 

建大堆后利用向下调整算法升序堆排序的结果：

不再画图展示...... 

代码中的注释内容可看可不看 ，懒得改了

结论：在进行升序和降序堆排序时更多的仅使用向下调整算法就可以完成 

关于上述内容涉及的相关时间复杂度的计算，我们放在了：堆的相关时间复杂度计算（C语言） 

~over~

无聊看看天T^T
关注
  • 24
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言实现堆排序代码
weixin_43943137的博客
12-13 981
堆排序
C语言实现堆排序.zip
01-18
C语言实现堆排序，首先需要定义一个用于存储元素的数组，然后编写函数来实现建堆、调整堆和交换元素等操作。以下是一个基本的C语言实现： ```c #include void heapify(int arr[], int n, int i) { int largest =...
堆排序 c语言实现,C语言实现堆排序代码
weixin_35651191的博客
05-20 396
void heapsort(int arr[], unsigned int N){unsigned int n = N, i = n/2, parent, child;int t;for (;;) { /* Loops until arr is sorted */if (i > 0) { /* First stage - Sorting the heap */i--; /...
c语言实现堆排序
qq_52227682的博客
10-23 350
c语言实现堆排序
数据结构c语言版堆排序,数据结构之---C语言实现堆排序
weixin_31164189的博客
05-19 226
过程图如下：(先建堆，在调整，插入，输出)代码：//堆排序(HeapSort)//杨鑫#include #include //堆调整，构建大顶堆，arr[]是待调整的数组，i是待调整的数组//元素的位置，length是数组的长度void HeapAdjust(int arr[], int i, int length){int Child;int temp;for(;2 * i + 1 < l...
c语言堆排序,C语言实现堆排序代码
weixin_39719749的博客
05-20 198
下面是编程之家 jb51.cc 通过网络收集整理的代码片段。编程之家小编现在分享给大家，也给大家做个参考。void heapsort(int arr[],unsigned int N){unsigned int n = N,i = n/2,parent,child;int t;for (;;) { /* Loops until arr is sorted */if (i > 0) { /* ...
C语言实现——堆排序
qq_58417047的博客
08-21 2047
C语言实现——堆排序
堆排序——C语言实现
热门推荐
qq_41890240的博客
03-08 1万+
在实现堆排序之前，我们先讲解一些必备的知识点。 一、什么是堆？ 堆的逻辑结构是完全二叉树； 堆的物理结构是一个数组。 二、堆的分类： 大堆：所有的父亲大于等于孩子； 小堆：所有的父亲小于等于孩子。 三、父亲和孩子的下标关系： leftchild=parent×2+1; rightchild=parent×2+2; parent=(child-1)/2。 四、堆能干什么？ 大堆能保证堆顶的数最大； 小堆能保证堆顶的数最小； 堆排序也正是利用这一特性进行排序的。
小顶堆排序C语言,堆排序原理 C语言实现堆排序及过程详解
weixin_39873741的博客
05-19 326
堆排序就是把最大堆堆顶的最大数取出，将剩余的堆继续调整为最大堆，再次将堆顶的最大数取出(最大堆调整的递归运算)，这个过程持续到剩余数只有一个时结束。在堆中定义以下几种操作：最大堆调整(Max-Heapify):将堆的末端子节点作调整，使得子节点永远小于父节点创建最大堆(Build-Max-Heap):将堆所有数据重新排序，使其成为最大堆堆排序(Heap-Sort):移除位在第一个数据的根节点，并做...
C语言实现----堆排序
qq_53436105的博客
10-12 3885
​ 一、堆排序介绍 堆排序（ Heap Sort ）是指利用堆这种数据结构所设计的一种排序算法。 因此，学习堆排序之前，有必要了解堆！若读者不熟悉堆，建议先了解堆，然后再来学习本章。 我们知道，堆分为"最大堆"和"最小堆"。最大堆通常被用来进行"升序"排序，而最小堆通常被用来进行"降序"排序。 鉴于最大堆和最小堆是对称关系，理解其中一种即可。本文将对最大堆实现的升序排序进行详细说明。 看本文之前可以看看--->>B站视频讲解 最大堆进行升序排序的基本思想： ①初始化堆：将数列 a [1... n
c语言实现堆排序算法 heapsort
04-15
堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。 堆排序的平均时间复杂度为Ο...
C语言实现堆排序的简单实例
09-04
总结来说，这个C语言实现的堆排序实例通过直观的代码展示了如何使用大顶堆原理对数组进行升序排序。通过对代码的理解，我们可以学习到堆排序的基本思想和操作步骤，这有助于我们在其他编程语言中实现类似功能。
C语言实现堆排序heapSort算法
01-18
我们首先实现了swap函数用于交换两个元素的值，然后实现了heapify函数用于调整堆，最后实现了heapSort函数用于进行堆排序。在main函数中，我们定义了一个数组并对其进行堆排序，然后打印排序前后的数组。运行该代码...
贸易常见付款方式D/P，D/A，T/T，L/C
最新发布
王小磊
07-23 537
D/P付款交单代收行必须在进口商付清货款后，才可将商业单据交给进口方D/ADocumentsagainstAcceptance承兑交单出口人的交单以进口人在汇票上承兑为条件，一般承兑时会注明具体付款的日期T/T电汇汇出行应汇款人申请，拍发加押电报给在另一国家的分行或代理行（即汇入行），指示解付一定金额给收款人L/C信用证银行根据进口人（买方）的请求，开给出口人（卖方）的一种保证承担支付货款责任的书面凭证。
主流开发语言和开发环境介绍
weixin_44215445的博客
07-23 1009
主流开发语言和开发环境介绍
C++二叉搜索树
Jk_Mr的博客
07-20 1094
树结构是一种重要的数据结构。树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。
C++ 继承篇
2301_79201049的博客
07-18 700
必须对继承而来的成员进行初始化直接通过初始化列表或者赋值的方式进行初始化调用父类构造函数进行初始化
【C++】操作符“new”和“delete”（创建和销毁对象）
qq_65596720的博客
07-19 391
由于C++引入了类的概念所以创建空间和销毁空间变得复杂，使用malloc和free会更加复杂，所以C++引入了new和delete来简化代码。
用c语言实现堆排序算法
07-29
好的，下面是使用C语言实现堆排序的示例代码： ```c #include void swap(int* a, int* b) { int temp = *a; *a = *b; *b = temp; } void heapify(int arr[], int size, int i) { int largest = i; // 根节点...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值