堆排序

最新推荐文章于 2023-09-21 13:21:58 发布
最新推荐文章于 2023-09-21 13:21:58 发布
阅读量461 收藏
点赞数
分类专栏： C语言算法练习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/point123456789/article/details/42936081
版权

1.堆：  类似二叉树

数据组织方式->数组对象

2.种类：    最大堆->A[PARENT(i)] >= A[i]

最小堆->A[PARENT(i)] <= A[i]

3.建堆：Heap_max_Build

   保持堆性质:Heap_max_Ify

    堆排序:Heap_max_Sort

4.Code

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

#define PARAEN(i) \
	(i) / 2
#define LEFT(i) \
	2 * (i)
#define RIGHT(i) \
	2 * (i) + 1

void Heap_max_Display(int *piArray, int iSize)
{
	int iCnt = 0;
	
	assert(piArray != NULL);
	
	printf("Heap sequence: ");
	
	for (iCnt = 1; iCnt <= iSize; iCnt++)
	{
		printf("%d ", piArray[iCnt]);
	}
	printf("\r\n");
	
	return;
}

void Heap_max_Ify(int *piArray, int iSize, int iPosition)
{
	int iLeft = 0;
	int iRight = 0;
	int iLargest = 0;
	int iSwapValue = 0;

	assert(piArray != NULL);
	assert(iPosition >= 1);

	iLeft = LEFT(iPosition);
	iRight = RIGHT(iPosition);
	iLargest = iPosition;

	printf("Heap max ify:%d %d %d %d start\r\n", iPosition, iLeft, iRight, iSize);
	Heap_max_Display(piArray, iSize);

	/* 小于堆的大小 */
	if ((iLeft <= iSize) && (piArray[iLeft] > piArray[iPosition]))
	{
		iLargest = iLeft;
	}

	if ((iRight <= iSize) && (piArray[iRight] > piArray[iLargest]))
	{
		iLargest = iRight;
	}

	if (iLargest != iPosition)
	{
		iSwapValue = piArray[iLargest];		
		piArray[iLargest] = piArray[iPosition];
		piArray[iPosition] = iSwapValue;

		printf("Swap position %d %d \r\n", iPosition, iLargest);
		printf("Swap value %d %d \r\n", piArray[iPosition], piArray[iLargest]);
		Heap_max_Ify(piArray, iSize, iLargest);
	}
	else
	{
		printf("No need swap\r\n");
	}

	printf("Heap max ify:%d %d %d %d finish\r\n", iPosition, iLeft, iRight, iSize);
	Heap_max_Display(piArray, iSize);
	return;
}

void Heap_max_Build(int *piArray, int iSize)
{
	int iCnt = 0;
	
	assert(piArray != NULL);

	printf("Heap max build size:%d start \r\n", iSize);
	
	for (iCnt = iSize / 2 ; iCnt >= 1; iCnt--)	
	{
		Heap_max_Ify(piArray, iSize, iCnt);
	}
	
	printf("Heap max build size:%d finish \r\n", iSize);

	return;
}

/* 构造一个最大堆，然后交换第一个和最后一个；
   堆的大小减一；
   重新构造堆；
   依此类推 */
void Heap_max_Sort1(int *piArray, int iSize)
{
	int iCnt = 0;
	int iHeapSize = 0;
	int iHeapValue = 0;
	
	assert(piArray != NULL);
	
	iHeapSize = iSize;
	for (iCnt = iHeapSize; iCnt >= 1; iCnt--)
	{
		Heap_max_Build(piArray, iHeapSize);

		iHeapValue = piArray[iHeapSize];
		piArray[iHeapSize] = piArray[1];	
		piArray[1] = iHeapValue;
		iHeapSize--;	
	}	

	return;	
}

/* 构造最大堆；
   交换最大值和最后一个值；
   堆的大小减一；
   继续保持堆的性质;
   依此类推 
   复杂度：nlgn*/
void Heap_max_Sort(int *piArray, int iSize)
{
	int iHeapSize = 0;
	int iHeapValue = 0;

	assert(piArray != NULL);

	Heap_max_Build(piArray, iSize);
	
	iHeapSize = iSize;
	/* 一直比较，直到剩下两个 */
	while (iHeapSize >= 2)
	{
		iHeapValue = piArray[iHeapSize];
		piArray[iHeapSize] = piArray[1];
		piArray[1] = iHeapValue;
		iHeapSize--;

		Heap_max_Ify(piArray, iHeapSize, 1);
	}
	
	return;
}

int main()
{
	int aiArray[12 + 1] = {0, 0, 2, 3, 4, 0, 8, 9, 6, 7, 0, 11, 12};
	
	Heap_max_Display(aiArray, 12);
	
	Heap_max_Sort(aiArray, 12);
	
	Heap_max_Display(aiArray, 12);
	
	return 0;	
}

5.运行结果：

Heap sequence: 0 2 3 4 0 8 9 6 7 0 11 12 
Heap max build size:12 start 
Heap max ify:6 12 13 12 start
Heap sequence: 0 2 3 4 0 8 9 6 7 0 11 12 
Swap position 6 12 
Swap value 12 8 
Heap max ify:12 24 25 12 start
Heap sequence: 0 2 3 4 0 12 9 6 7 0 11 8 
No need swap
Heap max ify:12 24 25 12 finish
Heap sequence: 0 2 3 4 0 12 9 6 7 0 11 8 
Heap max ify:6 12 13 12 finish
Heap sequence: 0 2 3 4 0 12 9 6 7 0 11 8 
Heap max ify:5 10 11 12 start
Heap sequence: 0 2 3 4 0 12 9 6 7 0 11 8 
Swap position 5 11 
Swap value 11 0 
Heap max ify:11 22 23 12 start
Heap sequence: 0 2 3 4 11 12 9 6 7 0 0 8 
No need swap
Heap max ify:11 22 23 12 finish
Heap sequence: 0 2 3 4 11 12 9 6 7 0 0 8 
Heap max ify:5 10 11 12 finish
Heap sequence: 0 2 3 4 11 12 9 6 7 0 0 8 
Heap max ify:4 8 9 12 start
Heap sequence: 0 2 3 4 11 12 9 6 7 0 0 8 
Swap position 4 9 
Swap value 7 4 
Heap max ify:9 18 19 12 start
Heap sequence: 0 2 3 7 11 12 9 6 4 0 0 8 
No need swap
Heap max ify:9 18 19 12 finish
Heap sequence: 0 2 3 7 11 12 9 6 4 0 0 8 
Heap max ify:4 8 9 12 finish
Heap sequence: 0 2 3 7 11 12 9 6 4 0 0 8 
Heap max ify:3 6 7 12 start
Heap sequence: 0 2 3 7 11 12 9 6 4 0 0 8 
Swap position 3 6 
Swap value 12 3 
Heap max ify:6 12 13 12 start
Heap sequence: 0 2 12 7 11 3 9 6 4 0 0 8 
Swap position 6 12 
Swap value 8 3 
Heap max ify:12 24 25 12 start
Heap sequence: 0 2 12 7 11 8 9 6 4 0 0 3 
No need swap
Heap max ify:12 24 25 12 finish
Heap sequence: 0 2 12 7 11 8 9 6 4 0 0 3 
Heap max ify:6 12 13 12 finish
Heap sequence: 0 2 12 7 11 8 9 6 4 0 0 3 
Heap max ify:3 6 7 12 finish
Heap sequence: 0 2 12 7 11 8 9 6 4 0 0 3 
Heap max ify:2 4 5 12 start
Heap sequence: 0 2 12 7 11 8 9 6 4 0 0 3 
Swap position 2 5 
Swap value 11 2 
Heap max ify:5 10 11 12 start
Heap sequence: 0 11 12 7 2 8 9 6 4 0 0 3 
No need swap
Heap max ify:5 10 11 12 finish
Heap sequence: 0 11 12 7 2 8 9 6 4 0 0 3 
Heap max ify:2 4 5 12 finish
Heap sequence: 0 11 12 7 2 8 9 6 4 0 0 3 
Heap max ify:1 2 3 12 start
Heap sequence: 0 11 12 7 2 8 9 6 4 0 0 3 
Swap position 1 3 
Swap value 12 0 
Heap max ify:3 6 7 12 start
Heap sequence: 12 11 0 7 2 8 9 6 4 0 0 3 
Swap position 3 7 
Swap value 9 0 
Heap max ify:7 14 15 12 start
Heap sequence: 12 11 9 7 2 8 0 6 4 0 0 3 
No need swap
Heap max ify:7 14 15 12 finish
Heap sequence: 12 11 9 7 2 8 0 6 4 0 0 3 
Heap max ify:3 6 7 12 finish
Heap sequence: 12 11 9 7 2 8 0 6 4 0 0 3 
Heap max ify:1 2 3 12 finish
Heap sequence: 12 11 9 7 2 8 0 6 4 0 0 3 
Heap max build size:12 finish 
Heap max ify:1 2 3 11 start
Heap sequence: 3 11 9 7 2 8 0 6 4 0 0 
Swap position 1 2 
Swap value 11 3 
Heap max ify:2 4 5 11 start
Heap sequence: 11 3 9 7 2 8 0 6 4 0 0 
Swap position 2 4 
Swap value 7 3 
Heap max ify:4 8 9 11 start
Heap sequence: 11 7 9 3 2 8 0 6 4 0 0 
Swap position 4 8 
Swap value 6 3 
Heap max ify:8 16 17 11 start
Heap sequence: 11 7 9 6 2 8 0 3 4 0 0 
No need swap
Heap max ify:8 16 17 11 finish
Heap sequence: 11 7 9 6 2 8 0 3 4 0 0 
Heap max ify:4 8 9 11 finish
Heap sequence: 11 7 9 6 2 8 0 3 4 0 0 
Heap max ify:2 4 5 11 finish
Heap sequence: 11 7 9 6 2 8 0 3 4 0 0 
Heap max ify:1 2 3 11 finish
Heap sequence: 11 7 9 6 2 8 0 3 4 0 0 
Heap max ify:1 2 3 10 start
Heap sequence: 0 7 9 6 2 8 0 3 4 0 
Swap position 1 3 
Swap value 9 0 
Heap max ify:3 6 7 10 start
Heap sequence: 9 7 0 6 2 8 0 3 4 0 
Swap position 3 6 
Swap value 8 0 
Heap max ify:6 12 13 10 start
Heap sequence: 9 7 8 6 2 0 0 3 4 0 
No need swap
Heap max ify:6 12 13 10 finish
Heap sequence: 9 7 8 6 2 0 0 3 4 0 
Heap max ify:3 6 7 10 finish
Heap sequence: 9 7 8 6 2 0 0 3 4 0 
Heap max ify:1 2 3 10 finish
Heap sequence: 9 7 8 6 2 0 0 3 4 0 
Heap max ify:1 2 3 9 start
Heap sequence: 0 7 8 6 2 0 0 3 4 
Swap position 1 3 
Swap value 8 0 
Heap max ify:3 6 7 9 start
Heap sequence: 8 7 0 6 2 0 0 3 4 
No need swap
Heap max ify:3 6 7 9 finish
Heap sequence: 8 7 0 6 2 0 0 3 4 
Heap max ify:1 2 3 9 finish
Heap sequence: 8 7 0 6 2 0 0 3 4 
Heap max ify:1 2 3 8 start
Heap sequence: 4 7 0 6 2 0 0 3 
Swap position 1 2 
Swap value 7 4 
Heap max ify:2 4 5 8 start
Heap sequence: 7 4 0 6 2 0 0 3 
Swap position 2 4 
Swap value 6 4 
Heap max ify:4 8 9 8 start
Heap sequence: 7 6 0 4 2 0 0 3 
No need swap
Heap max ify:4 8 9 8 finish
Heap sequence: 7 6 0 4 2 0 0 3 
Heap max ify:2 4 5 8 finish
Heap sequence: 7 6 0 4 2 0 0 3 
Heap max ify:1 2 3 8 finish
Heap sequence: 7 6 0 4 2 0 0 3 
Heap max ify:1 2 3 7 start
Heap sequence: 3 6 0 4 2 0 0 
Swap position 1 2 
Swap value 6 3 
Heap max ify:2 4 5 7 start
Heap sequence: 6 3 0 4 2 0 0 
Swap position 2 4 
Swap value 4 3 
Heap max ify:4 8 9 7 start
Heap sequence: 6 4 0 3 2 0 0 
No need swap
Heap max ify:4 8 9 7 finish
Heap sequence: 6 4 0 3 2 0 0 
Heap max ify:2 4 5 7 finish
Heap sequence: 6 4 0 3 2 0 0 
Heap max ify:1 2 3 7 finish
Heap sequence: 6 4 0 3 2 0 0 
Heap max ify:1 2 3 6 start
Heap sequence: 0 4 0 3 2 0 
Swap position 1 2 
Swap value 4 0 
Heap max ify:2 4 5 6 start
Heap sequence: 4 0 0 3 2 0 
Swap position 2 4 
Swap value 3 0 
Heap max ify:4 8 9 6 start
Heap sequence: 4 3 0 0 2 0 
No need swap
Heap max ify:4 8 9 6 finish
Heap sequence: 4 3 0 0 2 0 
Heap max ify:2 4 5 6 finish
Heap sequence: 4 3 0 0 2 0 
Heap max ify:1 2 3 6 finish
Heap sequence: 4 3 0 0 2 0 
Heap max ify:1 2 3 5 start
Heap sequence: 0 3 0 0 2 
Swap position 1 2 
Swap value 3 0 
Heap max ify:2 4 5 5 start
Heap sequence: 3 0 0 0 2 
Swap position 2 5 
Swap value 2 0 
Heap max ify:5 10 11 5 start
Heap sequence: 3 2 0 0 0 
No need swap
Heap max ify:5 10 11 5 finish
Heap sequence: 3 2 0 0 0 
Heap max ify:2 4 5 5 finish
Heap sequence: 3 2 0 0 0 
Heap max ify:1 2 3 5 finish
Heap sequence: 3 2 0 0 0 
Heap max ify:1 2 3 4 start
Heap sequence: 0 2 0 0 
Swap position 1 2 
Swap value 2 0 
Heap max ify:2 4 5 4 start
Heap sequence: 2 0 0 0 
No need swap
Heap max ify:2 4 5 4 finish
Heap sequence: 2 0 0 0 
Heap max ify:1 2 3 4 finish
Heap sequence: 2 0 0 0 
Heap max ify:1 2 3 3 start
Heap sequence: 0 0 0 
No need swap
Heap max ify:1 2 3 3 finish
Heap sequence: 0 0 0 
Heap max ify:1 2 3 2 start
Heap sequence: 0 0 
No need swap
Heap max ify:1 2 3 2 finish
Heap sequence: 0 0 
Heap max ify:1 2 3 1 start
Heap sequence: 0 
No need swap
Heap max ify:1 2 3 1 finish
Heap sequence: 0 
Heap sequence: 0 0 0 2 3 4 6 7 8 9 11 12 



point123456789
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
堆排序详细图解（通俗易懂）
oorik的博客
02-17 23万+
什么是堆 堆是一种叫做完全二叉树的数据结构，可以分为大根堆，小根堆，而堆排序就是基于这种结构而产生的一种程序算法。 堆的分类 大根堆:每个节点的值都大于或者等于他的左右孩子节点的值 小根堆:每个结点的值都小于或等于其左孩子和右孩子结点的值 两种结构映射到数组为: 大根堆: 小根堆: //父-->子:i--->左孩子:2*i+1, 右孩子:2*i+2; //子-->父:i--->(i-1)*2;(i为下标元素) 排序思想 1.首先将待排序的数...
堆排序（优先队列）
Rookie的博客
11-15 365
堆（二叉堆） 此处堆不是存储中的堆，并且满足一下几个性质： 1.每个节点在此子树中最大（最小）。 2.此树为一颗完全二叉树。 数组本身就满足完全二叉树，假设1为根节点那么子节点为2,3, 2的子节点为4,5...那么只需要将这个完全二叉树调整至满足第一个条件就是一个堆了，调整时，叶子节点都是满足条件，然后从最后一个存在子节点的节点开始调整子树，从后调整的好处是每次调整当前节点时子树都是满足
六大排序算法：插入排序、希尔排序、选择排序、冒泡排序、堆排序、快速排序
热门推荐
HanMeng的博客
07-24 58万+
文章目录：1. 插入排序2.希尔排序 1. 插入排序 步骤： 1.从第一个元素开始，该元素可以认为已经被排序 2.取下一个元素tem，从已排序的元素序列从后往前扫描 3.如果该元素大于tem，则将该元素移到下一位 4.重复步骤3，直到找到已排序元素中小于等于tem的元素 5.tem插入到该元素的后面，如果已排序所有元素都大于tem，则将tem插入到下标为0的位置 6.重复步骤2~5 动图演示如下： 思路：   在待排序的元素中，假设前n-1个元素已有序，现将第n个元素插入到前面已经排好的序列中，使得前n个
堆排序算法（图解详细流程）
阿顾的博客
08-04 23万+
堆排序的时间复杂度O(N*logN),额外空间复杂度O(1)，是一个不稳定性的排序 目录 一 准备知识 1.1 大根堆和小根堆 二 堆排序基本步骤 2.1 构造堆 2.2固定最大值再构造堆 三 总结 四代码 一 准备知识 堆的结构可以分为大根堆和小根堆，是一个完全二叉树，而堆排序是根据堆的这种数据结构设计的一种排序，下面先来看看什么是大根堆和小根堆 1.1 大根...
堆排序详解
最新发布
Xpccccc的博客
09-21 1347
堆排序详解
排序算法：堆排序
Yikefore的博客
05-28 2709
关于排序算法中的堆排序的详细介绍，以及实现过程和时间复杂度的计算，附带图解。
十大经典排序算法详解(三)-堆排序,计数排序,桶排序,基数排序
lovely__RR的博客
02-02 4万+
十大经典排序算法-堆排序,计数排序,桶排序,基数排序 1-堆排序 算法思想: 算法图解: 示例代码: 在这里插入代码片 复杂度分析: 2-计数排序 算法思想: 算法图解: 示例代码: 在这里插入代码片 复杂度分析: 3-桶排序 算法思想: 算法图解: 示例代码: 在这里插入代码片 复杂度分析: 4-基数排序 算法思想: 算法图解: 示例代码: 在这里插入代码片 复杂度分析: ...
堆排序是什么？
Free雅轩的博客
02-23 4230
堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。 堆排序可以说是一种利用堆的概念来排序的选择排序。分为两种方法： 大顶堆：每个节点的值都大于或等于其子节点的值，在堆排序算法中用于升序排列； 小顶堆：每个节点的值都小于或等于其子节点的值，在堆排序算法中用于降序排列； 堆排序的平均时间复杂度为 Ο(nlogn)。 1. 算法步骤 创建一个堆 H[0……n-1]； 把堆首（
图解堆排序
12-21
在深入探讨堆排序之前，首先我们要理解堆的概念和顺序存储二叉树的特性。顺序存储二叉树是一种特殊的数组表示的二叉树，通常只考虑完全二叉树，即每一层除了最后一个节点外，其余节点都完全填充。在这种存储方式中，...
堆排序（C语言实现）
01-07
堆排序（C语言实现）算法思想步骤程序 算法思想 见： 4. 选择排序—堆排序（Heap Sort） 算法导论——堆排序heapsort 步骤 1. 将n个元素建立初始堆，第一个节点放在数组下标1中，因此n个节点对应数组 a[1] ~ a[n]，...
C#堆排序实现方法
09-03
堆排序是一种基于比较的排序算法，它通过构建一个近似完全二叉树的堆结构来实现排序。在C#中，堆排序可以通过以下步骤来实现： 1. **堆的定义**： 堆通常是一个近似完全二叉树的结构，其中每个父节点的值都大于或...
图最少着色问题
point123456789的专栏
12-20 2172
Reverse-1
point123456789的专栏
12-05 1430
#include #include #include typedef struct tagLinkList{ struct tagLinkList *next; int num; }LINK_LIST_S; LINK_LIST_S *LinkList_CreateNode(int num) { LINK_LIST_S *pstLinkList = NULL; pstLink
内联函数是否加return
point123456789的专栏
01-11 826
内联函数：减少函数调用产生的栈开销； 编译时，对内联函数在调用时进行展开替换。 return： 能加，编译器替换。
C语言之树学习
point123456789的专栏
11-17 384
记录学习过程：  1、二叉数的遍历方法“
Java实现堆排序算法
"堆排序是一种基于比较的排序算法，它通过构建和调整二叉堆来实现数据的排序。本文档提供了Java代码实现堆排序的过程，包括建立大根堆、交换首尾元素以及堆的调整。" 堆排序的核心在于堆这种数据结构，它是一个近似...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值