【数据结构】——（二叉树）堆

1.树概念及结构

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

有一个特殊的结点，称为根结点，根结点没有前驱结点

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

树是递归定义的。

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

               

1.2 树的相关概念

结点的度：一个结点含有的子树的个数称为该结点的度； 如上图：A的为6

叶结点或终端结点：度为0的结点称为叶结点； 如上图：B、C、H、I...等结点为叶结点

非终端结点或分支结点：度不为0的结点； 如上图：D、E、F、G...等结点为分支结点

双亲结点或父结点：若一个结点含有子结点，则这个结点称为其子结点的父结点； 如上图：A是B的父结点

孩子结点或子结点：一个结点含有的子树的根结点称为该结点的子结点； 如上图：B是A的孩子结点

兄弟结点：具有相同父结点的结点互称为兄弟结点； 如上图：B、C是兄弟结点

树的度：一棵树中，最大的结点的度称为树的度； 如上图：树的度为6 结点的层次：从根开始定义起，根为第1层，根的子结点为第2层，以此类推；

树的高度或深度：树中结点的最大层次； 如上图：树的高度为4

堂兄弟结点：双亲在同一层的结点互为堂兄弟；如上图：H、I互为兄弟结点

结点的祖先：从根到该结点所经分支上的所有结点；如上图：A是所有结点的祖先

子孙：以某结点为根的子树中任一结点都称为该结点的子孙。如上图：所有结点都是A的子孙

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

1.3 树的表示

树的表达有很多种

1.明确知道树的度时，直接用指针数组、

//明确告诉树的度为N
#define N 4
struct treeNode
{
    int val;
    struct treeNode* subs[N];
};

这种方法在N很大时，可能会导致极大的空间浪费，因为树最大的有N个节点，不代表每个父节点都有N个子节点，很可能会导致空间浪费。

2.左孩子右兄弟表示方法

typedef struct treeNode

{

int val;

struct treeNode* leftchild; // 第一个孩子结点

struct treeNode* rightbrother; // 指向其下一个兄弟结点

}HP;

结构图如下

 2.二叉树概念及结构

2.1概念

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

1. 或者为空

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

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

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

注意：对于任意的二叉树都是由以下几种情况复合而成的：

2.2 特殊的二叉树

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

2.3 二叉树的性质

1. 若规定根结点的层数为1，则一棵非空二叉树的第i层上最多有 2^(i-1)个结点。

2. 若规定根结点的层数为1，则深度为h的二叉树的最大结点数是2^h-1

3. 若规定根结点的层数为1，具有n个结点的满二叉树的深度，h=log2^(n+1)

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

1. 若i>0，i位置结点的双亲序号：(i-1)/2；i=0，i为根结点编号，无双亲结点

2. 若2i+1=n否则无左孩子

3. 若2i+2=n否则无右孩子

2.4二叉树的存储结构

二叉树一般可以使用两种结构存储，一种顺序结构，一种链式结构。 1. 顺序存储 顺序结构存储就是使用数组来存储，一般使用数组只适合表示完全二叉树，因为不是完全二叉树会有空 间的浪费。而现实中使用中只有堆才会使用数组来存储，关于堆我们后面的章节会专门讲解。二叉树顺 序存储在物理上是一个数组，在逻辑上是一颗二叉树

普通的二叉树并不适合用数组来存储，因为会浪费很大的空间，而完全二叉树比较适合用数组来存储，现实中我们通常把堆(一种二叉树)使用顺序结构的数组来存储，需要注意的是这里的堆和操作系统虚拟进程地址空间中的堆是两回事，一个是数据结构，一个是操作系统中管理内存的一块区域分段。我们看一下结构图，能让我们更好的理解。

2.5堆的概念

由上面的叙述，我们可以了解到堆是由完全二叉树所实现的，而堆分为两种，大堆和小堆，

小堆：每个根节点都小于子节点即为小堆

大堆：每个根节点都大于子节点即为大堆

由上，我们可以总结出堆的性质

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

2.6.堆的实现 

这里我们要实现堆，是小堆

typedef struct Heap
{
 HPDataType* _a;
 int _size;
 int _capacity; 
}Heap;
// 堆的构建
void HeapCreate(Heap* hp, HPDataType* a, int n);
// 堆的销毁
void HeapDestory(Heap* hp);
// 堆的插入
void HeapPush(Heap* hp, HPDataType x);
// 堆的删除
void HeapPop(Heap* hp);
// 取堆顶的数据
HPDataType HeapTop(Heap* hp);
// 堆的数据个数
int HeapSize(Heap* hp);
// 堆的判空
int HeapEmpty(Heap* hp);

2 .6.1堆的初始化

代码如下：

void HeapInit(Heap* hp)

{

assert(hp);

hp->a = NULL;

hp->capacity = hp->size = 0;

}

堆的销毁

代码如下

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

堆的插入

void HeapPush(Heap* 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, 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 AdjustUp(HPDataType* 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;
		}
	}
}

堆的删除

注意的是堆的删除，删除的是堆顶，而非堆尾，如果是堆尾的话，那就没有太大意义了。

如果将堆顶数据按照顺序表头删的方法直接删除的话，会出现结构错乱，这样父子关系变成了兄弟关系，兄弟关系变成了父子关系。

这时候就要向下调整，即AdjustDown

// 堆的删除
void HeapPop(Heap* hp)
{
	assert(hp);
	assert(hp->size > 0);
	Swap(&(hp->a[0]), &(hp->a[hp->size - 1]));
	hp->size--;
	AdjustDown(hp->a, hp->size, 0);
}

 AdjustDown函数

//向下调整
void AdjustDown(HPDataType* a,int n,int parent)
{
	int child = parent * 2 + 1;
	while (child < n)//child >= 0说明孩子已经不存在，调整到叶子了
	{
		if (child+1 < n&&a[child] > a[child + 1])
		{
			child++;
		}
		if (a[parent] > a[child])
		{
			Swap(&a[parent], &a[child]);
			parent = child;
			child = child * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

获取栈顶数据

// 取堆顶的数据
HPDataType HeapTop(Heap* hp)
{
	assert(hp);
	assert(hp->size > 0);
	return hp->a[0];
}

堆的数据个数 

// 堆的数据个数
int HeapSize(Heap* hp)
{
	assert(hp);
	return hp->size;
}

堆的判空

// 堆的判空
int HeapEmpty(Heap* hp)
{
	assert(hp);
	return hp->size == 0;
}

好了，堆的删除就先讲到这里了。

堆的应用

堆排序 堆排序即利用堆的思想来进行排序，总共分为两个步骤：

1. 建堆

升序：建大堆

降序：建小堆

2.利用堆删除思想来进行排序 建堆和堆删除中都用到了向下调整，因此掌握了向下调整，就可以完成堆排序

第一种建堆方式

1.向上调整方法建堆

向上调整算法复杂度为O（n*logn）

for (int i = 1; i < length; i++)

{

AdjustUp(arr,i)

}

第二种方法就是用向下调整算法建堆

2.向下调整算法的时间复杂度为O（N）

for (int i =(length-1-1/2); i > 0; i--)
{
	AdjustDown(arr,i)
}

利用堆删除思想来进行排序

void HeapSort(int* a, int n)
{
	
	for (int i = 1; i < n; i++)
	{
		AdjustUp(a,i);
	}
	int end =	n - 1;
	while (end > 0)
	{
		Swap(&a[0], &a[end]);
		AdjustDown(a, end, 0);
		--end;
	}
}

好了，本章就讲到这里啦！！！我们下期再见