C语言基础数据结构——树，二叉树，堆的实现

S+叮当猫

已于 2023-09-23 22:26:37 修改

阅读量227

点赞数

文章标签：数据结构

于 2023-09-09 23:15:56 首次发布

本文链接：https://blog.csdn.net/weixin_63716012/article/details/132747558

版权

头文件（包含头文件的引用，和函数的声明）：

什么是树？

树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。

树的相关概念

节点的度：一个节点含有的子树的个数称为该节点的度；

叶节点或终端节点：度为0的节点称为叶节点；

非终端节点或分支节点：度不为0的节点；

双亲节点或父节点：若一个节点含有子节点，则这个节点称为其子节点的父节点；

孩子节点或子节点：一个节点含有的子树的根节点称为该节点的子节点；

兄弟节点：具有相同父节点的节点互称为兄弟节点；

树的度：一棵树中，最大的节点的度称为树的度；

节点的层次：从根开始定义起，根为第1层，根的子节点为第2层，以此类推；

树的高度或深度：树中节点的最大层次（树的高度有两种说法，一种认为树的根不计入高度，一种认为树的根计入高度，推荐将树的根计入树的高度）

堂兄弟节点：双亲在同一层的节点互为堂兄弟；

节点的祖先：从根到该节点所经分支上的所有节点；

子孙：以某节点为根的子树中任一节点都称为该节点的子孙。

森林：由m（m>0）棵互不相交的树的集合称为森林；

概念部分总结：

1.树的每个节点的身份都不唯一，如图，B节点为A节点的子节点的同时，也作为C节点的父节点。

2.每棵树都可以宽泛的理解为由分支节点和叶子节点组成。

3.每个节点有且仅有一个父亲节点，如果某个节点有两个父亲节点，那么这个树就变成了“图”。

树的表示：

1.在明确树的度的情况下，挨个节点开间来表示。

2.双亲表示法：每个树的节点只存储该节点的双亲节点的指针。

3.左孩子右兄弟表示法：每个节点内部有两个指针，一个指向最左边的孩子，一个指向该节点右边第一个兄弟节点。

struct TreeNode
{
    struct TreeNode* FistChild;
    struct TreeNode* NextBro;
    int data;
}

二叉树：

1. 二叉树不存在度大于2的结点

2. 二叉树的子树有左右之分，次序不能颠倒，因此二叉树是有序树

特殊的二叉树：

满二叉树：

一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树。也就是说，如果一个二叉树的层数为K，且结点总数是2^k-1 ，则它就是满二叉树。

完全二叉树：

假设一个二叉树，他有n层，如果前n-1层符合满二叉树，且第n层连续，那么这个二叉树为一个完全二叉树。

完全二叉树的性质：

完全二叉树节点最大值为2^n-1，即满二叉树的节点数量。

完全二叉树节点最小值为2^(n-1)，即前n-1层符合满二叉树，最后一层只有一个节点。

完全二叉树的应用——堆

什么是堆？

满足：堆中某个节点的值总是不大于或不小于其父节点的值的完全二叉树叫做堆。

堆的分类：

小根堆：

父节点的值总小于子节点的值。

大根堆：

子节点的值总小于父节点的值。

堆的应用：

①堆排序

②topk

③优先级队列

大根堆的实现：

实现方法：

堆是完全二叉树的应用，而顺序存储十分契合完全二叉树，所以使用顺序存储。

完全二叉树中如果知道一个节点的位置，就可以推导出该节点的父节点和子节点的位置。具体的公式为——（子节点位置-1）/2=父节点位置。

头文件（包含头文件的引用，和函数的声明）：

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

#define HeapType int

typedef struct Heap
{
	HeapType* a;
	int size;
	int capacity;
}Heap;

void HeapInit(Heap* hp);
void HeapDestory(Heap* hp);
void HeapPush(Heap* hp, HeapType x);
int HeapEmpty(Heap* hp);
void HeapPop(Heap* hp);
HeapType HeapTop(Heap* hp);

函数实现文件（函数的具体实现）：

#include"heap.h"    //声明包含头文件

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

void HeapDestory(Heap* hp)//堆的销毁
{
	assert(hp);
	hp->size = 0;
	hp->capacity = 0;
	free(hp->a);
	hp->a = NULL;
}

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

void AdjustUp(HeapType* a, int child)
//判断函数，如果子节点的值大于父节点的值
//交换两个节点的值
{
	assert(a);
	while (child > 0)
	{
		int parent = (child - 1) / 2;
		if (a[child] > a[parent])
		{
			Swap(&a[child], &a[parent]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

void HeapPush(Heap* hp, HeapType x)
//插入节点函数，插入前判断空间是否足够
//足够则插入，不够则扩容
{
	assert(hp);
	if (hp->size == hp->capacity)
	{
		int newcapacity = hp->capacity == 0 ? 4 : hp->capacity * 2;
		HeapType* tmp = (HeapType*)realloc(hp->a, sizeof(hp->a) * newcapacity);
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}
		hp->a = tmp;
		hp->capacity = newcapacity;
	}
	hp->a[hp->size] = x;
	hp->size++;
	AdjustUp(hp->a, hp->size - 1);
}

int HeapEmpty(Heap* hp)
{
	assert(hp);
	return hp->size == 0;
}

void AdjustDown(HeapType* 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 HeapPop(Heap* hp)
{
	assert(hp);
	assert(!HeapEmpty(hp));
	Swap(hp->a[0], hp->a[hp->size - 1]);
	hp->size--;
	AdjustDown(hp->a, hp->size, 0);
}

HeapType HeapTop(Heap* hp)
{
	assert(hp);
	assert(!(HeapEmpty(hp)));
	return hp->a[0];
}

int HeapSize(Heap* hp)
{
	assert(hp);
	return hp->size;
}

测试文件：

#include"heap.h"
int main()
{
	Heap hp;
	HeapInit(&hp);
	HeapType arr[] = { 23,53,143,42,4,445,322 };
//这里的括号修改你要排序的元素
	for (int i = 0; i < sizeof(arr) / sizeof(HeapType); i++)
	{
		HeapPush(&hp, arr[i]);
	}
	return 0;
}

函数解析：

堆初始化：

①判断传过来的结构体指针是否为空

②将结构体中指向数组的指针设置为空指针

③将数组大小和数组容量设置为0。

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

堆销毁：

①判空

②将数组的大小和容量设置为0

③释放空间，再将数组指针设置为空。

void HeapDestory(Heap* hp)//堆的销毁
{
	assert(hp);
	hp->size = 0;
	hp->capacity = 0;
	free(hp->a);
	hp->a = NULL;
}

堆插入：

①判空；

②判断数组是否需要扩容空间，如果需要则将空间调整为之前的两倍。

③插入数据

④执行向上调整函数，将数组调整为大根堆

void HeapPush(Heap* hp, HeapType x)
//插入节点函数，插入前判断空间是否足够
//足够则插入，不够则扩容
{
	assert(hp);
	if (hp->size == hp->capacity)
	{
		int newcapacity = hp->capacity == 0 ? 4 : hp->capacity * 2;
		HeapType* tmp = (HeapType*)realloc(hp->a, sizeof(hp->a) * newcapacity);
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}
		hp->a = tmp;
		hp->capacity = newcapacity;
	}
	hp->a[hp->size] = x;
	hp->size++;
	AdjustUp(hp->a, hp->size - 1);
}

堆的向上调整：

①判空

②循环调整数组，使得其成为大根堆，Swap函数为交换函数，交换父子节点的值

void AdjustUp(HeapType* a, int child)
//判断函数，如果子节点的值大于父节点的值
//交换两个节点的值
{
	assert(a);
	while (child > 0)
	{
		int parent = (child - 1) / 2;
		if (a[child] > a[parent])
		{
			Swap(&a[child], &a[parent]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

堆删除堆顶元素：

①判空

②判断数组是否为空（HeapEmpty函数判断）

③交换堆顶和堆底元素，删除堆底元素。

④向下调整堆顶元素

void HeapPop(Heap* hp)
{
	assert(hp);
	assert(!HeapEmpty(hp));
	Swap(hp->a[0], hp->a[hp->size - 1]);
	hp->size--;
	AdjustDown(hp->a, hp->size, 0);
}

堆的向下调整：

①默认找到左孩子

②循环调整，因为涉及大根堆或是小根堆不同的情况，要判断出左右孩子的大小问题，完成判断后调整孩子节点和父亲节点的值。

void AdjustDown(HeapType* 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;
		}
	}
}

堆顶元素的获取：

HeapType HeapTop(Heap* hp)
{
	assert(hp);
	assert(!(HeapEmpty(hp)));
	return hp->a[0];
}

S+叮当猫

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
1
评论
C语言基础数据结构——树，二叉树，堆的实现

树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。1.树的每个节点的身份都不唯一，如图，B节点为A节点的子节点的同时，也作为C节点的父节点。2.每棵树都可以宽泛的理解为由分支节点和叶子节点组成。3.每个节点有且仅有一个父亲节点，如果某个节点有两个父亲节点，那么这个树就变成了“图”。满足：堆中某个节点的值总是不大于或不小于其父节点的值的完全二叉树叫做堆。
复制链接

扫一扫