数据结构——堆(二叉树)的结构及实现(C语言)

最新推荐文章于 2024-03-12 22:28:15 发布
置顶 最新推荐文章于 2024-03-12 22:28:15 发布
阅读量2.2k 收藏 5
点赞数 4
分类专栏： 数据结构 文章标签： 二叉树 堆排序 树堆 c语言 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40076022/article/details/112402835
版权

堆的C语言实现

一、堆的概念及结构

1.1 什么是堆？

将数组中的所有元素按照完全二叉树的顺序存储方式存储在一个一维数组中

堆具有如下性质：

  • 堆中某个节点的值不大于或者小于其父节点的值；
  • 堆总是一颗完全二叉树。

堆可以分为两类：

  • 大根堆：每个节点的值都小于父节点的值；
  • 小根堆：每个节点的值都大于父节点的值；

在这里插入图片描述

1.2 堆的结构

如上图所示，堆的逻辑结构是一个完全二叉树，存储结构是一个数组。

typedef int HPDataType;

typedef struct Heap
{
	HPDataType* _a;	
	int _size;		//堆中有效元素个数
	int _capacity;	//堆容量
}Heap;

二、堆的实现

了解了堆的结构后，我们就可以实现堆了，但是先找出堆中父节点与左右孩子节点的关系。
在这里插入图片描述

如上图所示我们可以得到父亲节点与左右孩子节点的关系，

假设父节点(parent)为 i ，则：
左 孩 子 ( L C h i l d ) = 2 ∗ i + 1 右 孩 子 ( R C h i l d ) = 2 ∗ i + 2 左孩子(LChild)=2*i+1 \\ 右孩子(RChild)=2*i+2 左孩子(LChild)=2∗i+1右孩子(RChild)=2∗i+2

int parent = i;		//父节点
int LChild = parent * 2 + 1;	//左孩子
int RChild = parent *2 +1;		//右孩子

假设子节点(Child)为 i，则
父 节 点 ( p a r e n t ) = ( i − 1 ) 2 父节点(parent)=\dfrac{(i-1)}{2} 父节点(parent)=2(i−1)​

int child = i;		//孩子节点，左右孩子结点不用区分，因为类型为int
int parent = (child-1)/2;	//父节点

通过上述关系，我们就可以在知道某个节点的位置后，查找其父节点和子节点了。

2.1 堆向下调整法

在构建堆之前，我们需要掌握一个算法来将堆构建成大根堆或小根堆，我们以小根堆为例讲解，该算法有一个前提：

左右子树必须是一个堆(大根堆或者小根堆)，才能调整

如下图所示，数组定义如下

int a[] = {27,15,19,18,28,34,65,49,25,37};

在这里插入图片描述
如上图所示，27的左右子树均是小根堆，那么就可以通过向下调整下将该堆构建成小根堆。

步骤为首先以根节点27作为parent，然后遍历二叉树，找出左孩子和右孩子中较小的节点作为孩子节点(child)，当父节点大于孩子节点时就交换数据，直到遍历到最后一个叶子节点。

//数据交换
void swap(HPDataType* p1, HPDataType* p2)
{
	HPDataType tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

//堆向下调整算法
void AdjustDown(HPDataType* a, int n, int root)
{
	//1.首先确定父节点与孩子节点，默认孩子节点为左孩子
	int parent = root;
	int child = parent * 2 + 1;	//不区分左右孩子，默认左孩子为孩子节点	
	//遍历二叉树，当孩子节点超出数组范围则停止
	while (child < n)
	{
		//找出左右孩子中最小的节点作为孩子节点
		if ((child + 1 < n) && (a[child + 1] < a[child]))
		{
			child++;
		}

		//如果父亲节点大于孩子节点则交换，否则退出循环
		if (a[parent] > a[child])
		{
			swap(&a[parent], &a[child]);	//交换
			parent = child;		//孩子节点作为新的父节点
			child = 2 * parent + 1;		//默认左孩子作为新的孩子节点
		}
		else
		{
			break;
		}
	}

}

2.2 堆的创建

在掌握了向下调整算法后就可以实现堆创建了，我们从二叉树中最后一个叶子节点开始调整，即数组中最后一个元素，一直调整到根节点的树，就可以调整成堆，即遍历数组中的每一个元素。

	//构建堆,从最后一个节点开始依次遍历执行向下调整算法，一直到根节点，可以找到最小的数
for (int i = n - 1; i >= 0; --i)
	{
		AdjustDown(php->_a, n, i);
	}

但真的需要这样操作吗？
如下图所示，叶子节点没有左右子树因此即可以看作大根堆也可以看作小根堆，实际上并不需要调整，只需要从最后一个节点的父节开始调整，即倒数第一个非叶子节点的子树开始调整，一直到根节点的树就可以调整成堆，并选择出最小的元素作为根节点。

例如：下图的最后一个节点为37，对应数组下标为 i = n − 1 = 9 i = n-1= 9 i=n−1=9 ，其父节点下标为 ( i − 1 ) 2 = 9 − 1 2 = 4 \frac{(i-1)}{2}=\frac{9-1}{2}=4 2(i−1)​=29−1​=4，也就是28开始 在这里插入图片描述

//堆的创建
void HeapInit(Heap * php, HPDataType * a, int n)
{
	assert(php);

	php->_a = (HPDataType *)malloc(sizeof(HPDataType)*n);
	//复制堆
	memcpy(php->_a, a, sizeof(HPDataType)*n);
	php->_size = n;
	php->_capacity = n;
	
	//这种方法不够优化因此不采用
	//for (int i = n - 1; i >= 0; --i)
	//{
	//	AdjustDown(php->_a, n, i);
	//}

	//构建堆,从最后一个节点开始依次遍历执行向下调整算法，一直到根节点，可以找到最小的数
	for (int i = (n - 2) / 2; i >= 0; --i)
	{
		AdjustDown(php->_a, n, i);
	}
}

2.3 堆的销毁

//堆的销毁
void HeapDestory(Heap* php)
{
	free(php->_a);		//先free堆中的数组
	php->_a = NULL;
	php->_size = php->_capacity = 0;
}

2.4 堆的插入

堆的插入是将数据插入到数组尾上，在进行向上调整算法，直到满足堆。

向上调整算法如图所示
先插入到数组末尾
1.10与28比较，小于28，交换；
2.10与18比较，小于18，交换；
3.10与15比较，小于15，交换；
4.满足堆调整完成。

在这里插入图片描述

//堆的插入
void HeapPush(Heap* php, HPDataType x)
{
	assert(php);

	//堆满，重新申请空间
	if (php->_size == php->_capacity)
	{
		php->_capacity *= 2;	//扩大2倍
		HPDataType *tmp = (HPDataType *)realloc(php->_a, sizeof(HPDataType)*php->_capacity);
		if (NULL == tmp)
		{
			printf("内存申请失败！\n");
			exit(-1);
		}
		php->_a = tmp;
	}
	

	php->_a[php->_size++] = x;	//元素插入数组末尾
	AdjustUp(php->_a, php->_size, php->_size - 1);
}

2.5 堆的删除

删除堆是删除堆顶的数据，将堆顶的数据和最后一个数据交换，然后删除数组最后一个数据，再进行向下调整算法。
在这里插入图片描述

//堆的删除
void HeapPop(Heap* php)
{
	assert(php);
	assert(php->_size > 0);

	//交换堆顶与最后一个数据
	swap(&php->_a[0], &php->_a[php->_size - 1]);
	php->_size--;	//删除最后一个元素
	AdjustDown(php->_a, php->_size, 0);
}

2.6 取堆顶的数据

HPDataType HeapTop(Heap* php)
{
	assert(php);
	assert(php->_size > 0);

	return php->_a[0];
}

2.7 堆的数据个数

//堆的数据个数
int HeapSize(Heap* php)
{
	assert(php);

	return php->_size;
}

2.8 堆的判空

//堆的判空
int HeapEmpty(Heap* php)
{
	assert(php);

	return php->_size == 0;
}

三、堆排序

执行堆排序的步骤为

首先构建堆，然后交换堆顶与堆中最后一个节点,然后删除最后一个元素，执行向下调整算法，直到最后一个元素
小根堆：每次挑出最小的元素，降序排序
大根堆：每次挑出最大的元素，升序排序
注意：
每次删除最后一个元素并不是物理结构上的删除，即不是删除二叉树的结点，而是指逻辑结构上的删除便于我们理解和操作，即只是让数组的长度减一再执行向下调整。

在这里插入图片描述

//对数组进行堆排序
void HeapSort(HPDataType *a, int n)
{

	//1.构建堆,从最后一个节点开始依次遍历执行向下调整算法，一直到根节点，可以找到最小的数
	for (int i = (n - 2) / 2; i >= 0; --i)
	{
		AdjustDown(a, n, i);
	}

	//每次和最后一个元素交换执行向下调整
	int end = n - 1;	//end为最后一个元素的数组下标
	while(end > 0)
	{
		swap(&a[0], &a[end]);
		AdjustDown(a, end, 0);
		--end;
	}

	for (int i = 0; i < n; ++i)
	{
		printf("%d ", a[i]);
	}
	printf("\n");

}

测试

int main()
{
	int a[] = { 27,15,19,18,28,34,65,49,25,37 };
	HeapSort(a, 10);
	return 0;
}

结果
在这里插入图片描述

四、代码清单

4.1 Heap.h

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<assert.h>

typedef int HPDataType;

typedef struct Heap
{
	HPDataType* _a;	
	int _size;		//堆中有效元素个数
	int _capacity;	//堆容量
}Heap;

//堆的创建
void HeapInit(Heap * php, HPDataType * a, int n);

//堆的销毁
void HeapDestory(Heap* php);

//堆的插入
void HeapPush(Heap* php, HPDataType x);

//堆的删除
void HeapPop(Heap* php);

//取堆顶的数据
HPDataType HeapTop(Heap* php);

//堆的数据个数
int HeapSize(Heap* php);

//堆的判空
int HeapEmpty(Heap* php);

//对数组进行堆排序
void HeapSort(HPDataType *a, int n);

//堆打印
void HeapPrint(HPDataType *php, int n);

4.2 Heap.c

#include"Heap.h"

//数据交换
void swap(HPDataType* p1, HPDataType* p2)
{
	HPDataType tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

//堆向下调整算法
void AdjustDown(HPDataType* a, int n, int root)
{
	//1.首先确定父节点与孩子节点，默认孩子节点为左孩子
	int parent = root;
	int child = parent * 2 + 1;	//不区分左右孩子，默认左孩子为孩子节点	
	//遍历二叉树，当孩子节点超出数组范围则停止
	while (child < n)
	{
		//找出左右孩子中最小的节点作为孩子节点
		if ((child + 1 < n) && (a[child + 1] < a[child]))
		{
			child++;
		}

		//如果父亲节点大于孩子节点则交换，否则退出循环
		if (a[parent] > a[child])
		{
			swap(&a[parent], &a[child]);	//交换
			parent = child;		//孩子节点作为新的父节点
			child = 2 * parent + 1;		//默认左孩子作为新的孩子节点
		}
		else
		{
			break;
		}
	}

}

void AdjustUp(HPDataType* a, int n, int child)
{
	int parent = (child - 1) / 2;	//新元素的父节点；
								//向上调整直到根节点
	while (child > 0)
	{
		//小根堆：如果父节点大于子节点就交换
		if (a[parent] >a[child])
		{
			swap(&a[parent], &a[child]);
			child = parent;		//父节点作为新的孩子节点
			parent = (child - 1) / 2;	//新的孩子节点的父节点
		}
		else
		{
			break;
		}
	}


}

//堆的创建
void HeapInit(Heap * php, HPDataType * a, int n)
{
	assert(php);

	php->_a = (HPDataType *)malloc(sizeof(HPDataType)*n);
	//复制堆
	memcpy(php->_a, a, sizeof(HPDataType)*n);
	php->_size = n;
	php->_capacity = n;
	
	//这种方法不够优化因此不采用
	//for (int i = n - 1; i >= 0; --i)
	//{
	//	AdjustDown(php->_a, n, i);
	//}

	//构建堆,从最后一个节点开始依次遍历执行向下调整算法，一直到根节点，可以找到最小的数
	for (int i = (n - 2) / 2; i >= 0; --i)
	{
		AdjustDown(php->_a, n, i);
	}
}

//堆的销毁
void HeapDestory(Heap* php)
{
	free(php->_a);		//先free堆中的数组
	php->_a = NULL;
	php->_size = php->_capacity = 0;
}

//堆的插入
void HeapPush(Heap* php, HPDataType x)
{
	assert(php);

	//堆满，重新申请空间
	if (php->_size == php->_capacity)
	{
		php->_capacity *= 2;	//扩大2倍
		HPDataType *tmp = (HPDataType *)realloc(php->_a, sizeof(HPDataType)*php->_capacity);
		if (NULL == tmp)
		{
			printf("内存申请失败！\n");
			exit(-1);
		}
		php->_a = tmp;
	}
	

	php->_a[php->_size++] = x;	//元素插入数组末尾
	AdjustUp(php->_a, php->_size, php->_size - 1);
}


//堆的删除
void HeapPop(Heap* php)
{
	assert(php);
	assert(php->_size > 0);

	//交换堆顶与最后一个数据
	swap(&php->_a[0], &php->_a[php->_size - 1]);
	php->_size--;	//删除最后一个元素
	AdjustDown(php->_a, php->_size, 0);
}

//取堆顶的数据
HPDataType HeapTop(Heap* php)
{
	assert(php);
	assert(php->_size > 0);

	return php->_a[0];
}

//堆的数据个数
int HeapSize(Heap* php)
{
	assert(php);

	return php->_size;
}

//堆的判空
int HeapEmpty(Heap* php)
{
	assert(php);

	return php->_size == 0;
}


//对数组进行堆排序
void HeapSort(HPDataType *a, int n)
{

	//1.构建堆,从最后一个节点开始依次遍历执行向下调整算法，一直到根节点，可以找到最小的数
	for (int i = (n - 2) / 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;
	}

}

//堆打印
void HeapPrint(HPDataType *a, int n)
{
	assert(a);
	assert(n);
	for (int i = 0; i < n; ++i)
	{
		printf("%d ", a[i]);
	}
	printf("\n");
}

4.3 test.c

#include"Heap.h"

void TestHeap()
{
	//int a[] = { 27,15,19,18,28,34,65,49,25,37 };
	//
	//HeapSort(a, sizeof(a) / sizeof(HPDataType));
	//HeapPrint(a,sizeof(a)/sizeof(HPDataType));

	int a[] = { 27,15,19,18,28,34,65,49,25,37 };
	Heap hp;
	HeapInit(&hp, a, sizeof(a) / sizeof(HPDataType));
	HeapPrint(hp._a, hp._size);
	HeapPush(&hp, 10);
	HeapPush(&hp, 11);
	HeapPush(&hp, 42);
	HeapPrint(hp._a, hp._size);
	HeapPop(&hp);
	//HeapPop(&hp);
	//HeapPop(&hp);
	//HeapPop(&hp);
	//HeapPop(&hp);
	//HeapPop(&hp);
	//HeapPop(&hp);
	//HeapPop(&hp);
	//HeapPop(&hp);
	//HeapPop(&hp);
	//HeapPop(&hp);
	//HeapPop(&hp);
	//HeapPop(&hp);
	HeapPrint(hp._a, hp._size);
	printf("%d\n",HeapTop(&hp));
	printf("%d\n", HeapSize(&hp));
	printf("%d\n", HeapEmpty(&hp));
	HeapDestory(&hp);
	//printf("%d\n", HeapTop(&hp));
	printf("%d\n", HeapSize(&hp));
	printf("%d\n", HeapEmpty(&hp));






}

int main()
{
	TestHeap();

	system("pause");
	return 0;
}

在这里插入图片描述

五颗粒粒
关注
  • 4
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
数据结构——基于C语言实现二叉树的应用.cpp
08-11
/创建二叉树 //初始化二叉树 //创建队列 //出队 //队列判空 //入队 //先序递归遍历 //后序递归遍历 //中序递归遍历 //层次遍历
React中的Diff算法
热门推荐
m0_53644435的博客
03-12 1万+
一、什么是Diff算法
React之Diff算法
认定的总要想办法去完成。
02-02 1297
对于Vue2的diff算法使用了双指针，React的diff算法没有使用双指针，是因为更新的jsx对象的newChildren为数组的形式，但是和newChildren中每个组件比较的是current fiber，对fiber的兄弟节点是通过silbing来相连的，我们通过下标来去获取下一个newChildren项，但是对于fiber只能通过fiber.silbing来获取对应的项，所以没有使用双指针法来进行diff。既然唯一的可能性已经不能复用，则剩下的fiber都没有机会了，所以都需要标记删除。
数据结构中的堆（Java）
最新发布
这个人很懒什么都没有留下
03-12 325
在堆的操作中，非叶子节点的重要性体现在维护堆的性质（如最大堆或最小堆）方面。非叶子节点是指至少有一个子节点的节点，它们位于堆的上层。在二叉堆（Binary Heap）中，非叶子节点的数量总是等于总节点数的一半（向上取整）。在堆（Heap）这种数据结构中，节点被分为两类：叶子节点（Leaf Nodes）和非叶子节点（Non-Leaf Nodes）。叶子节点是指没有子节点的节点，它们位于堆的最底层。在堆中，叶子节点的数量总是大于或等于非叶子节点的数量。该方式适用索引为0起点的堆。
【React】diff算法
GY的博客
11-15 1816
React之diff算法什么是虚拟DOM什么是Diff算法传统diff算法React的diff算法1. 什么是调和？2. 什么是React diff算法？3. diff策略。4. tree diff5. component diff：React对不同的组件间的比较，有三种策略。6. element diff：当节点处于同一层级时，diff提供三种节点操作：删除、插入、移动。 什么是虚拟DOM 虚拟DOM是一个对象，一个什么样的对象呢？一个用来表示真实DOM的对象。举个例子： 真实DOM <ul id=
React Diff算法详解
祥哥的说
01-14 6263
react diff
【LeetCode】617. 合并二叉树
jiiiiiaaaa的博客
09-23 491
题目 给定两个二叉树，想象当你将它们中的一个覆盖到另一个上时，两个二叉树的一些节点便会重叠。 你需要将他们合并为一个新的二叉树。合并的规则是如果两个节点重叠，那么将他们的值相加作为节点合并后的新值，否则不为NULL 的节点将直接作为新二叉树的节点。 示例1: 输入: Tree 1 Tree 2 1 2 ...
数据结构——二叉树 线索化二叉树 C语言
03-16
中序线索二叉树，反方向进行中序遍历(要求非递归，顺前驱进行)。 （1）建立二叉树； (2) 按先序、中序、后序输出二叉树; （3）复制二叉树； （4）在字符模式下画出无缺陷的二叉树
数据结构——二叉树
02-06
该文件包括二叉树的头文件（BitTree开头）和堆栈的头文件（Seq开头），另外还实现了编写按层次顺序（同一层自左至右）遍历二叉树的算法、后序递归遍历计算二叉树的深度的算法、判断给定二叉树是否为完全二叉树（通过...
数据结构之线索二叉树-C语言实现.pdf
01-15
线索二叉树 数据结构学习笔记——线索二叉树
数据结构——二叉树c语言源码
12-16
数据结构——二叉树c语言源码，数据结构——二叉树c语言源码
【力扣-简单】617. 合并二叉树
qq_39380838的博客
09-23 116
给定两个二叉树，想象当你将它们中的一个覆盖到另一个上时，两个二叉树的一些节点便会重叠。 你需要将他们合并为一个新的二叉树。合并的规则是如果两个节点重叠，那么将他们的值相加作为节点合并后的新值，否则不为NULL 的节点将直接作为新二叉树的节点。 示例1: 输入: Tree 1 Tree 2 1 2 ...
617. 合并二叉树
u010160949的博客
02-11 116
给定两个二叉树，想象当你将它们中的一个覆盖到另一个上时，两个二叉树的一些节点便会重叠。 你需要将他们合并为一个新的二叉树。合并的规则是如果两个节点重叠，那么将他们的值相加作为节点合并后的新值，否则不为 NULL 的节点将直接作为新二叉树的节点。 解题思路: 1.非法性判断。 2.创建一个主节点来存储，然后递归左子树和右子树。 public TreeNode mergeTrees(TreeNode ...
【leetcode.617】合并二叉树
阳阳的博客
09-23 431
一、题目描述 给定两个二叉树，想象当你将它们中的一个覆盖到另一个上时，两个二叉树的一些节点便会重叠。 你需要将他们合并为一个新的二叉树。合并的规则是如果两个节点重叠，那么将他们的值相加作为节点合并后的新值，否则不为NULL 的节点将直接作为新二叉树的节点。 示例1: 注意:合并必须从两个树的根节点开始。 二、思路 使用深度优先策略，遍历两颗二叉树的同一个位置，会出现以下情况 两个节点都为null，则合并后的节点也为null 两个节点都不为null，则创建一个新的节点，其值为...
LeetCode - 617 ：合并二叉树
517
09-13 393
合并二叉树 给定两个二叉树，想象当你将它们中的一个覆盖到另一个上时，两个二叉树的一些节点便会重叠。 你需要将他们合并为一个新的二叉树。合并的规则是如果两个节点重叠，那么将他们的值相加作为节点合并后的新值，否则不为 NULL 的节点将直接作为新二叉树的节点。 示例1：  输入：      输出：     注意： 合并必须从两个树的根节点开始。 解题思路 如果 Tree1 和...
React diff算法
程序员界科比的博客
08-15 257
1. 关于diff算法 1.1 什么是diff算法 diff算法即差异查找算法。 1.2 diff算法的作用 计算出虚拟DOM中真正变化的部分，并只针对该部分进行原生DOM操作，而非重新渲染整个页面。 1.3 传统diff算法 通过循环递归对节点进行依次对比，算法复杂度达到O(n^3)，n是树的节点数，效率极其低下。如果要展示1000个节点，要进行上亿次比较。现在的CPU每秒能执...
【Leetcode刷题篇】- Leetcode617 合并二叉树
Mind_programmonkey的博客
06-14 203
给定两个二叉树，想象当你将它们中的一个覆盖到另一个上时，两个二叉树的一些节点便会重叠。 你需要将他们合并为一个新的二叉树。合并的规则是如果两个节点重叠，那么将他们的值相加作为节点合并后的新值，否则不为 NULL 的节点将直接作为新二叉树的节点。 示例 1: 输入: Tree 1 Tree 2 1 2 / \ / \ 3 2 1 3
React的diff算法
xiaonuo930110的博客
03-23 376
React在界面刷新（setState）时，并不会马上对所有的DOM节点进行操作，而是先通过diff算法计算后，再对有变化的DOM节点进行操作（native是对原生UI层进行操作），刷新步骤如下： 1. state 变化，生成新的 Virtual Dom 2. 比较 Virtual Dom 与之前 Virtual Dom 的异同 3. 生成差异对象 4. 遍历差异对象并更新真实 DOM 一、Virtual Dom 概述 对 DOM 的操作很耗时，使用 JS 对象来模拟 DOM Tree，在渲染更新
C++数据结构——中序遍历二叉树
05-23
中序遍历是二叉树遍历的一种，遍历顺序为左子树、根节点、右子树。以下是C++代码实现： ```c++ #include using namespace std; struct TreeNode { int val; TreeNode* left; TreeNode* right; TreeNode(int x...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值