数据结构---堆----C语言实现

已于 2022-04-08 18:48:36 修改
阅读量1.1k 收藏 1
点赞数 4
于 2022-04-03 17:35:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_57535054/article/details/123939355
版权

c语言 数据结构

目录

堆排序介绍

功能介绍

功能实现

公式

功能合并

这里添加另一种方法，只用到了向下调整法就可排序

源码1

源码2

堆排序介绍

堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。是一个近似完全二叉树的结构，并同时满足堆积的性质：即子节点总是小于或者大于它的父节点

想要用堆，先要实现堆的功能函数

功能介绍

初始化、释放、打印、入堆、出堆、返回堆顶元素、返回堆中有多少元素、判空、向上调整法、向下调整法

//初始化
void HeapInit(HP* hp);

//释放
void HeapDestory(HP* hp);

//打印
void HeapPrint(HP* hp);

//入堆
void HeapPush(HP* hp, HeaDataType x);

//出堆 从堆顶出
void HeapPop(HP* hp);

//返回堆顶元素
HeaDataType HeapTop(HP* hp);

//返回堆中多少元素
size_t HeapSize(HP* hp);

//判空
bool HeapEmpty(HP* hp);

实现堆排序所需要头文件

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

堆它的结构是树形结构（逻辑结构上）但是它的物理结构是用顺序表来实现，所以我们构建的结构体跟顺序表是一样的，然后我们再对类型进行重命名

typedef int HeaDataType;

typedef struct Heap
{
	HeaDataType* a;
	int size;
	int capacity;
}HP;

功能实现

1.初始化

因为它物理结构上是顺序表。那么初始化，只需要对指针置空，并对size和capacity置0。

//初始化
void HeapInit(HP* hp)
{
	assert(hp);
	hp->a = NULL;
	hp->size = hp->capacity = 0;
}

2.释放（这些必备的函数，先实现，到后面我们就可以直接调用）

把a的数据释放，并把指针置空，再把size和capacity置为0

//释放
void HeapDestory(HP* hp)
{
	free(hp->a);
	hp->a = NULL;
	hp->size = hp->capacity = 0;
}

3.打印

直接对数组里的数据依次打印

//打印
void HeapPrint(HP* hp)
{
	for (size_t i=0; i < hp->size; i++)
	{
		printf("%d ", hp->a[i]);
	}
}

4.入堆

要入堆，需要判断空间是否满，然后再看是否要进行扩容操作，（这不是重点，因为扩容操作太简单，这里主要讲解向上调整法）

因为堆的要求是子节点是必须大于或小于父节点的，那么要插入节点的值是不能确定的，并且无法保证它一定是有序的，所以我们要对插入的子节点进行操作，如果插入的数是小于父节点的，那么我们就要让它向上移动，并且不让它破坏结构，就要用到向上调整法

向上调整法思路

1.我们先用下标找到插入节点的父节点

传值我们用下标去找，找到它的父节点的下标位置。

2.让孩子节点和父亲节点的值交换

这里要交换他们的值，那么用他们的类型指针，去指向他们的值，然后进行值交换，如果用HP->a[child/parent]那么交换的只是他们的下标

这里再加上一个Swap交换函数  

3.然后让父亲节点变为孩子节点

4.再利用孩子节点去找到它的父亲节点

稍微的小总结（交换后，让孩子节点变成它的父亲节点，再利用这个父亲节点去找它的父亲（套娃）

 情况不全是这样，这次是0 它是最小的，所以是到堆顶，如果它比其中一个数小，就成为它的子节点

void Swap(HeaDataType* hp, HeaDataType* hb)
{
	HeaDataType* tmp = *hp;
	*hp = *hb;
	*hb = tmp;
}


void ADjustUP(HeaDataType* a, size_t child/*孩子节点下标*/)
{
	size_t prent = (child - 1) / 2;//父亲节点下标
	while (child > 0)
	{
		if (a[child/*孩子节点的值*/] < a[prent/*父亲节点的值*/])
			//这里用的是HeaDataType* a  它是指针 找的是child的值 而不是下标
		{
			Swap(&a[child], &a[prent]);
			child = prent;
			prent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

//入堆
void HeapPush(HP* hp, HeaDataType x)
{
	if (hp->size == hp->capacity)
	{
		size_t newcapacity = hp->capacity == 0 ? 4 : hp->capacity * 2;
		HeaDataType* tmp = (HeaDataType*)realloc(hp->a, sizeof(HeaDataType)*newcapacity);
		if (tmp == NULL)
		{
			printf("realloc fail\n");
			exit(-1);
		}
		hp->a = tmp;
		hp->capacity = newcapacity;
	}
	hp->a[hp->size] = x;
	hp->size++;

	//向上调整法
	ADjustUP(hp->a, hp->size - 1);
}

5.出堆

出堆则是把堆顶的数据给去除，并且堆的结构不能被破坏

出堆是直接用到向下调整法。

向下调整法的思路：

1.让堆顶的数据和最后一个节点的数据交换

最后一个数就是size-1。

2.再删除最后一个节点

删除最后一个数让size直接--（有效数据--）

3.再把堆顶往下调整

让堆顶的下标去找子节点，（分为左孩子、右孩子）

先判断左孩子小还是右孩子小，再向下调整（这里有一个极端情况，它可能没有右孩子，又因为左孩子下标+1就是右孩子，我们判断左孩子+1是否到了size的有效数据）

再接下来，判断孩子节点是否比父亲节点小，是否要进行交换操作

 6.返回堆顶元素、返回堆中有多少元素、判空

这三个功能实现简单，所以合起来讲

返回堆顶元素直接返回数组的下标为0的元素

返回堆中有多少元素 返回size就可以 size记录的就是有效数据

判空 返回size是否为0

//返回堆顶元素
HeaDataType HeapTop(HP* hp)
{
	assert(hp);
	assert(hp->size > 0);

	return hp->a[0];
}

//返回堆中多少元素
size_t HeapSize(HP* hp)
{
	assert(hp);

	return hp->size;
}

//判空
bool HeapEmpty(HP* hp)
{
	assert(hp);

	return hp->size == 0;
}

公式

左孩子=父节点*2+1  leftchild=parent*2+1

右孩子=父节点*2+2  rightchild=parent*2+2

父节点=（孩子节点-1）/2 parent=(child-1)/2

功能合并

功能实现后，就可以实现一个堆排序了

例：假设我要排序 12,64,7,9,35,67,53,100

先计算好数组元素的大小，再让他们分别压入堆里，再让他们依次从小到打压出数组，最后打印

如：

void HeapSort(int* a, int size)
{
	HP hp;
	HeapInit(&hp);
	int i, j=0;
	for (i = 0; i < size; i++)
	{
		HeapPush(&hp, a[i]);
	}

	while (!HeapEmpty(&hp))
	{
		a[j++]= HeapTop(&hp);
		HeapPop(&hp);
	}
	HeapDestory(&hp);
}

int main()
{
	//test();
	int i;
	int a[] = { 12,64,7,9,35,67,53,100 };
	HeapSort(a, sizeof(a) / sizeof(int));
	printf("堆排序后:");
	for (i = 0; i < sizeof(a) / sizeof(int); i++)
	{
		printf("%d ", a[i]);
	}

	return 0;
}

这里添加另一种方法，只用到了向下调整法就可排序

1.这里我们先建一个大堆先找到最后一个父节点（利用公式）

 2.找到堆的最后一个节点即数组里最后一个数字

3.这时大堆的堆顶一定为堆中最大的数，那么我们把最大的数与最后一个数交换（即最大的数移动到了最后），然后我们在继续建大堆（最后一个数不参与建队）建好后，让end指向倒数第二的位置  口诉比较乱，这里再次用图讲解

源码1

//初始化
void HeapInit(HP* hp)
{
	assert(hp);
	hp->a = NULL;
	hp->size = hp->capacity = 0;
}

//释放
void HeapDestory(HP* hp)
{
	free(hp->a);
	hp->a = NULL;
	hp->size = hp->capacity = 0;
}

//打印
void HeapPrint(HP* hp)
{
	for (size_t i=0; i < hp->size; i++)
	{
		printf("%d ", hp->a[i]);
	}
}

void Swap(HeaDataType* hp, HeaDataType* hb)
{
	HeaDataType* tmp = *hp;
	*hp = *hb;
	*hb = tmp;
}


void ADjustUP(HeaDataType* a, size_t child/*孩子节点下标*/)
{
	size_t prent = (child - 1) / 2;//父亲节点下标
	while (child > 0)
	{
		if (a[child/*孩子节点的值*/] < a[prent/*父亲节点的值*/])
			//这里用的是HeaDataType* a  它是指针 找的是child的值 而不是下标
		{
			Swap(&a[child], &a[prent]);
			child = prent;
			prent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

//入堆
void HeapPush(HP* hp, HeaDataType x)
{
	if (hp->size == hp->capacity)
	{
		size_t newcapacity = hp->capacity == 0 ? 4 : hp->capacity * 2;
		HeaDataType* tmp = (HeaDataType*)realloc(hp->a, sizeof(HeaDataType)*newcapacity);
		if (tmp == NULL)
		{
			printf("realloc fail\n");
			exit(-1);
		}
		hp->a = tmp;
		hp->capacity = newcapacity;
	}
	hp->a[hp->size] = x;
	hp->size++;

	//向上调整法
	ADjustUP(hp->a, hp->size - 1);
}

void ADjustDown(HeaDataType* a, size_t size, size_t root)
{
	size_t prent = root;
	size_t child = prent * 2 + 1;
	while (child < size)
	{
		if (child + 1 < size/*判断树是否只有左孩子*/&& a[child + 1] < a[child])
		{
			++child;
		}
		
		if (a[child] < a[prent])
		{
			Swap(&a[child], &a[prent]);
			prent = child;
			child=prent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

//出堆 
void HeapPop(HP* hp)
{
	//交换第一个数和最后一个数  去掉最后一个数
	//然后向下调整法

	assert(hp);
	assert(hp->size > 0);

	Swap(&hp->a[0], &hp->a[hp->size - 1]);
	--hp->size;

	ADjustDown(hp->a, hp->size, 0);
}

//返回堆顶元素
HeaDataType HeapTop(HP* hp)
{
	assert(hp);
	assert(hp->size > 0);

	return hp->a[0];
}

//返回堆中多少元素
size_t HeapSize(HP* hp)
{
	assert(hp);

	return hp->size;
}

//判空
bool HeapEmpty(HP* hp)
{
	assert(hp);

	return hp->size == 0;
}

源码2

void HeapSort(int* a, int size)
{
	for (int i =(size-1-1)/2; i>=0; i--)//先找到最后一个父节点  然后建大堆
	{
		ADjustDown(a, size, i);//先建大堆
	}
	int end = size - 1;//这时堆是大堆  然后找最后一个节点 
	while (end >0)
	{
		Swap(&a[0], &a[end]);//让第一个和最后一个节点交换 （最大的节点被换到最后）
		ADjustDown(a, end, 0);//让最后一个节点的前面全部节点建队  让最大的节点换到堆顶
		--end;              //然后让第一个节点与倒数第二个节点交换 （次大的节点被换到的倒数第二个）
	}
}

如果本篇对您有帮助，希望能获得您的赞！感谢！

Lonely丶墨轩
关注
  • 4
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
C语言实现的堆数据结构及堆排序
01-16
按照算法导论上的伪代码写出的堆数据结构，实现的是最大堆的堆排序
常用数据结构 - C语言实现
最新发布
06-18
数据结构 NOTONLLY的SBT模板.cpp NOTONLLY的划分树模板.cpp NOTONLLY的后缀数组模板.cpp RMQ-ST算法.cpp RMQ线段树.cpp SBT.cpp SBT2.cpp splay伸展树.cpp ST表.cpp Treap.cpp Trie树.cpp 二叉堆.cpp 二维线段树.cpp...
C语言数据结构---堆
huxyc的博客
06-18 188
堆通常是一个可以被看做一棵树的数组对象。 /**************************************************************************** *Project:Heap 堆 *Author:Rise *Note:这里是小根堆 *堆通常是一个可以被看做一棵树的数组对象。 *****************************************************************************/ #include<
数据结构——堆（C语言实现）
sinzz的博客
06-11 2536
本篇文章主要介绍了堆的概念、堆的实现、堆排序的实现、建堆和堆排序时间复杂度的讲解、以及简单介绍了TOPK问题。
C语言实现数据结构的堆(Heap)
qq_68926231的博客
08-09 783
日拱一卒，功不唐捐！一起进步~
堆的实现（C语言）
Enthusiastic_boy的博客
12-06 840
什么是堆？ 可以简单理解为：1.堆中某个节点的值总是不大于或不小于其父节点的值；2.堆总是一棵完全二叉树3.将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。 理解了堆的概念后那么下面就来创建一个堆。 假设有这样一个数组：int array[]={8,2,3,4,5,6}，存储的是完全二叉树，那么： 从上图中可以发现，除了根节点外，其余部分满足小堆的基本性质。因为：2<4, 2<5; 3<6。那么如何将上面的完全二叉树调整为一个小堆呢？ 首先，...
C语言-数据结构-stack讲解
04-21
下面我们将详细介绍如何在C语言中实现栈的数据结构。 ##### 1. 定义栈类型 ```c typedef int STDataType; typedef struct Stack { STDataType* a; // 指向数组的指针 int top; // 栈顶位置 int capacity; // 栈...
C语言-数据结构-栈队列实现
03-10
本主题关注的是如何使用C语言来实现数据结构中的栈和队列，这是两种基础但非常重要的抽象数据类型（ADT）。 栈（Stack）是具有后进先出（LIFO）特性的数据结构。它类似于一个堆叠的盘子，最新的元素被放在顶部，...
基于C语言实现二叉树-堆-图（数据结构实验）【100012026】
04-25
本实验“基于C语言实现二叉树-堆-图（数据结构实验）”着重于三种基本数据结构：二叉树、堆和图，并探讨了它们在实际问题中的应用。 首先，我们来深入理解二叉树。二叉树是一种特殊的树形数据结构，每个节点最多有...
完整word版-《c语言数据结构》第9章-排序-自测卷-答案.doc
11-23
【C语言数据结构-第9章 排序】 排序是计算机科学中的一项基础操作，它在数据处理和信息管理中有着广泛的应用。本章主要讨论的是C语言实现的各种排序算法，包括它们的基本原理、效率分析以及适用场景。 一、排序...
堆--用C语言实现
05-12
堆的出队，删除，插入节点（下筛法，上滤法），子树更新，节点修改，堆排序，堆的创建，销毁。
C语言实现堆
weixin_54792212的博客
03-29 1818
文章目录前言一、什么是树1.1 树的相关概念1.2 树的表示1.4 树在实际中的应用二、什么是二叉树2.1 特殊的二叉树2.2 二叉树的性质三、堆3.1 堆的结构3.2 堆的实现3.2.1 堆向下调整算法3.2.2 建堆3.2.3 堆的插入3.2.4 堆的删除3.2.5 数据结构和接口(声明)3.2.6 接口函数的定义（实现)3.2.7 堆的调用3.3 堆的应用3.3.1 堆排序3.3.2 TOP-K问题 前言 在介绍堆之前需要介绍一下树和二叉树的概念，因为堆是一种数据结构，是将集合中所有的元素按完全二叉树
【数据结构】堆-C语言版
局部变量和全局变量
03-03 1586
堆的性质： （1）堆中某个结点的值总是不大于或不小于其父结点的值； （2）堆总是一棵完全二叉树。
数据结构：堆的实现(堆的接口超详细C语言实现)
zw的博客
03-17 656
文章目录1. 概念1.1 堆的性质1.2 堆的动态结构2. 具体的接口实现2.1 堆的构建2.2 堆的销毁2.3 堆的插入2.4 堆的删除2.5 取堆顶的数据2.6 堆的数据个数2.7 堆的判空2.8 对数组进行堆排序2.9 向下调整算法2.10 向上调整算法2.11 TopK问题：找出N个数里面最大/最小的前K个问题。3. 牛刀小试 1. 概念 堆是一种完全二叉树，现实中通常使用顺序结构的数组来存储堆，此处的堆是一种数据结构(完全二叉树)，而不是虚拟进程空间中的那个堆(是操作系统用来管理内存的一个区域
堆（C语言实现）
cw412524的博客
11-30 1369
数据结构 堆（C语言实现），包含丰富接口，干货满满！
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值