数据结构——树——堆

THOVOH

已于 2024-05-28 17:04:40 修改

阅读量705

点赞数 23

文章标签：算法数据结构 c语言开发语言

于 2024-05-28 16:58:54 首次发布

本文链接：https://blog.csdn.net/THOVOH/article/details/139237917

版权

1 堆的概念及结构

如果有一个关键码的集合K = { k0、k1、k2......kn }，把它的所有元素按完全二叉树的顺序存储方式存储在一个一维数组中，并满足：ki <= k2*i+1且ki <= k2*i+2 (ki => k2*i+1且ki => k2*i+2) i = 0，1， 2…，则称为小堆(或大堆)。将根结点最大的堆叫做最大堆或大根堆，根结点最小的堆叫做最小堆或小根堆。

堆的性质：

堆中某个结点的值总是不大于或不小于其父结点的值；

堆总是一棵完全二叉树。

这里就会是数据结构里面第一次遇到逻辑结构与存储结构不相同的数据结构类型，要注意的是堆的逻辑结构是树，但存储结构是数组。

可以根据这个选择题，来尝试对堆的理解。

可以像这样画图来判断到底是不是堆

2 堆的实现

2.1 堆向下调整算法

现在我们给出一个数组，逻辑上看做一颗完全二叉树。我们通过从根结点开始的向下调整算法可以把它调整成一个小堆。向下调整算法有一个前提：左右子树必须是一个堆，才能调整。

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

已知父节点然后求较小子节点进行比较，然后交换，这里主要就是采用父节点与子节点的下标进行比较，如果有不记得已知父节点求子节点下标的朋友，可以参考数据结构——树这一篇博客去理解。

#pragma once
#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;


//堆的存储结构中的头文件以及堆结构体的创建

//交换父节点和子节点，swap函数
void swap(HPDataType* p1, HPDataType* p2)
{
	HPDataType tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}
//向下调整
void AdjustDown(HPDataType* a, int n, int parent)  //第一个参数为 数组地址，第二个参数为 元素个数 及数组元素个数，第三个参数为父节点位置

{
	//假设左孩子小
	int child = parent * 2 + 1;
	while (child < n)
	{
		//先找出小的子节点，如果右孩子小，就取右孩子
		if (child + 1 < n && a[child + 1] < a[child])  //  //  大堆 if (child + 1 < n && a[child + 1] > a[child])
		{                                                  //  小堆 if (child + 1 < n && a[child + 1] < a[child])
			child++;
		}
		//将父节点与较小的子节点进行比较，如果父节点大于子节点就进行交换
		if (a[parent] > a[child])                    // 大堆  	if (a[parent] < a[child]) 
		{                                            // 小堆  	if (a[parent] > a[child]) 
			swap(&a[parent], &a[child]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

//向下调整代码

这里为什么会传数组地址，是为了后续实现堆排序做准备，当然这里也可以传结构体指针。

2.2 堆向上调整算法

向上调整算法就是已知子节点找父节点然后进行比较，以小堆为例，如果子节点小于父节点，就swap交换。

//向上调整，谁小谁做父节点
void AdjustUp(HPDataType*a, int child)
{
	int parent = (child - 1) / 2;
	while (child > 0)
	{
		if (a[child] < a[parent])                      //   大堆   if (a[child] > a[parent]) 
		{                                              //   小堆   if (a[child] < a[parent])  
			swap(&(a[child]), &(a[parent]));
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

2.3 堆的创建

下面我们给出一个数组，这个数组逻辑上可以看做一颗完全二叉树，但是还不是一个堆，现在我们通过算法，把它构建成一个堆。根结点左右子树不是堆，我们怎么调整呢？这里我们从倒数的第一个非叶子结点的子树开始调整，一直调整到根结点的树，就可以调整成堆。

2.2.1 向上调整建堆

int a[] = {1,5,3,8,7,6};

因此就可以采用直接向下调整建堆，可以根据自己需要，来建大堆还是小堆

void CreatSort(int *a)
{
	//降序   建小堆
	//升序   建大堆
	for (int i = 0; i < n; i++)
	{
		AdjustUp(a, i);
	}
}
void HeapTest03()
{
	int a[] = { 4,2,8,1,5,6,7,9 };
	CreatHeap(a);
}

2.2.2 向下调整建堆

代码实现：

void CreatSort(int *a, int n)
{

	//降序   建小堆
	//升序   建大堆
	//向下调整建堆
	for (int i = n - 1;i > 0;i--)
	{
		AdjustDown(a, i, 0);
	}
}

void HeapTest03()
{
	int a[] = { 4,2,8,1,5,6,7,9 };
	CreatSort(a, sizeof(a) / sizeof(a[0]));

}

2.4 堆的删除

删除堆是删除堆顶的数据，将堆顶的数据根最后一个数据一换，然后删除数组最后一个数据，再进行向下调整算法。因为删除堆底部数据没有什么意义。

void HPPop(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);
}

2.5 堆的代码实现

//堆的初始化
void HPInit(HP* php)
{
	assert(php);
	php->a = NULL;
	php->capacity = 0;
	php->size = 0;
}


//交换父节点和子节点，swap函数
void swap(HPDataType* p1, HPDataType* p2)
{
	HPDataType tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

//向上调整，谁小谁做父节点
void AdjustUp(HPDataType*a, int child)
{
	int parent = (child - 1) / 2;
	while (child > 0)
	{
		if (a[child] < a[parent])                      //   大堆   if (a[child] > a[parent]) 
		{                                              //   小堆   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->capacity == php->size)
	{
		int newcapacity = php->capacity = 0 ? 4 : php->capacity * 2;
		HPDataType* tmp = (HPDataType*)realloc(php->a, newcapacity * sizeof(HPDataType));
		if (tmp == NULL)
		{
			perror("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 n, int parent)
{
	//假设左孩子小
	int child = parent * 2 + 1;

	while (child < n)
	{
		//先找出小的子节点，如果右孩子小，就取右孩子
		if (child + 1 < n && a[child + 1] < a[child])  //  //  大堆 if (child + 1 < n && a[child + 1] > a[child])
		{                                                  //  小堆 if (child + 1 < n && a[child + 1] < a[child])
			child++;
		}
		//将父节点与较小的子节点进行比较，如果父节点大于子节点就进行交换
		if (a[parent] > a[child])                    // 大堆  	if (a[parent] < a[child]) 
		{                                            // 小堆  	if (a[parent] > a[child]) 
			swap(&a[parent], &a[child]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

//删除堆顶元素
void HPPop(HP* php)
{
	assert(php);
	assert(php->size > 0);
	//php->a[0] = php->a[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;
}


//堆的销毁
void HPDestory(HP* php)
{
	assert(php);
	free(php);
	php->a = NULL;
	php->capacity = php->size = 0;
}

喜欢的朋友可以点一下赞，下一期将给大家带来堆排序及两种建堆算法时间复杂度的分析。