前言
本篇博客为大家介绍树这个数据结构，这里对大家前面学的函数递归的思想有一定要求，如果有遗忘可以先去复习一下递归的相关知识；树是一种重要的数据结构，其中二叉树最为典型，二叉树的学习是有一定难度提升的，下面进入正文。
1.树的概念和结构
1.1 树的概念
树是一种非线性的数据结构，它是由n（n>=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 树的表示
树结构相对线性表就比较复杂了，要存储表示起来就比较麻烦了，既然保存值域，也要保存结点和结点之间的关系，我们这里就简单地了解最常用的孩子兄弟表示法。具体大家请看下面代码。
typedef int DataType;
struct Node
{struct Node* firstChild1; // 第一个孩子结点struct Node* pNextBrother; // 指向其下一个兄弟结点DataType data; // 结点中的数据域
};
这里大家仔细来看这种表示方法，每个child都指向从左起第一个孩子，剩下的孩子就是通过兄弟节点去遍历到。
2. 二叉树的概念和结构
2.1 概念
1. 二叉树不存在度大于2的结点
2. 二叉树的子树有左右之分，次序不能颠倒，因此二叉树是有序树
注意：对于任意的二叉树都是由以下几种情况复合而成的：
2.2 现实中的二叉树
2.3 特殊的二叉树
1. 满二叉树：一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树。也就是说，如果一个二叉树的层数为K，且结点总数是2^(K-1)，则它就是满二叉树。
2. 完全二叉树：完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树而引出来的。 前h-1层都是满的，最后一层从左到右必须连续；要注意的是满二叉树是一种特殊的完全二叉树。
2.4 二叉树的性质
2.5 二叉树的存储结构
二叉树一般可以使用两种结构存储，一种顺序结构，一种链式结构。
1. 顺序存储
顺序结构存储就是使用数组来存储，一般使用数组只适合表示完全二叉树，因为不是完全二叉树会有空间的浪费。而现实中使用中只有堆才会使用数组来存储，关于堆我们后面会专门讲解。二叉树顺序存储在物理上是一个数组，在逻辑上是一颗二叉树。
2. 链式存储
二叉树的链式存储结构是指，用链表来表示一棵二叉树，即用链来指示元素的逻辑关系。 通常的方法是 链表中每个结点由三个域组成，数据域和左右指针域，左右指针分别用来给出该结点左孩子和右孩子所 在的链结点的存储地址 。链式结构又分为二叉链和三叉链，当前我们学习中一般都是二叉链，后面学到高阶数据结构如红黑树等会用到三叉链。
3. 二叉树的顺序结构及实现
3.1 二叉树的顺序结构
普通的二叉树是不适合用数组来存储的，因为可能会存在大量的空间浪费。而完全二叉树更适合使用顺序结构存储。现实中我们通常把堆(一种二叉树)使用顺序结构的数组来存储，需要注意的是这里的堆和操作系统虚拟进程地址空间中的堆是两回事，一个是数据结构，一个是操作系统中管理内存的一块区域分段。
3.2 堆的概念和结构
如果有一个关键码的集合K = { ， ， ，…， }，把它的所有元素按完全二叉树的顺序存储方式存储 在一个一维数组中，并满足： 且 = 且 >= ) i = 0，1， 2…，则称为小堆(或大堆)。将根结点最大的堆叫做最大堆或大根堆，根结点最小的堆叫做最小堆或小根堆。
堆的性质： 堆中某个结点的值总是不大于或不小于其父结点的值； 堆总是一棵完全二叉树。
这里大家需要注意，大堆和小堆不一定是降序或者升序的，我们只能要求的是父节点和子节点的大小，同一行是无法比较大小的。在小堆中，根是最小的；在大堆中，根是最大的。
3.3 堆的实现
3.3.1 堆的向下调整算法
现在我们给出一个数组，逻辑上看做一颗完全二叉树。我们通过从根结点开始的向下调整算法可以把它调整成一个小堆。向下调整算法有一个前提：左右子树必须是一个堆，才能调整。
int array[] = {27,15,19,18,28,34,65,49,25,37};
3.3.2 堆的创建
我们给出一个数组，这个数组逻辑上可以看做一颗完全二叉树，但是还不是一个堆，现在我们通过算法，把它构建成一个堆。根结点左右子树不是堆，我们怎么调整呢？
这里我们从倒数的第一个非叶子结点的子树开始调整，一直调整到根结点的树，就可以调整成堆。
int a[] = {1,5,3,8,7,6};
3.3.3 建堆的时间复杂度（向下）
向下建堆的时间复杂度：O(N)
这里大家可以看到向下调整建堆的效率是更高的，因为向上调整建堆的时间复杂度为：O(N*logN)
3.3.4 堆的代码实现
这里来为大家依次介绍，首先来看头文件，我们需要在头文件中将堆的数据结构定义出来，以及定义好后面要实现的一些函数接口，还需将所需头文件包含进去。
#pragma once
#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
#include<stdbool.h>typedef int HPDataType;
typedef struct Heap
{HPDataType* a;//用数组实现，类似顺序表int size;//元素个数int capacity;//空间大小
}HP;void Swap(HPDataType* p1, HPDataType* p2);//交换
void AdjustUp(HPDataType* a, int child);//向上调整
void AdjustDown(HPDataType* a, int n, int parent); //向下调整void HPInit(HP* php); //初始化
void HPDestroy(HP* php); //销毁
void HPPush(HP* php, HPDataType x); //插入
void HPPop(HP* php); //删除
HPDataType HPTop(HP* php); //取树顶元素
bool HPEmpty(HP* php); //判空
3.3.4.1 堆的初始化和销毁
void HPInit(HP* php)
{php->a = NULL;php->capacity = php->size = 0;
}
void HPDestroy(HP* php)
{assert(php);free(php->a);php->a = NULL;php->capacity = php->size = 0;
}
关于堆的初始化和销毁，想必大家应该可以很快地理解，因为这与我们前面学过的顺序表的初始化和销毁是同理的；我们本质上还是再对数组进行操作，但是我们逻辑上要将其想象成堆（完全二叉树）。
3.3.4.2 向上调整算法
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;}}
}这里是为我们后面的插入做铺垫，我们将数据插入后，要将它们变成堆的形式。比如这里我们想得到小根堆，那么就可以用向上调整法，将小的数向上调整，当然，这里需要提醒大家，向上调整不一定得到顺序的数据，前面提到过，小根堆的数据不一定是升序的。时间复杂度：O(NlogN)
3.3.4.3 堆的插入
void HPPush(HP* php, HPDataType x)
{assert(php);if (php->capacity == php->size){int newcapacity = php->capacity == 0 ? 4 : 2 * php->capacity;HPDataType* tmp = (HPDataType*)realloc(php->a, newcapacity * sizeof(HPDataType));if (tmp == NULL){perror("realloc");exit(1);}php->a = tmp;php->capacity = newcapacity;}php->a[php->size++] = x;AdjustUp(php->a, php->size - 1);
}这里大家还是可以类比顺序表的尾插方法，再插入之前，我们还是需要先判断空间够不够；申请好空间后，我们将数据插入到"数组“的末尾，然后在进行向上调整，以达到堆的结构。时间复杂度：O(logN)
3.3.4.4 向下调整算法
void AdjustDown(HPDataType* a, int n, int parent)
{//这里先假设左孩子小int child = parent * 2 + 1;while (child < n)//child>=n时，说明已经调整到叶节点了{//找出小的那个孩子if (a[child + 1] < a[child] && child + 1 < n){child++;}if (a[child] < a[parent]){Swap(&a[child], &a[parent]);parent = child;child = parent * 2 + 1;}else{break;}}
}这里相较于向上调整算法要稍微复杂一些，我们需要先找出左右孩子中较小的孩子，然后在进行向下调整，调整的逻辑和上面类似。 时间复杂度：O(N)
3.3.4.5 堆的删除
删除堆是删除堆顶的数据，将堆顶的数据根最后一个数据一换，然后删除数组最后一个数据，再进行向下调整算法。时间复杂度：O(logN)
void HPPop(HP* php)
{assert(php);assert(php->size > 0);Swap(&php->a[0], &php->a[php->size - 1]);php->size--;AdjustDown(php->a, php->size, 0);
}3.3.4.6 取堆顶元素
HPDataType HPTop(HP* php)
{assert(php);assert(php->size > 0);return php->a[0];
}3.3.4.7 判空
bool HPEmpty(HP* php)
{assert(php);return php->size == 0;
}4. 二叉树的链式结构及实现
4.1 前置说明
上面为大家介绍了二叉树的顺序结构，我们通过数组实现了二叉树，整体的难度还行。下面将为大家介绍二叉树的链式结构，这里的内容相比前面的就要复杂一些了，由于现在大家对二叉树结构掌握还不够深入，为了降低大家学习成本，此处手动快速创建一棵简单的二叉树，快速进入二叉树 操作学习，等二叉树结构了解的差不多时，我们反过头再来研究二叉树真正的创建方式。
#include<stdio.h>
#include<stdlib.h>
typedef int BTDataType;
typedef struct BinaryTreeNode
{BTDataType _data;struct BinaryTreeNode* left;struct BinaryTreeNode* right;
}BTNode;BTNode* BuyNode(BTDataType x)
{BTNode* node = (BTNode*)malloc(sizeof(BTNode));if (node == NULL){perror("malloc fail");exit(1);}node->_data = x;node->left = NULL;node->right = NULL;return node;
}
BTNode* CreatBinaryTree()
{BTNode* node1 = BuyNode(1);BTNode* node2 = BuyNode(2);BTNode* node3 = BuyNode(3);BTNode* node4 = BuyNode(4);BTNode* node5 = BuyNode(5);BTNode* node6 = BuyNode(6);node1->left = node2;node1->right = node4;node2->left = node3;node4->left = node5;node4->right = node6;return node1;
}4.2 二叉树的遍历
关于二叉树的遍历，这里如果大家学过离散数学，应该对这个点不陌生，当然，没学过也没关系，大家仔细看上面的图片，展示了3遍历方式：前中后；其实大家经过观察会发现，3中遍历方式无非就是根节点的位置不同。
下面我们的重点是如何用代码来实现3种遍历方式。
4.2.1 前序遍历
void PrevOrder(BTNode* root)
{if (root == NULL){printf("N ");return;}printf("%d ", root->_data);PrevOrder(root->left);PrevOrder(root->right);
}
大家可以结合这两张图片来理解遍历的过程，这里运用了递归的思想，将大问题化成小问题，分而治之。后面我们看到的中序和后序也会运用相同的思想。
4.2.2 中序遍历
void InOrder(BTNode* root)
{if (root == NULL){printf("N ");return;}InOrder(root->left);printf("%d ", root->_data);InOrder(root->right);
}
4.2.3 后序遍历
void PostOrder(BTNode* root)
{if (root == NULL){printf("N ");return;}PostOrder(root->left);PostOrder(root->right);printf("%d ", root->_data);
}
4.3 结点个数和高度
4.3.1 二叉树结点个数
int Treesize(BTNode* root)
{return root == NULL ? 0 : Treesize(root->left) + Treesize(root->right) + 1;
}这里大家仔细来看代码，代码非常简洁，基本思想就是二叉树的节点可以分为两部分来计算，当是空结点时，即0个节点；当不是空结点时，节点数就是其左子树+右子树+1。所以代码就可以写成上述形式，我们使用了三目操作符，一行代码就可以实现以上逻辑。同样，后面我们还要运用这样的思想。
4.3.2 二叉树叶结点个数
int TreeLeafSize(BTNode* root)
{if (root == NULL){return 0;}if (root->left == NULL && root->right == NULL){return 1;}return TreeLeafSize(root->left) + TreeLeafSize(root->right);
}这里代码的逻辑与上面类似，还是分治的思想，当root为空时，说明没有叶结点；当root的度为0时，它自己就是叶结点；其余情况均可以分成一个个的小情况来计算。
4.3.3 二叉树的高度
这里我们再来求一下二叉树的高度。这里需要先明确一点，就是高度是从1 开始算的，而不是从0开始；这里同样还需要用到递归的思想，当root为空时，高度就是0；当root不为空时，其高度就等于它的左子树和右子树中的较大值+1，如此看来，代码的逻辑就出来了。
int TreeHeight(BTNode* root)
{if (root == NULL){return 0;}int leftheight = TreeHeight(root->left);int righteight = TreeHeight(root->right);return leftheight > righteight ? leftheight + 1 : righteight + 1;
}这里大家来看一下代码，我们新定义了两个变量来存储每次递归得到的值，这样做是非常有必要的，如果不存储，那么每递归一次，上一次的数据就忘了，就又需要重新再进行递归，如此一来，效率就会大大下降。
4.3.4 二叉树第k层结点个数
int TreeLevelKSize(BTNode* root,int k)
{if (root == NULL){return 0;}if (k == 1){return 1;}return TreeLevelKSize(root->left, k - 1) + TreeLevelKSize(root->right, k - 1);
}大家来看这里的代码，我们想求出第k层的结点个数，还是需要将大问题转化为小问题，root为空时，结点个数自然0；k为1，表示求第一层，就是根节点，也就是1；排除以上两种情况，其余情况都可以运用递归的思路来解决，比如我们要求第4层的节点个数，那么对于第1层来说是求第4层，对第2层来说是求第3层，以此类推，这个问题就被拆解成子问题了。
4.3.5 二叉树查找值为x的结点
BTNode* TreeFind(BTNode* root, BTDataType x)
{if (root == NULL){return NULL;}if (root->_data == x){return root;}BTNode* ret1 = TreeFind(root->left, x);if (ret1){return ret1;}BTNode* ret2 = TreeFind(root->right, x);if (ret2){return ret2;}return NULL;
}5. 总结
本篇博客为大家介绍了二叉树的一些基础内容，其中重点介绍了二叉树的顺序存储和链式存储，后面我们学了C++后还会学习二叉树的进阶内容，所以在这里大家就需要打好基础，以便于学习后面的进阶内容，最后，希望本篇博客可以为大家带来帮助，感谢阅读！
