二叉树顺序结构实现【堆的实现】【详细图解】

最新推荐文章于 2024-11-08 14:08:42 发布
最新推荐文章于 2024-11-08 14:08:42 发布
阅读量1k 收藏 30
点赞数 32
分类专栏： 数据结构专栏 文章标签： 数据结构 算法 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liu11e/article/details/139262144
版权
P. S.：以下代码均在VS2019环境下测试，不代表所有编译器均可通过。
P. S.：测试代码均未展示头文件stdio.h的声明，使用时请自行添加。

  

目录





1、二叉树的顺序结构


  二叉树的顺序结构是指将数据以完全二叉树的逻辑结构进行存储的结构。
  但二叉树是多种多样的，为何在日常应用中很少见到普通的二叉树，且看下图中的普通二叉树与完全二叉树的展示。

在这里插入图片描述
  上图中左侧是一个普通的二叉树，右侧是一个完全二叉树（也可称之为满二叉树），当使用顺序结构进行存储时，可以发现作图的存储存在着大量的空间浪费，而右侧的完全二叉树却没有浪费很多空间。


  故在实现二叉树的顺序结构时所使用的是完全二叉树，而这一种存储方式，也称之为堆（ PS. 此处的堆和操作系统虚拟进程地址空间中的堆是两回事，一个是数据结构，一个是操作系统中管理内存的一块区域分段）。




2、堆的概念


  若一组数据按照二叉树的顺序存储方式存储在一维数组中，就将其称作 “堆” 。
  堆也有大堆和小堆之分：
   大堆 ：在二叉树中所有的父结点均比子结点所代表的数值大，称之为大堆。
   小堆 ：在二叉树中所有的父结点均比子结点所代表的数值小，称之为小堆。
（ PS. 此处的大堆小堆是指父结点与子结点的大小关系，并不代表所存储数据在一维数组中一定有序。）


有关一维数组中如何寻找父子结点所在位置及其位置之间的关系，回看：
  链接: 数据结构—二叉树相关概念【详解】【画图演示】


有关树中结点之间的关系及其概念，回看：
  链接: 【树】简要理解树的概念




3、堆的实现


3.1 堆实现的前提


  在日常使用中，所输入数据之间维持大堆或小堆关系的情况较少出现，所以在输入数据时，一般需要使用向下调整或向上调整算法对所输入的数据大堆或小堆化，以便更好地使用。
  故在开始堆的实现前，需要先进行向上调整和向下调整算法的实现，后文命名为AdjustUp，AdjustDown。

3.1.1 向上调整


  向上调整是指每一次输入数据时，从输入数据位置作为子结点，与父结点进行比较，若子结点大于父节点，进行数值上的交换（此时构建的是大堆，反之构建的为小堆），交换后将此时的父结点看作新的子结点，再向上进行交换，直至到达根节点或出现子结点小于父结点为止。

在这里插入图片描述

  • 上图为输入28时所展现的向上调整示意图。

具体代码实现如下所示：

void AdjustUp(HPDataType* 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;
	}
}
  • 代码块中所展示的Swap函数是一个简单的交换变量数值的函数。

3.1.2 向下调整


  向下调整的方式和向上调整的方式大致相同，以根作为父结点，与其两个子结点中最大的进行比较，若父结点所代表数值小于最大的子结点，则与之交换数值，而后以交换后的子结点作为新的父节点开启新一轮比较，直至出现父节点大于子结点的情况或到达叶子节点（此种方法所构建的是大堆，将上文中的比较词汇取反即可构建小堆）。

在这里插入图片描述

  • 上图中所展示的是通过向下调整构建小堆的过程。

具体代码如下所示：

void AdjustDown(HPDataType* a, int size, int parent)
{
	int child = parent * 2 + 1;
	while (child < size)
	{
		if (child + 1 < size && a[child + 1] > a[child])//child + 1 < size 是为了避免子结点越界
		{
			++child;
		}
		if (a[child] > a[parent])
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

3.2 堆实现


  因堆的实践中只有核心代码需要解释，其余部分代码将会在标题 4、完整代码展示 中展示。

3.2.1 数据插入


  
  • 结构体等相关定义展示
typedef int HPDataType;

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

void HPPush(HP* php, HPDataType x);

  因堆顺序结构的定义如上，且其中代表数组的是一个指向数据类型的指针，故我们需要进行数组的空间开辟，故出现了如下代码：

if (php->size == php->capacity)
	{
		int newcapacity = php->capacity == 0 ? 4 : 2 * php->capacity;
		HPDataType* tmp = (HPDataType*)realloc(php->a, sizeof(HPDataType) * newcapacity);
		if (tmp == NULL)
		{
			perror("HPPush:realloc fail");
			return;
		}
		php->a = tmp;
		php->capacity = newcapacity;
	}

  上图代码中我们需要先判断数组中的空间是否足够，即php->size == php->capacity，若判断条件成立，则进入扩容阶段，一般在扩容时我们会进行原有数组空间大小的二倍扩容，这一依据是根据相关研究者的研究所得出的结论，并应用realloc对原数组进行扩容。

  • 完整代码展示
void HPPush(HP* php, HPDataType x)
{
	assert(php);
	if (php->size == php->capacity)
	{
		int newcapacity = php->capacity == 0 ? 4 : 2 * php->capacity;
		HPDataType* tmp = (HPDataType*)realloc(php->a, sizeof(HPDataType) * newcapacity);
		if (tmp == NULL)
		{
			perror("HPPush:realloc fail");
			return;
		}
		php->a = tmp;
		php->capacity = newcapacity;
	}
	php->a[php->size] = x;
	php->size++;

	AdjustUp(php->a, php->size - 1);
}

  上述代码块中再插入数据后进行了向上调整，令所插入的数据形成大堆或小堆，以便后续使用。
  向上调整代码及原理回看3.1.1向上调整 。


3.2.2 数据删除


  数据删除阶段所删除的数据是根节点的数据，在直接删除根节点的数据后，堆中谁能作为新的根节点就成了不可避免的问题，为此可以直接将最后一位数据与第一位数据进行交换，再从根节点开始向下调整，这样就可以从堆中筛选出第二大或第二小的数据来作为新的根，并避免了不必要的麻烦。
  • 完整代码展示
void HPPop(HP* php)
{
	assert(php);
	assert(php->size > 1);
	
	Swap(&php->a[0], &php->a[php->size - 1]);
	
	php->size--;
	
	AdjustDown(php->a, php->size, 0);
}

  向下调整代码及原理回看3.1.2向下调整 。




4、完整代码展示

4.1 Heap.h

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

typedef int HPDataType;

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

void Swap(HPDataType* p1, HPDataType* p2);

void HPInit(HP* php);

void HPDestroy(HP* php);

void AdjustUp(HPDataType* a, int child);

void HPPush(HP* php, HPDataType x);

void AdjustDown(HPDataType* a, int size, int parent);

void HPPop(HP* php);

HPDataType HPTop(HP* php);

bool HPEmpty(HP* php);

int HPSize(HP* php);

4.2 Heap.c

#include "Heap.h"

void Swap(HPDataType* p1, HPDataType* p2)
{
	HPDataType tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

void HPInit(HP* php)
{
	assert(php);
	php->a = NULL;
	php->size = php->capacity = 0;
}

void HPDestroy(HP* php)
{
	assert(php);
	free(php->a);
	php->a = NULL;
	php->size = php->capacity = 0;
}

void AdjustUp(HPDataType* 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;
		}
	}
}

void HPPush(HP* php, HPDataType x)
{
	assert(php);
	if (php->size == php->capacity)
	{
		int newcapacity = php->capacity == 0 ? 4 : 2 * php->capacity;
		HPDataType* tmp = (HPDataType*)realloc(php->a, sizeof(HPDataType) * newcapacity);
		if (tmp == NULL)
		{
			perror("HPPush:realloc fail");
			return;
		}
		php->a = tmp;
		php->capacity = newcapacity;
	}
	php->a[php->size] = x;
	php->size++;

	AdjustUp(php->a, php->size - 1);
}

void AdjustDown(HPDataType* a, int size, int parent)
{
	int child = parent * 2 + 1;
	while (child < size)
	{
		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 HPPop(HP* php)
{
	assert(php);
	assert(php->size > 1);
	
	Swap(&php->a[0], &php->a[php->size - 1]);
	
	php->size--;
	
	AdjustDown(php->a, php->size, 0);
}

HPDataType HPTop(HP* php)
{
	assert(php);
	assert(php->size > 0);
	return php->a[0];
}

bool HPEmpty(HP* php)
{
	assert(php);
	return php->size == 0;
}

int HPSize(HP* php)
{
	assert(php);
	return php->size;
}

4.3 Heaptest.c

#include "Heap.h"

void test()
{
	HP s;
	HPInit(&s);
	HPPush(&s, 123);
	HPPush(&s, 12);
	HPPush(&s, 1);
	HPPush(&s, 321);
	HPPush(&s, 32);
	HPPush(&s, 3);
	printf("输入数据为：123，12，1，321，32，3\n");
	printf("插入数据后数组内成员展示：");
	for (int i = 0; i < s.size; i++)
	{
		printf("%d ", s.a[i]);
	}
	printf("\n");
	HPPop(&s);
	HPPop(&s);
	printf("删除数据后数组内成员展示：");
	for (int i = 0; i < s.size; i++)
	{
		printf("%d ", s.a[i]);
	}
	printf("\n");
	printf("此时调用判空函数后结果展示：");
	if (HPEmpty(&s))
		printf("yes\n");
	else
		printf("no\n");
	printf("此时数组内成员个数：");
	printf("%d\n", HPSize(&s));
	printf("此时根节点的数据为：");
	printf("%d\n", HPTop(&s));
}

int main()
{
	test();
	return 0;
}




5、拓展堆排序


  堆排序的相关内容可以观看博主以往的博文：

    链接: 图解堆排序【一眼看穿逻辑思路】




6、结语


  十分感谢您观看我的原创文章。
  本文主要用于个人学习和知识分享，学习路漫漫，如有错误，感谢指正。
  如需引用，注明地址。

LiUEEEEE
关注
专栏目录
堆排序详细图解（通俗易懂）
oorik的博客
02-17 25万+
什么是堆 堆是一种叫做完全二叉树的数据结构，可以分为大根堆，小根堆，而堆排序就是基于这种结构而产生的一种程序算法。 堆的分类 大根堆:每个节点的值都大于或者等于他的左右孩子节点的值 小根堆:每个结点的值都小于或等于其左孩子和右孩子结点的值 两种结构映射到数组为: 大根堆: 小根堆: //父-->子:i--->左孩子:2*i+1, 右孩子:2*i+2; //子-->父:i--->(i-1)*2;(i为下标元素) 排序思想 1.首先将待排序的数...
C语言实现顺序结构二叉树-堆
m0_73605503的博客
07-24 769
欢迎来到HanLop博客的C语言数据结构初阶系列。在这个系列中，我们将深入探讨各种基本的数据结构和算法，帮助您打下坚实的编程基础。在本篇文章中，我们将讲解顺序结构的二叉树，特别是堆（Heap）。堆是一种特殊的完全二叉树，它满足堆属性，即每个节点的值都大于或等于（或小于或等于）其子节点的值。堆在许多算法中起着至关重要的作用，例如优先队列的实现和堆排序。在这篇文章中，我们将介绍堆的基本概念、堆的创建和操作方法，以及其在实际编程中的应用。通过一些实际的代码示例，您将更好地掌握堆在C语言中的实现和应用。
二叉树的顺序实现-堆
都市隸人的博客
05-31 670
本文详细介绍了堆的概念及其应用，并附上了详细的图解以及C语言源码
数据结构-二叉树图解与实现
qq_40988139的博客
06-18 928
需要一种数据结构来平衡查找与插入效率，使得查找速度和插入速度都能得到提升，因此有了树这种数据结构。如果该二叉树的所有叶子节点都在最后一层，并且结点总数= 2^n -1 , n为层数，则我们称为满二叉树。 如果该二叉树的所有叶子节点都在最后一层或者倒数第二层，而且最后一层的叶子节点在左边连续，倒数第二层的叶子节点在右边连续，我们称为完全二叉树 前序遍历先遍历父节点，再遍历左子节点，最后遍历右子节点中序遍历先遍历左子节点，再遍历父节点，最后遍历右子节点后序遍历先遍历左子节点，再遍历右子节点，最后遍历父节点可以看
二叉树的初步学习和顺序结构实现（上）
weixin_71964451的博客
03-17 838
好了，小伙伴们，今天我们就先学到这里，下一节我们学习二叉树的链式结构的实现，今天的知识点一定要好好理解，该画图的时候画图，不要嫌麻烦，要为后面的学习打基础。
数据结构：二叉树的顺序结构--堆
Yikefore的博客
05-24 1597
二叉树的顺序结构--堆详细解读，附带图解和完整代码
数据结构-二叉树·堆（顺序结构的实现）
2301_77509762的博客
11-04 1930
本篇文章对 树的相关概念及结构，二叉树（堆）的概念及结构，二叉树顺序结构及实现的相关知识详细讲解！二叉树链式结构在下一章讲解！
二叉树链式结构与简单实现
瞌睡不来的博客
09-14 977
二叉树链式结构简单实现与源码展示
二叉树—堆（C语言实现）
2401_83431652的博客
05-29 1101
树是一种非线性的数据结构，它是有n（n > 0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一颗倒挂的树，也就是说它是根朝上，而叶朝下。树结构相对线性表就比较复杂，要存储表示起来就比较麻烦，既然保存值域，也要保存结点和结点之间的关系，实际上数有很多表示方式比如：双亲表示法，孩子表示法，孩子双亲表示法以及孩子兄弟表示法等。我们这里就简单的理解其中最常用的孩子兄弟表示法。 二、二叉树的概念及结构 1.概念 由上图可知： 注意：对于任意的二叉树都是有以下几种情况符合而成的：(1)满
图解二叉树的三种遍历方式及java实现代码
08-30
图解二叉树的三种遍历方式及Java实现代码 二叉树是一种特殊的树形结构，每个节点最多只有两个子节点，即左子树和右子树。二叉树节点是二叉树的基本组成单元，它由节点元素、左子树指针和右子树指针组成。 二叉树...
二叉树链式结构的实现
mmz123_的博客
10-30 758
文章目录二叉树的遍历前序遍历中序遍历：后序遍历节点个数及高度等求二叉树节点个数求二叉树叶子节点个数求二叉树第k层节点个数求二叉树深度/高度查找值为x的节点二叉树基础oj练习单值二叉树二叉树的前序遍历 二叉树的遍历 为了先了解二叉树的结构，此处先手动快速创建一棵简单的二叉树： typedef char BTDataType; typedef struct BinaryTreeNode { BTDataType _data; struct BinaryTreeNode* _left; struct Bi
数据结构：二叉树（带图详解）
热门推荐
xu_haopeng的博客
11-01 1万+
目录 树的概念和结构 树的概念 树的表示形式 二叉树 二叉树的概念 两种特殊的二叉树 1、满二叉树 2、完全二叉树 二叉树的性质 二叉树的存储 二叉树的遍历 1. 前中后序遍历 还原二叉树 2、层序遍历 二叉树的基本操作 树的概念和结构 树的概念 树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看 起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。 它具有以下的特点： 有一个特殊的结点，称为根结点...
数据结构:二叉树及堆排序
m0_64240499的博客
08-12 582
二叉树初阶及堆排序
数据结构 栈和队列
最新发布
qq_67140973的博客
11-08 502
正文开始。
Java：数据结构-Lambda表达式
blamep的博客
11-08 542
lambda表达式允许你通过表达式来代替功能接口。lambda表达式就和方法一样,它提供了一个正常的参数列表和一个使用这些参数的主体(body,可以是一个表达式或一个代码块)。
【数据结构与算法】第9课—数据结构之二叉树(链式结构)
weixin_70620792的博客
11-05 767
2为底，n+1为对数，n为二叉树节点数。
【STL栈和队列】：高效数据结构的应用秘籍
LH__1314的博客
11-05 953
C++ 标准模板库（STL）为我们提供了多种容器，其中stack（栈）和queue（队列）是非常常用的两种容器。根据之前C语言实现的栈和队列，（如有遗忘，请回去看看【数据结构】— 栈和队列-CSDN博客）我们知道一些栈和队列的逻辑，现在就来学习C++STL中的栈和队列。eque`（双端队列）既可以当作栈，也可以当作队列使用。我们可以在双端队列的两端进行插入和删除操作，从而更灵活地实现栈和队列的功能。​对于双端队列，简单来说，就是可以像vector那样随机访问，也可以像链表那样随机位置插入；
Java：数据结构-枚举
blamep的博客
11-08 365
枚举 概念：将一组常量组织起来，在这之前表示一组常量通常使用定义常量的方式。 public static final int RED = 1; public static final int GREEN = 2; public static final int BLACK = 3; 枚举的使用 public enum enumTest { RED(0,"RED"),GREEN(1,"GREEN"),BLUE(2,"BLUE"), BLACK(3,"BLACK"),WHI
C语言实现数据结构之堆
0xFFFFFFFF
11-08 1392
在这篇文章，我们使用C语言实现了一个物理存储结构为动态顺序表，逻辑结构为二叉树的堆，并实现了堆排序——一种比较快的排序
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值