【数据结构】第六站：树的入门和堆的实现（附完整代码和注释）

---

前言

树的入门阶段我们需要：认识树(理清树的结构)、认识树的相关概念、了解不同种类的树。然后我们试着实现一种树：堆。堆的本质是一个顺序表，而它在逻辑上被认为成一种特殊的树，所以这节将会让你深刻的认识到老婆饼里没有老婆，还是那句话，画图！

---

一、树的入门

1.树概念及结构

1.1树的定义

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

-------- 注意：树形结构中，子树之间不能有交集，否则就不是树形结构

1.2树的相关概念

（1）.节点的度：一个节点含有的子树的个数称为该节点的度； 如上图：A的为6
(2).叶节点或终端节点：度为0的节点称为叶节点； 如上图：B、C、H、I…等节点为叶节点
(3).非终端节点或分支节点：度不为0的节点； 如上图：D、E、F、G…等节点为分支节点
(4).双亲节点或父节点：若一个节点含有子节点，则这个节点称为其子节点的父节点； 如上图：A是B的父节点
(5).孩子节点或子节点：一个节点含有的子树的根节点称为该节点的子节点； 如上图：B是A的孩子节点
(6).兄弟节点：具有相同父节点的节点互称为兄弟节点； 如上图：B、C是兄弟节点
(7).树的度：一棵树中，最大的节点的度称为树的度； 如上图：树的度为6
(8).节点的层次：从根开始定义起，根为第1层，根的子节点为第2层，以此类推；
(9).树的高度或深度：树中节点的最大层次； 如上图：树的高度为4
(10).堂兄弟节点：双亲在同一层的节点互为堂兄弟；如上图：H、I互为兄弟节点
(11).节点的祖先：从根到该节点所经分支上的所有节点；如上图：A是所有节点的祖先
(12).子孙：以某节点为根的子树中任一节点都称为该节点的子孙。如上图：所有节点都是A的子孙
(13).森林：由m（m>0）棵互不相交的树的集合称为森林；

注意：以上概念无需死记硬背，我们最好认得并理解，可以将它想象成一个家系图或者真实的树会更容易理解。

1.3树的表示

树结构相对线性表就比较复杂了，主要是结构设计起来就比较麻烦了，那既然我们需要保存值，也要保存结点和结点之间
的关系，那我们就直接给树的节点结构体中创造与树的度相同个数的指针，这样就可以完整表示出一颗树，但也避免不了对空间的大量浪费（一些节点无需这么多的指针），实际中树有很多种表示方式如：双亲表示法，孩子表示法、孩子双亲表示法以及孩子兄弟表示法等。我们这里就简单的了解其中最常用的孩子兄弟表示法。

孩子兄弟表示法（左孩子右兄弟）

typedef int DataType;
struct Node
{
 struct Node* _firstChild1; // 指向它的左边第一个孩子结点
 struct Node* _pNextBrother; // 指向其右边兄弟结点
 DataType _data; // 结点中的数据域
};

这种结构简直天才，无论树有多少个节点，树的度是多少，我们的节点结构体只需要两个指针就可以找到所有的节点。

1.4树在实际中的运用（表示文件系统的目录树结构）

2.二叉树概念及结构

2.1概念

二叉树：1. 二叉树不存在度大于2的结点
2. 二叉树的子树有左右之分，次序不能颠倒，因此二叉树是有序树
没错，说人话就是：二叉树是有计划生育限制的树种（每个节点最多只有两个孩子），它只是在树的概念上加了限制，本质上它还是一颗树。、

也正是因为这个原因，我们的二叉树节点可以很轻松的用带有两个指针的结构体表示出来。

typedef int DataType;
struct Node
{
 struct Node* _left; // 指向其的左边的孩子结点
 struct Node* _right; // 指向其的右边的孩子结点
 DataType _data; // 结点中的数据域
};

2.2特殊的二叉树

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

2.3二叉树的性质

以上性质主要理解。需要注意的是：完全二叉树深度和节点个数之间的关系符合首项为1，公比为2的等比数列和该数列的和之间的关系（之后计算时间复杂度也是根据这个）

2.4二叉树的存储结构

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

1. 顺序存储:
   顺序结构存储就是使用(就是顺序表的结构)数组来存储，一般使用数组只适合表示完全二叉树，因为不是完全二叉树会有空间的浪费。
   二叉树顺序存储在物理上是一个数组，在逻辑上是一颗二叉树。
   我们先给顺序表各位置标好下标，再将它拆成对应的二叉树（如下图左边的完全二叉树），我们可以发现它们上下的父子节点下标之间的关系：①(孩子节点的下标-1)/2=父亲节点的下标②（父亲节点的下标*2）+1=左孩子节点下标。请牢记这两个式子，它是之后堆实现的基础
   注意我们上面父子节点下标关系中的算式使用的是C语言的取整除法“/”，所以无论左孩子还是右孩子，我们都可以找到父亲节点。
   

上图顺序存储的树拆分成树过程如下。

3. 链式存储:
   二叉树的链式存储结构是指，用链表来表示一棵二叉树，即用链来指示元素的逻辑关系。 通常的方法是链表中每个结点由三个域组成，数据域和左右指针域，左右指针分别用来给出该结点左孩子和右孩子所在的链结点的存储地址 。链式结构又分为二叉链和三叉链，当前我们学习中一般都是二叉链，后面课程学到高阶数据结构如红黑树等会用到三叉链。（三叉看看就好）
   

typedef int BTDataType;
// 二叉链
struct BinaryTreeNode
{
struct BinTreeNode* _pLeft; // 指向当前节点左孩子
 struct BinTreeNode* _pRight; // 指向当前节点右孩子
 BTDataType _data; // 当前节点值域
};

// 三叉链
struct BinaryTreeNode
{
 struct BinTreeNode* _pParent; // 指向当前节点的双亲
 struct BinTreeNode* _pLeft; // 指向当前节点左孩子
 struct BinTreeNode* _pRight; // 指向当前节点右孩子
 BTDataType _data; // 当前节点值域
};

二、堆的实现

1.堆的概念及结构

我们之前知道了二叉树就是有计划生育的树，而完全二叉树又是特殊的二叉树，它们依次不断的加强对树的制约，以达成对数据进行处理、排列、筛选的各种不同目的，而我们将要学习的“堆”，其实也就是在完全二叉树的基础上再加上一条BUFF罢了，根据制约不同，我们将它分为大根堆和小根堆。
（1）.大根堆：一颗所有父节点都大于它的孩子节点的完全二叉树。
（ 2）.小根堆：一颗所有父节点都小于它的孩子节点的完全二叉树。
因为堆也是一种完全二叉树，所我们照样可以用上文的方式（顺序结构/数组）去表示，同时它所有父子节点的下标关系（那两条必须要记的）也可以使用。(结构如下图）

2. 堆的实现

堆的实现我们默认是大堆实现，小堆只需要改变判断符号即可。

2.1堆实现的各函数

#define _CRT_SECURE_NO_WARNINGS 1
#include<assert.h>
#include<stdlib.h>
#include<stdbool.h>
typedef int Heapdatatype;
typedef struct Heap
{
	Heapdatatype* a;
	int size;
	int capacity;
}HP;

void HeapInit(HP* php);
void HeapPush(HP* php,Heapdatatype x);
void HeapPop(HP* php);
Heapdatatype HeapTop(HP* php);
bool HeapEmpty(HP* php);
int  HeapSize(HP* php);
void HeapDestroy(HP* php);

2.2堆的初始化

因为我们已知了堆是用顺序结构储存的，所以堆的初始化便也和 顺序表的初始化一致。

void HeapInit(HP* php)
{
	assert(php);
	php->a = (Heapdatatype*)malloc(sizeof(Heapdatatype) * 7);
	if (php->a == NULL)
	{
		perror("malloc fail");
		return;
	}
	php->size = 0;
	php->capacity = 7;
}
//初始化正常开辟。逻辑上堆，物理上数组，最重要的是理解父子节点的下标关系。

这样我们就创造了一个7个整数空间大小的空堆。

2.3堆的插入

我们对一个堆进行插入一个值时，这个值一开始只能插入在顺序表的尾上（物理上是顺序表）。我们想要让这个值在正确的位置上，以形成堆，我们需要调整。（没有找到大根堆插入的图，小根堆插入逻辑一样）

void HeapPush(HP* php, Heapdatatype x)
{
	assert(php);
	if (php->size == php->capacity)
	{
		Heapdatatype* tmp = (Heapdatatype*)realloc(php->a,sizeof(Heapdatatype) * php->capacity * 2);
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}
			php->a = tmp;
			php->capacity *= 2;
	}
	php->a[php->size] = x;
	php->size++;
	ADjustup(php->a,php->size-1);
}
//堆的插入其实就是正常的顺序表尾插，正常的判断是否扩容，真正重要的，也是真正有堆的插入的逻辑思想的是ADjustup函数，
//它使正常处于顺序表尾的值，正确的进入堆中。

这里我们为了将值正常调整到堆的位置上，我们需要一个重要的函数（思想）：向上调整。
又因为调整过程需要两个数值的交换，所以我们又写了一个交换值函数Swap函数。

void ADjustup(Heapdatatype* 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;
		}
	}
}
//向上调整，前提是除了在数组中尾插的数据(堆尾节点的数据），其它的数据满足堆。所以我们在，插入数据满足堆时才直接break。
//循环判断条件也是一个重点。

void Swap(Heapdatatype* x, Heapdatatype* y)
{
	Heapdatatype tmp=*x;
	*x = *y;
	*y = tmp;
}

注意：向上调整函数的条件是：其他数据一定要满足是堆，我们才可以正常插入。

2.4堆的删除

堆的删除，要是删除大堆的尾的话我们只需要直接将堆节点的size–即可。可是这样做根本没有实际意义，你说它能存储/删除数据吧，那还不如用顺序表方便呢，我们创造堆就是为了对数据进行筛选排序，所以对大堆，我们要删除的是它的根节点的数据（删最大的值，为了排出第二大的值）。哦！那就和顺序表的头删一样呗，我们直接将堆头位置删了，然后将其他值全部向前一位不就行了，，这其实是经典的错误，当这样头删完之后，我们再将顺序结构拆成堆逻辑可以发现，我们堆中的父子兄弟结构完全被破坏了，不仅仅是效率低的问题，它已经不再是一个堆了！

所以我们这里应该用另一种思想：我们将堆根上的数据和堆尾的数据交换，然后size–删除堆尾，然后我们用另一种函数（思想）向下调整，去调整此时堆头的数据，使其进入堆中，放在正确的位置上。

void HeapPop(HP* php)
{
	assert(php);
	assert(!HeapEmpty(php));
	Swap(&php->a[0], &php->a[php->size-1 ]);
	AdjustDown(php->a, php->size - 1, 0);
	php->size--;
}
//删除堆头最大值。正常的数组移位删除无法满足堆的需要（它会破坏堆的父子关系），那么我们既然应该最大限度的不破坏堆的结构，那么使
//堆的头尾互换，并删除换后的最大值尾值，使新的头重新匹配进堆，所以有了向下调整的逻辑（函数），这里换值我们虽然把他删除
//但他实际上还是留在了堆中，只是php->size--，我们不再访问它了，但是如果我们一直重复刚才的操作：头尾互换，新头匹配进堆
//我们的最大值、次大值、次次大值就会依次在尾反向堆积，这也是堆排序的思想来源。


void AdjustDown(Heapdatatype* a,int n,int parent)
{
	int child = parent * 2+1;
	while (child < n)
	{
		if(child+1<n&&a[child + 1] > a[child])//这里有越界风险。
		{
			child++;
		}
		if(a[child] > a[parent])
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}
//向下调整函数AdjustDown，是堆删逻辑的一部分。

注意:这里的向下调整函数也需要其他数据满足是堆！
可能会有人说，这本来就是在堆中调整的啊，其他数据怎么可能不满足堆呢？其实这两个函数（向上/向下调整函数）还有许多要用到的地方，所以我们最好谨记。

2.5堆的大小/堆头/是否为空函数

因为堆顺序储，所以这三个函数其实非常简单。

bool HeapEmpty(HP* php)

{
	assert(php);
	return php->size == 0;
}

Heapdatatype HeapTop(HP* php)
{
	assert(php);
	return php->a[0];
}
int  HeapSize(HP* php)
{
	assert(php);
	return php->size;
}

2.6堆的销毁

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

三、完整源码

1.heap.h

#define _CRT_SECURE_NO_WARNINGS 1
#include<assert.h>
#include<stdlib.h>
#include<stdbool.h>
typedef int Heapdatatype;
typedef struct Heap
{
	Heapdatatype* a;
	int size;
	int capacity;
}HP;

void HeapInit(HP* php);
void HeapPush(HP* php,Heapdatatype x);
void HeapPop(HP* php);
Heapdatatype HeapTop(HP* php);
bool HeapEmpty(HP* php);
int  HeapSize(HP* php);
void HeapDestroy(HP* php);

2.heap.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"heap.h"
void HeapInit(HP* php)
{
	assert(php);
	php->a = (Heapdatatype*)malloc(sizeof(Heapdatatype) * 7);
	if (php->a == NULL)
	{
		perror("malloc fail");
		return;
	}
	php->size = 0;
	php->capacity = 7;
}
//初始化正常开辟。逻辑上堆，物理上数组，最重要的是理解父子节点的下标关系。


void Swap(Heapdatatype* x, Heapdatatype* y)
{
	Heapdatatype tmp=*x;
	*x = *y;
	*y = tmp;
}



void ADjustup(Heapdatatype* 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;
		}
	}
}
//向上调整，前提是除了在数组中尾插的数据(堆尾节点的数据），其它的数据满足堆。所以我们在，插入数据满足堆时才直接break。
//循环判断条件也是一个重点。

void HeapPush(HP* php, Heapdatatype x)
{
	assert(php);
	if (php->size == php->capacity)
	{
		Heapdatatype* tmp = (Heapdatatype*)realloc(php->a,sizeof(Heapdatatype) * php->capacity * 2);
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}
			php->a = tmp;
			php->capacity *= 2;
	}
	php->a[php->size] = x;
	php->size++;
	ADjustup(php->a,php->size-1);
}
//堆的插入其实就是正常的顺序表尾插，正常的判断是否扩容，真正重要的，也是真正有堆的插入的逻辑思想的是ADjustup函数，
//它使正常处于顺序表尾的值，正确的进入堆中。

void AdjustDown(Heapdatatype* a,int n,int parent)
{
	int child = parent * 2+1;
	while (child < n)
	{
		if(child+1<n&&a[child + 1] > a[child])//这里有越界风险。
		{
			child++;
		}
		if(a[child] > a[parent])
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}
//向下调整函数AdjustDown，是堆删逻辑的一部分。

//大堆
void HeapPop(HP* php)
{
	assert(php);
	assert(!HeapEmpty(php));
	Swap(&php->a[0], &php->a[php->size-1 ]);
	AdjustDown(php->a, php->size - 1, 0);
	php->size--;
}
//删除堆头最大值。正常的数组移位删除无法满足堆的需要（它会破坏堆的父子关系），那么我们既然应该最大限度的不破坏堆的结构，那么使
//堆的头尾互换，并删除换后的最大值尾值，使新的头重新匹配进堆，所以有了向下调整的逻辑（函数），这里换值我们虽然把他删除
//但他实际上还是留在了堆中，只是php->size--，我们不再访问它了，但是如果我们一直重复刚才的操作：头尾互换，新头匹配进堆
//我们的最大值、次大值、次次大值就会依次在尾反向堆积，这也是堆排序的思想来源。

bool HeapEmpty(HP* php)

{
	assert(php);
	return php->size == 0;
}

Heapdatatype HeapTop(HP* php)
{
	assert(php);
	return php->a[0];
}
int  HeapSize(HP* php)
{
	assert(php);
	return php->size;
}

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

本文章为作者的笔记和心得记录，顺便进行知识分享，有任何错误请评论指点：）。