【数据结构】千字深入浅出讲解二叉树的顺序存储结构 — 堆（附原码 _ 超详解）

用户7016533327500
145 阅读8分钟

在这里插入图片描述

🚀write in front🚀 📝个人主页：认真写博客的夏目浅石. 🎁欢迎各位→点赞👍 + 收藏⭐️ + 留言📝 📣系列专栏：C语言实现数据结构 💬总结：希望你看完之后，能对你有所帮助，不足请指正！共同学习交流 🖊 ✉️==如果无聊的话，就来逛逛我的博客栈吧==stack-frame.cn

@TOC

前言

这几天看了数据结构的堆这一节，真的收获很大，第一次看没有动手敲代码就是感觉学了和没学一样，今天也是从新又看了一遍，并且边学边敲代码，终于算是非常理解堆这个东西了，今天就把我所学到的知识给大家分享一下。

一、二叉树的概念与性质

二叉树的概念：一棵二叉树是结点的一个有限集合，该集合:

  1. 或者为空
  2. 由一个根节点加上两棵别称为左子树和右子树的二叉树组成

在这里插入图片描述 从上图可以看出：

  1. 二叉树不存在度大于2的结点
  2. 二叉树的子树有左右之分，次序不能颠倒，因此二叉树是有序树

注意：对于任意的二叉树都是由以下几种情况复合而成的： 在这里插入图片描述 特殊的二叉树：

  1. 满二叉树：一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树。也就是说，如果一个二叉树的层数为K，且结点总数是 ，则它就是满二叉树。
  2. 完全二叉树：完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树而引出来的。对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树。 要注意的是满二叉树是一种特殊的完全二叉树。

二叉树的性质：

  1. 若规定根节点的层数为1，则一棵非空二叉树的第i层上最多有2^(i-1)个结点.
  2. 若规定根节点的层数为1，则深度为h的二叉树的最大结点数是2^(h-1).
  3. 对任何一棵二叉树, 如果度为0其叶结点个数为 , 度为2的分支结点个数为 则有 n0＝n2 ＋1(重点常用)

二、二叉树的顺序存储

二叉树的顺序结构存储是使用 数组存储。

一般使用数组只适合表示 完全二叉树，因为完全二叉树最后一层连续且其它层均满，使用顺序存储不存在空间浪费。

在这里插入图片描述 二叉树顺序存储在 物理 上是一个 数组，在 逻辑 上是一棵 二叉树。

我们这篇博客学习的堆就是使用 顺序存储 来实现。

三、堆的概念和结构

概念：如果有一个关键码的集合 K = {k0 ， k1 ， k2 ， … ， kn-1} ，把它的所有元素按完全二叉树的顺序存储方式存储在一 个一维数组中 ，并满足： Ki <= K2i+1 且 Ki<= K2i+2 (Ki >= K2i+1 且 Ki >=K2i+2) i = 0 ， 1 ， 2… ，则称为小堆 ( 或大堆) 。（即双亲比孩子的数值小(大)——小(大)堆）将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。

堆分为 大堆 和 小堆 ：

  • 大堆：树中所有父亲节点数据大于等于孩子节点数据
  • 小堆：树中所有父亲节点数据小于等于孩子节点数据

堆的性质：

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

在这里插入图片描述

四、堆的实现

1、结构的定义

堆是完全二叉树，其存储结构是顺序存储。那就和顺序表一样，将数据存在数组中，给定size 记录堆中元素个数，capacity 记录堆的最大容量。

typedef int HPDataType;
typedef struct Heap
{
	HPDataType* a; // 存储数据的空间
	int size; // 大小
	int capacity; // 容量
}HP;

2、接口总览

void HeapPrint(HP* php); // 打印
void HeapInit(HP* php); // 初始化
void HeapDestroy(HP* php); // 销毁
void HeapPush(HP* php, HPDataType x); // 堆尾插入数据
void HeapPop(HP* php); // 删除堆顶数据
HPDataType HeapTop(HP* php); // 取堆顶数据
int HeapSize(HP* hp); // 计算大小
bool HeapEmpty(HP* hp); // 判空
void AdjustUp(HPDataType* a, int child); // 向上调整
void AdjustDown(HPDataType* a, int n, int parent); // 向下调整

3、初始化

堆的初始化和顺序表是一样的，因为我们用的就是顺序存储：

void HeapInit(HP* php)
{
	assert(php);

	php->a = NULL;
	php->size = php->capacity = 0;
}

4、销毁

堆的销毁只要释放空间，然后把 size 和 capacity 置0就可以。

void HeapDestroy(HP* php)
{
	assert(php);

	free(php->a);
	php->a = NULL;

	php->size = php->capacity = 0;
}

5、插入

堆的插入就是在 数组尾部 的插入，就是 数组 的 尾插。

堆插入数据只会在尾部，所以无需封装接口用来扩容，直接判断是否要扩容就可以。

堆在插入数据后，需要保持堆的结构，之前是小/大堆，在插入数据后也应该是小/大堆。当插入数据后，如果破坏了结构，就需要 向上调整。

void HeapPush(HP* php, HPDataType x)
{
	assert(php);

	// 检查容量
	if (php->size == php->capacity)
	{
		int newcapacity = php->capacity == 0 ? 4 : php->capacity * 2;
		HPDataType* tmp = (HPDataType*)realloc(php->a, sizeof(HPDataType) * newcapacity);
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(-1);
		}
		php->a = tmp;
		php->capacity = newcapacity;
	}

	// 插入元素
	php->a[php->size++] = x;

	// 向上调整
	AdjustUp(php->a, php->size - 1);
}

6、向上调整(重要---关系建堆)

我们默认实现为 小堆，于是堆的插入就可能会造成 两种情况：

  1. 插入数据 大于 它的 父亲 ，插入后，仍然为小堆，这种情况无需调整：

在这里插入图片描述

  1. 插入数据 小于 它的 祖先(从根到该节点所经分支上的所有节点，就是它的父亲，爷爷等)，插入后，不为小堆，此时需要将 插入数据需要向上调整，直到它为小堆： 在这里插入图片描述 理清了这两个情况，再梳理一下细节：

向上调整，肯定是以 孩子为基准，孩子调整到堆顶就代表着向上调整结束了。如果使用父亲为基准的话，是非正常结束的(孩子调整到0没有结束，而是通过比较值后，break退出的)。

而中间的过程就是判断孩子是否小于父亲，如果小于就交换它们的值，然后将孩子迭代为父亲，再重新计算父亲，继续调整上方；如果孩子大于等于父亲，就退出，无需调整。

通过不断向上调整元素，就可以构建出来 小堆。

void Swap(HPDataType* p1, HPDataType* p2)
{
	assert(p1 && p2);

	HPDataType tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

void AdjustUp(HPDataType* a, int child)
{
	assert(a);

	// 求父亲
	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;
		}
	}
}

7、删除

堆的 删除 为删除 堆顶的数据。

对于删除来说，有两个方案：

  1. 直接头删
  2. 交换 堆顶 和 堆底 元素，尾删堆底元素，将堆顶元素 向下调整。(堆底元素就是数组尾部的元素)。

我们先看看 方案一 可不可行：

首先，由于堆是顺序存储的，那么 头删就要挪动数据，时间复杂度就为O(N)。

举个例子，假设 12 和 15 在第二层原本是兄弟，但是由于头删，12到了堆顶，变成了 15 的父亲.

所以，方案一就行不通了，那就只能使用 方案二 了：

方案二的话就很好，删除元素前，交换了堆顶和堆底的元素，然后将堆底尾删，尾删的时间复杂度只有O(1)。通过向下调整对堆顶元素 下调 时，也不会破坏过多的父子关系。

void HeapPop(HP* php)
{
	assert(php);
	assert(php->size > 0); // 堆空不能删

	// 交换堆顶和最后一个节点的值
	Swap(&php->a[0], &php->a[php->size - 1]);
	// 尾删
	php->size--;

	AdjustDown(php->a, php->size, 0); // 向下调整
}

8、向下调整(重要)

向下调整的步骤为：

  1. 找到左右孩子中的 小孩子。
  2. 判断 父亲 是否大于 小孩子，如果是则交换，不是则退出
  3. 交换后将 父亲迭代到大孩子的位置，重新计算孩子。

注意找最大孩子的时候，大孩子必须存在，小心越界。

向下调整的 循环条件 为 孩子下标 < 堆的大小，如果继续调整就越界了。

void Swap(HPDataType* p1, HPDataType* p2)
{
	assert(p1 && p2);

	HPDataType tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

void AdjustDown(HPDataType* a, int n, int parent)
{
	// 假设最小孩子
	int minchild = 2 * parent + 1;

	while (minchild < n)
	{
		// 找最小孩子
		if (minchild + 1 < n && a[minchild + 1] < a[minchild])
		{
			minchild++;
		}
        // 如果父亲大于孩子，调整
		if (a[parent] > a[minchild])
		{
			Swap(&a[parent], &a[minchild]); // 交换
			parent = minchild; // 迭代
			minchild = 2 * parent + 1;
		}
		else
		{
			break;
		}
	}
}

9、取堆顶数据

HPDataType HeapTop(HP* php)
{
	assert(php);
	assert(php->size > 0);

	return php->a[0];
}

10、计算堆大小

int HeapSize(HP* php)
{
	assert(php);

	return php->size;
}

11、判空

bool HeapEmpty(HP* php)
{
	assert(php);

	return php->size == 0;
}

12、打印堆

void HeapPrint(HP* php)
{
	assert(php);

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

五、完整代码

Heap.h

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

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

// 堆的构建
void HeapCreate(HP* hp, HPDataType* a, int n);

void HeapPrint(HP* php);
void HeapInit(HP* php);
void HeapDestroy(HP* php);

// 保持他继续是一个堆 O(logN)
void HeapPush(HP* php, HPDataType x);

// 删除堆顶的数据，并且保持他继续是一个堆 O(logN)
void HeapPop(HP* php);

HPDataType HeapTop(HP* php);

int HeapSize(HP* hp);
// 堆的判空
bool HeapEmpty(HP* hp);

Heap.c

#include "Heap.h"

void HeapPrint(HP* php)
{
	assert(php);

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

// 初始化 不开空间
void HeapInit(HP* php)
{
	assert(php);

	php->a = NULL;
	php->size = php->capacity = 0;
}

// 销毁
void HeapDestroy(HP* php)
{
	assert(php);

	free(php->a);
	php->a = NULL;

	php->size = php->capacity = 0;
}

void Swap(HPDataType* p1, HPDataType* p2)
{
	assert(p1 && p2);

	HPDataType tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

// 向上调整
void AdjustUp(HPDataType* a, int child)
{
	assert(a);

	// 算父亲
	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;
		}
	}
	
}

// 保持他继续是一个堆 O(logN)
void HeapPush(HP* php, HPDataType x)
{
	assert(php);

	// 检查容量
	if (php->size == php->capacity)
	{
		int newcapacity = php->capacity == 0 ? 4 : php->capacity * 2;
		HPDataType* tmp = (HPDataType*)realloc(php->a, sizeof(HPDataType) * newcapacity);
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(-1);
		}
		php->a = tmp;
		php->capacity = newcapacity;
	}

	// 插入元素
	php->a[php->size++] = x;

	// 向上调整
	AdjustUp(php->a, php->size - 1);
}

// 向下调整
void AdjustDown(HPDataType* a, int n, int parent)
{
	// 假设最小孩子
	int minchild = 2 * parent + 1;

	while (minchild < n)
	{
		// 找最小孩子
		if (minchild + 1 < n && a[minchild + 1] < a[minchild])
		{
			minchild++;
		}
		if (a[parent] > a[minchild])
		{
			Swap(&a[parent], &a[minchild]);
			parent = minchild;
			minchild = 2 * parent + 1;
		}
		else
		{
			break;
		}
	}
}

// 删除堆顶的数据，并且保持他继续是一个堆 O(logN)
void HeapPop(HP* 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(HP* php)
{
	assert(php);
	assert(php->size > 0);

	return php->a[0];
}

int HeapSize(HP* php)
{
	assert(php);

	return php->size;
}
// 堆的判空
bool HeapEmpty(HP* php)
{
	assert(php);

	return php->size == 0;
}

test.c

#include "Heap.h"

void TestHp1()
{
	HP hp;
	HeapInit(&hp);
	
	int array[] = { 26, 14, 15, 16, 27, 32, 64, 47, 24, 34 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	
	for (int i = 0; i < sz; i++)
	{
		HeapPush(&hp, arr[i]);
	}

	HeapPrint(&hp);

	HeapPop(&hp);
	HeapPrint(&hp);

    // 取五个最小数据
	/*int k = 5;
	while (k--)
	{
		printf("%d ", HeapTop(&hp));
		HeapPop(&hp);
	}*/

	HeapDestroy(&hp);
}

void TestHp2()
{
	int array[] = { 26, 14, 15, 16, 27, 32, 64, 47, 24, 34 };
	HP hp;
	HeapInit(&hp);
	for (int i = 0; i < sizeof(array) / sizeof(int); ++i)
	{
		HeapPush(&hp, array[i]);
	}

    // 排序
	while (!HeapEmpty(&hp))
	{
		printf("%d ", HeapTop(&hp));
		HeapPop(&hp);
	}

	HeapDestroy(&hp);
}

int main()
{
	TestHp1();
	//TestHp2();
	
	return 0;
}

总结

  今天学习了堆的知识，初次写数据结构的知识，给我的感觉就是，==学三遍不如手敲代码一遍来的实在==，所以数据结构的学习我将多画图，多敲代码来学习，希望大家吸取经验和我一起学习数据结构，为后面打比赛刷题打下坚实基础。

  我是夏目浅石，希望和你一起学习进步，刷题无数！！！希望各位大佬==能一键三连==支持一下博主，hhhh~我们下期见喽 在这里插入图片描述 ==如果无聊的话，就来逛逛我的博客栈吧==stack-frame.cn

✨原创不易，还希望各位大佬支持一下\textcolor{blue}{原创不易，还希望各位大佬支持一下}
👍 点赞，你的认可是我创作的动力！\textcolor{9c81c1}{点赞，你的认可是我创作的动力！}
⭐️ 收藏，你的青睐是我努力的方向！\textcolor{ed7976}{收藏，你的青睐是我努力的方向！}
✏️ 评论，你的意见是我进步的财富！\textcolor{98c091}{评论，你的意见是我进步的财富！}

avatar
文章
阅读
粉丝