二叉树以及堆的实现

树

树的定义及概念

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

• 有⼀个特殊的结点，称为根结点，根结点没有前驱结点。
• 除根结点外，其余结点被分成M(M>0) 个互不相交的集合T1、T2、……、Tm ，其中每⼀个集合Ti(1 <= i <= m) 又是⼀棵结构与树类似的⼦树。每棵子树的根结有且只有⼀个前驱，可以有0个或多个后继。因此，树是递归定义的。

树的性质：

• 子树不相交
• 除了根结点外，每个结点有且仅有一个父结点
• 一棵N个结点的树有N-1条边

树的相关术语

• 父结点/双亲结点：若一个结点含有子结点，则这个结点称为其子结点的父结点；如上图中G为J和k的父结点
• 子结点/孩子结点：一个结点含有的子树的根结点称为该结点的子结点；如上图中B是A的孩子结点
• 结点的度：一个结点有几个孩子结点，他的度就是多少；⽐如A的度为3，F的度为0，G的度为2
• 树的度：⼀棵树中，最大的结点的度称为树的度；如上图树的度为3
• 叶子结点/终端结点：度为0的结点称为叶结点；如上图中的E和F结点都为叶子结点
• 分支结点/非终端结点：度不为0的结点；如上图中的B和G结点都为分支结点
• 兄弟结点：具有相同父结点的结点互称为兄弟结点(亲兄弟)；如上图中的B和C结点为兄弟结点
• 结点的层次：从根开始定义起，根为第1层，根的子结点为第2层，以此类推；
• 树的高度或深度：树中结点的最大层次；如上图树的高度或深度为4
• 结点的祖先：从根到该结点所经分支上的所有结点；如上图中A是所有结点的祖先
• 路径：⼀条从树中任意节点出发，沿父节点-子节点连接，达到任意节点的序列；如上图中A到K的路径为A-C-G-K
• 子孙：以某结点为根的子树中任一结点都称为该结点的子孙。如上图中所有结点都是A的子孙
• 森林：由m（m>0） 棵互不相交的树的集合称为森林；

树的表示

孩子兄弟表示法：
树结构相对线性表就比较复杂了，要存储表示起来就比较⿇烦了，既然保存值域，也要保存结点和结点之间的关系，实际中树有很多种表示方式如：双亲表示法，孩子表示法、孩子双亲表示法以及孩子兄弟表示法等。我们这⾥就简单的了解其中最常用的孩⼦兄弟表示法。

 struct TreeNode 
{ 
	struct Node* child;//左边开始的第⼀个孩⼦结点
	struct Node* brother;//指向其右边的下⼀个兄弟结点
	int data;             
};

树形结构实际运用场景

文件系统是计算机存储和管理文件的⼀种方式，它利用树形结构来组织和管理文件和文件夹。在文件系统中，树结构被广泛应用，它通过父结点和子结点之间的关系来表示不同层级的文件和文件夹之间的关联。

二叉树

概念与结构

在树形结构中，我们最常用的就是⼆叉树，⼀棵⼆叉树是结点的⼀个有限集合，该集合由⼀个根结点加上两棵别称为左子树和右子树的⼆叉树组成或者为空。

二叉树的性质

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

特殊的二叉树

满二叉树

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

完全二叉树

完全⼆叉树是效率很⾼的数据结构，完全⼆叉树是由满⼆叉树而引出来的。对于深度为K的，有n个结点的⼆叉树，当且仅当其每一个结点都与深度为K的满⼆叉树中编号从1⾄n的结点一一对应时称之为完全二叉树。要注意的是满二叉树是一种特殊的完全二叉树。

性质：

• 若规定根结点的层数为1，则⼀棵⾮空⼆叉树的第i层上最多有2^(i-1)个结点
• 若规定根结点的层数为1，则深度为h的⼆叉树的最大结点数是h^2 −1
• 若规定根结点的层数为1，具有n个结点的满二叉树的深度( h = log2(n+1) log以2为底，n+1 为对数)

二叉树的存储

⼆叉树⼀般可以使用两种结构存储，⼀种顺序结构，⼀种链式结构。

顺序结构

顺序结构存储就是使用数组来存储，⼀般使用数组只适合表示完全二叉树，因为不是完全二叉树会有空间的浪费，完全⼆叉树更适合使用顺序结构存储。

链式结构

⼆叉树的链式存储结构是指，用链表来表示⼀棵⼆叉树，即用链来指示元素的逻辑关系。通常的方法是链表中每个结点由三个域组成，数据域和左右指针域，左右指针分别用来给出该结点左孩子和右孩子所在的链结点的存储地址。链式结构⼜分为二叉链和三叉链。

实现顺序结构二叉树

⼀般堆使用顺序结构的数组来存储数据，堆是一种特殊的二叉树，具有⼆叉树的特性的同时，还具备其他的特性。

堆的概念与结构

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

堆的性质：

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

⼆叉树性质：
对于具有n 个结点的完全⼆叉树，如果按照从上至下从左至右的数组顺序对所有结点从0 开始编号，则对于序号为i的结点有：

• 若i>0，i位置结点的双亲序号：(i-1)/2 ；i=0 ，i为根结点编号，无双亲结点
• 若2i+1<n ，左孩子序号：2i+1，若2i+1>=n，则无左孩子结点
• 若2i+2<n ，右孩⼦序号：2i+2 ，若2i+2>=n，则无右孩子结点

堆的实现（以小根堆为例）

堆的实现分为三个文件：heap.h、heap.c、test.c

heap.h

我们需要借助数组来实现堆，因此在结构体的定义时，我们选择了动态数组

#pragma once

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

typedef int HPDataType;

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

//初始化
void HPInit(HP* php);

//销毁
void HPDestory(HP* php);

//入堆
void HPPush(HP* php, HPDataType x);

//出堆
void HPPop(HP* php);

//判空
bool HPEmpty(HP* php);

//堆头元素
HPDataType HPtop(HP* php);

heap.c

初始化（同顺序表）

#include"heap.h"

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

销毁（同顺序表）

void HPDestory(HP* php)
{
	assert(php);
	if (php->arr)
		free(php->arr);
	php->arr = NULL;
	php->size = php->capacity = 0;
}

入堆

思路：

1. 判断数组空间是否满了，满了则需要进行扩容
2. 将数据插入，需要判断该数据是否满足小根堆的特点
3. 若不满足，则需要将父结点与该结点进行交互，并继续进行判断，从而实现数据向上调整，从而满足小跟读的特点
4. 将size++

例如需要在该小根堆中插入数据5，插入完成后跟父结点进行对比，即将5与56进行对比，因为56>5，因此将56与5进行交换

接着判断插入的5与他的父结点10，接着再进行交换

发现该结点已经变成根节点，已满足小根堆结点

void swap(int* x, int* y)
{
	int tmp = *x;
	*x = *y;
	*y = tmp;
}

void AdjustUp(HPDataType* arr,int child)
{
	int parent = (child - 1) / 2;
	while (child > 0)
	{
		if (arr[child] < arr[parent])
		{
			swap(&arr[child],&arr[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 : php->capacity * 2;
		HPDataType* tmp = (HPDataType*)realloc(php->arr, sizeof(HPDataType) * newcapacity);
		if (tmp == NULL)
		{
			perror("realloc fail!");
			exit(1);
		}
		php->capacity = newcapacity;
		php->arr = tmp;
	}
	php->arr[php->size] = x;
	AdjustUp(php->arr, php->size);
	php->size++;
}

出堆

思路：

1. 将根结点与最后的结点进行交换
2. 将size–
3. 向下调整，使堆满足小根堆的条件

例如要对该堆进行出堆操作，则需将56与5进行交换，由于size–，因此5不进入向下调整

取根节点的子节点，将它的左右孩子结点进行对比，将小的孩子结点与根节点进行交换

发现满足小根堆的条件，调整结束

void AdjustDown(HPDataType* arr, int parent, int n)
{
	int child = parent * 2 + 1;
	
	while (child < n)
	{
		if (child+1<n && arr[child] > arr[child + 1])
		{
			child++;
		}
		if (arr[parent] > arr[child])
		{
			swap(&arr[parent], &arr[child]);
			parent = child;
			child= parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

//出堆
void HPPop(HP* php)
{
	assert(php && php->size);
	swap(&php->arr[0],&php->arr[php->size-1]);
	php->size--;
	AdjustDown(php->arr, 0, php->size);
}

判空

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

寻找堆头元素

HPDataType HPtop(HP* php)
{
	assert(php && php->size);
	return php->arr[0];
}

test.c

#include"heap.h"

void Test()
{
	HP hp;
	HPInit(&hp);
	int arr[] = { 17,20,10,13,19,15 };
	for (int i = 0; i < 6; i++)
	{
		HPPush(&hp, arr[i]);
	}


	while (!HPEmpty(&hp))
	{
		printf("%d ", HPtop(&hp));
		HPPop(&hp);
	}


	HPDestory(&hp);
}

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

入堆操作成功

出堆成功