数据结构：树（1）【树的概念及结构】【二叉树的概念及存储结构】【二叉树的顺序结构及实现】

一.树的概念及结构

1.树的概念

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

我们所看到的最上方的那个节点称为根结点，根节点没有前驱结点

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

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

关于树的一些名词大家还是要了解一下的。

结点的度：一个结点含有的子树的个数称为该结点的度； 如上图：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）棵互不相交的树的集合称为森林；

2.树的结构

树结构相对线性表就比较复杂了，要存储表示起来就比较麻烦了，既然保存值域，也要保存结点和结点之间 的关系，实际中树有很多种表示方式如：双亲表示法，孩子表示法、孩子双亲表示法以及孩子兄弟表示法等。孩子兄弟表示法是一种很牛的表示方式。写起来相对来说比较简单一些。

typedef int DataType;
struct Node
{
 struct Node* firstChild; // 第一个孩子结点
 struct Node* pNextBrother; // 指向其下一个兄弟结点
 DataType data; // 结点中的数据域
};

也就是说假如我的根结点有多个孩子，一个指针指向我的其中一个孩子，但另一个指针是不直接指向我另一个孩子。比如下图的A，B和C，在A的这一层，没有其他的兄弟结点了，那么我的这个pNextBrother指针就指向NULL，在B的这一层上，B有一个兄弟结点C，那么它的pNextBrother就指向C。那么在第三层也是同样的道理。

 二.二叉树的概念及结构

1.二叉树的概念

一棵二叉树是结点的一个有限集合，这个集合或者为空，或者由一个根结点加上两棵分别称为左子树和右子树的二叉树组成。简单的说就是一棵树只有两个叉。

二叉树可以是下面的几种情况：

现实中的二叉树长这个样子。

 

二叉树有两种特殊的结构（实际也是一种，因为一种是包含在另一种里的）

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

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

 2.二叉树的性质

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

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

3. 对任何一棵二叉树, 如果度为0其叶结点个数为n0 , 度为2的分支结点个数为n2 ,则有n0＝n2＋1

 3.二叉树的存储结构

二叉树的存储结构有两种，一种是顺序存储，一种是链式存储。

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

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

这篇我主要写一下关于二叉树的顺序存储（链式存储因为我还不会）。

三.二叉树的顺序结构及实现

因为顺序存储是用数组来实现，想实现这个结构，我们要先了解数组的下标代表的是什么。因为完全二叉树的特殊性，所以我们从根开始就给二叉树的每一个结点标上一个数值。

具体情况如图所示：

 知道了完全二叉树在数组中是怎样存储的，接下来还要介绍一个叫做堆的东西。

1.堆的概念

堆可以分为大堆和小堆。假如我们有一个关键码的集合，里面的元素按完全二叉树的顺序存储方式存储在一个一维数组中，但是这些元素的大小关系就有些讲究了。

 小堆：堆中某个结点的值总是不小于其父结点的值（大堆与其相反）；

 堆：总是一棵完全二叉树。

2.堆的实现

因为我们是用数组实现堆，所以我们可以跟顺序表一样，创建一个结构体：

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

2.1堆的初始化

还是跟顺序表一样，指针指向NULL。

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

2.2堆的摧毁

我们在实现堆时，后面不会多动态开辟除了数组以外的空间，所以在这里只需要释放我们数组开辟的空间就行。

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

2.3往堆里入数据

这里就有些麻烦了。注意看代码：

//逐渐的往php->a里push数据，数据顺序满足二叉树
void HPPush(HP* php, HPDataType x)
{
	assert(php);
	//从这里开始是判断我们的数组是不是满了，或者是不是没有元素
	if (php->capacity == php->size)
	{
		int newcapacity = php->capacity == 0 ? 4 : php->capacity * 2;//这里是一个简单的三目表达式
		int* cur = (int*)realloc(php->a, sizeof(HPDataType)*newcapacity);
		if (cur == NULL)
		{
			perror("realloc::cur");
			return;
		}
		php->a = cur;
		php->capacity = newcapacity;
	}
	php->a[php->size] = x;
	php->size++;
	//到这里数据入数组结束，但是有一个很大的问题，我们这样实现的数组在逻辑结构上肯定是完全二叉树
	//但是我们数组里的数据是不是按照堆排列的？答案是十分不一定，我们就单独的创建一个函数来把我们的二叉树排列成堆的形式
	AdjustUp(php->a, php->size - 1);//这个函数后面单独写
}

2.3.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;
		}
	}
}

每次push数据的时候都要调用这个函数，确保我们在进入数组的过程中是按照堆的形式来排列的。

2.3.2交换函数

//交换函数
void Swap(HPDataType* a, HPDataType* b)
{
	int tmp = *a;
	*a = *b;
	*b = tmp;
}

2.4从上到下调整数据

这个相比于从下到上调整数据又多了几个需要注意的点：

//从上往下调整
void AdjustDown(HPDataType* a, int size, int parent)
{
	//直接假设左孩子小
	int child = parent * 2 + 1;

	while(child < size)//child >= size说明child不存在
	{
		if (a[child] > a[child + 1] && child + 1 < size)//如果左孩子大，并且右孩子存在，那么child就加一，换到小的那个孩子
			                                            //这样可以保证孩子结点一定比双亲结点小
		{
			child++;
		}

		if (a[child] < a[parent])//还是以小堆的形式来
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

2.5删除根结点

//删除堆的根节点
void HPPop(HP* php)
{
	assert(php);
	assert(php->size > 0);
	Swap(&php->a[0], &php->a[php->size - 1]);//先把跟节点和数组的最后一个元素交换，，交换之后就不是堆了
	php->size--;//size--就是删除
	AdjustDown(php->a,php->size, 0);//按照从上往下的调整方式来调整为堆
}

这里我单独解释一下为什么要用到交换。

如果我们直接把根结点删除，那么左孩子就变成了新的根，右孩子变成了原本左孩子的孩子，下面的结点之间的关系全乱了。 

2.6取根结点的元素

//取跟结点的元素
HPDataType HPTop(HP* php)
{
	assert(php);
	assert(php->size > 0);

	return php->a[0];
}

2.7判空

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

	return php->size == 0;
}

四.代码分享

text.c

#include"Heap.h"
int main()
{
	HP php;//创建堆
	HPInit(&php);//初始化堆
	int a[] = { 8,3,23,55,232,66,222,33,7,66,3333,999 };
	int i = 0;
	while (i < sizeof(a) / sizeof(int))
	{
		HPPush(&php, a[i]);//一个一个的把a数组里的元素放到堆里
		i++;
	}
	int k = 5;
	while (k--)//利用循环，求出堆里前5小的元素
	{
		printf("%d ", HPTop(&php));
		HPPop(&php);
	}
	HPDestroy(&php);
	return 0;
}

运行结果如图： 

Heap.h

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>
typedef int HPDataType;
typedef struct Heap
{
	HPDataType* a;
	int capacity;
	int size;
}HP;

void HPInit(HP* php);
void HPDestroy(HP* php);

void Swap(HPDataType* a, HPDataType* b);
void AdjustUp(HPDataType* a,int child);
void AdjustDown(HPDataType* a, int size, int parent);

void HPPush(HP* php, HPDataType x);

void HPPop(HP* php);
HPDataType HPTop(HP* php);
bool HPEmpty(HP* php);

 到这里我们仅仅是了解了树及二叉树的一些概念，还有关于二叉树的一些算法。关于二叉树的知识还有许多东西要说。感谢大家的观看，如有错误还请多多指出。