1. 树概念及其结构
1.1 树的概念
树是一种非线性 的数据结构，是由n（n>=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 ）棵互不相交的树的集合称为森林；
1.2 树的结构
树结构的表示相对线性表就较为复杂了，实际中树的表示方法有很多：双亲表示法、孩子表示法、孩子双亲表示法、孩子兄弟表示法。以孩子兄弟表示法为例：
cpp
typedef int DataType;
structNode
{
structNode* firstChild1; // 第一个孩子结点
structNode* pNextBrother; // 指向其下一个兄弟结点
DataTypedata; // 结点中的数据域
};内部结构如下图：
2. 二叉树概念及其结构
2.1 二叉树概念
定义：一颗二叉树是结点的有限集合，该集合：
或者为空，或者由一个根节点和左子树和右子树组成
由定义可知，二叉树没有度大于2 的结点，二叉树的子树有左右之分，左右树顺序不能颠倒，所以二叉树是有序树。
2.2 两种特殊的二叉树
满二叉树：一个二叉树，如果每一层的结点数都达到了最大值，这个树就是满二叉树。也就是一个K层的二叉树，如果结点个数为2^K-1 ，那么这个二叉树为满二叉树。
完全二叉树：完全二叉树是效率很高的数据结构，完全二叉树是对于有n个结点，深度为K的二叉树，除第K层外，每层结点都达到最大值，且最后一层的结点从左到右连续排列，无空缺的二叉树。
3. （完全）二叉树顺序结构实现
3.1 顺序结构介绍
顺序结构存储就是使用数组来存储，使用数组存储的二叉树一般都是完全二叉树，因为非完全二叉树会有空间的浪费。
二叉树数组存储方式在物理上是一个数组 ，在逻辑上是一颗二叉树。
现实中我们会把堆（一种二叉树）使用数组实现，这里的堆和操作系统虚拟进程地址空间中的堆是两回事。
3.2 堆的概念及结构
堆是一种特殊的完全二叉树，同时采用顺序结构存储，其核心特征是满足堆序性。
堆的两个核心定义要素：
逻辑结构：必须是一颗完全二叉树。这是其能用数组高校存储的基础（可通过下标公式快速定位父子结点）
数据关系（堆序性）：树中任意结点的值需满足以下两种规则之一：1. 大根堆：每个父结点的值大于等于其左右结点的值。2. 小根堆：每个父结点的值小于等于其左右节点的值。
3.3 顺序结构（堆）的实现
3.2.1 Heap.h
cpp
#define _CRT_SECURE_NO_WARNINGS 1
#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>
typedef int HPDataType;
typedef struct Heap
{
HPDataType* a;
int size;
int capacity;
}HP;
//交换函数
void Swap(HPDataType* p1, HPDataType* p2);
//初始化和销毁
void HPInit(HP* php);
void HPDestory(HP* php);
//插入 删除
void HPPush(HP* php, HPDataType x);
void HPPop(HP* php);
//取堆顶数据
HPDataType HPTop(HP* php);
//判空
bool HPEmpty(HP* php);
//向上调整插入数据位置
void AdjustUp(HPDataType* a, int child);
//向下调整数据
void AdjustDown(HPDataType* a, int n, int parent);3.2.2 Heap.c
cpp
#include"Heap.h"
//初始化和销毁
void HPInit(HP* php)
{
assert(php);
php->a = NULL;
php->capacity = 0;
php->size = 0;
}
void HPDestory(HP* php)
{
assert(php);
free(php->a);
php->a = NULL;
php->capacity = 0;
php->size = 0;
}
//交换函数
void Swap(HPDataType* p1, HPDataType* p2)
{
HPDataType tmp = *p1;
*p1 = *p2;
*p2 = tmp;
}
//向上调整插入数据位置
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;
}
}
}
//插入
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->a, newcapacity * sizeof(HPDataType));
if (tmp == NULL)
{
perror("HPPush::realloc fail");
return;
}
php->a = tmp;
php->capacity = newcapacity;
}
php->a[php->size] = x;
php->size++;
AdjustUp(php->a, php->size - 1);
}
//向下调整数据
void AdjustDown(HPDataType* a, int n, int parent)
{
//假设左节点小
int child = parent * 2 + 1;
while (child < n)
{
//找兄弟节点中小的那个 child+1<n 确保右节点存在
if (child + 1 < n && a[child + 1] < a[child])
{
++child;
}
if (a[parent] > a[child])
{
Swap(&a[parent], &a[child]);
parent = child;
child = parent * 2 + 1;
}
else
{
break;
}
}
}
//删除堆顶数据
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);
}
//取堆顶数据
HPDataType HPTop(HP* php)
{
assert(php);
assert(php->size > 0);
return php->a[0];
}
//判空
bool HPEmpty(HP* php)
{
return php->size == 0;
}3.2.3 test.c
cpp
#include"Heap.h"
void TestHeap01()
{
int a[] = { 4,2,8,1,5,6,7,9 };
HP hp;
HPInit(&hp);
for (int i = 0; i < sizeof(a)/sizeof(a[0]); i++)
{
HPPush(&hp, a[i]);
}
while (!HPEmpty(&hp))
{
printf("%d ", HPTop(&hp));
HPPop(&hp);
}
}
int main()
{
TestHeap01();
return 0;
}3.4 堆排序
堆排序是基于堆数据结构的排序算法，核心思路是通过构建堆并反复提取堆顶元素，实现数据的有序排列。其本质是利用根节点的最值性，将无序数组转换为有序数组。
把无序数据建堆有两种方式：一种是向上调整建堆：把第一个结点看作堆内数据，从第二个结点开始，依次把所有数据入堆，比较，调整位置；一种是向下调整建堆：把最后一个非叶子结点及其子结点看作一个堆，从最后一个非叶子结点开始调整数据位置，然后向前遍历，建堆，调整，直至根节点。
两种建堆方式逻辑上只是遍历方向不同，但效率差异显著。其原因为：
深度越深，节点越多。向上调整，每个结点最多需要移动到根节点，移动深度等于自身深度，越靠近叶子节点移动次数越多 ，时间复杂度为O(nlogn)，而向下调整，越靠近叶子节点移动次数越少，时间复杂度为O(n)。两种方式以下都做实现，可自行测试时间差异。
3.4.1 向上调整堆排序
cpp
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;
}
}
}
void AdjustDown(HPDataType* a, int n, int parent)
{
//假设左节点小
int child = parent * 2 + 1;
while (child < n)
{
//找兄弟节点中小的那个 child+1<n 确保右节点存在
if (child + 1 < n && a[child + 1] < a[child])
{
++child;
}
if (a[parent] > a[child])
{
Swap(&a[parent], &a[child]);
parent = child;
child = parent * 2 + 1;
}
else
{
break;
}
}
}
//堆排序(向上调整建堆)
void HeapSort01(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;
}
}3.4.2 向下调整堆排序
cpp
//向下调整数据
void AdjustDown(HPDataType* a, int n, int parent)
{
//假设左节点小
int child = parent * 2 + 1;
while (child < n)
{
//找兄弟节点中小的那个 child+1<n 确保右节点存在
if (child + 1 < n && a[child + 1] < a[child])
{
++child;
}
if (a[parent] > a[child])
{
Swap(&a[parent], &a[child]);
parent = child;
child = parent * 2 + 1;
}
else
{
break;
}
}
}
//堆排序（向下调整建堆）
void HeapSort02(int* a, int n)
{
int parent = (n - 1 - 1) / 2;
while (parent >= 0)
{
AdjustDown(a, n, parent);
--parent;
}
int end = n - 1;
while (end > 0)
{
Swap(&a[0], &a[end]);
AdjustDown(a, end, 0);
--end;
}
}4. 二叉树链式结构测试
由于二叉树链式结构实现较为复杂，所有我们手动创建一颗简单的二叉树，用于二叉树的操作学习，二叉树的真正创建方式会在后续的文章中详细说明。代码如下：
cpp
#define _CRT_SECURE_NO_WARNINGS 1
#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
typedef int BTDataType;
typedef struct BinaryTreeNode
{
BTDataType data;
struct BinaryTreeNode* left;
struct BinaryTreeNode* right;
}BTNode;
//为二叉树节点开辟空间
BTNode* BuyNode(BTDataType x);
//手搓二叉树 用于测试
BTNode* CreatBinaryTree();
//为二叉树节点开辟空间
BTNode* BuyNode(BTDataType x)
{
BTNode* node = (BTNode*)malloc(sizeof(BTNode));
if (node == NULL)
{
perror("malloc fail");
return NULL;
}
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;
}二叉树遍历方式有两种，广度优先遍历（BFS）和深度优先遍历（DFS）。二叉树的前、中、后序遍历属于深度优先遍历，层序遍历属于广度优先遍历。
4.1 二叉树的前、中、后序遍历
前序遍历：根、左子树、右子树
中序遍历：左子树、根、右子树
后序遍历：左子树、右子树、根
cpp
// 二叉树前序遍历
void BTPrevOrder(BTNode* root)
{
if (root == NULL)
{
printf("N ");
return;
}
printf("%d ", root->data);
BTPrevOrder(root->left);
BTPrevOrder(root->right);
}
// 二叉树中序遍历
void BTInOrder(BTNode* root)
{
if (root == NULL)
{
printf("N ");
return;
}
BTInOrder(root->left);
printf("%d ", root->data);
BTInOrder(root->right);
}
// 二叉树后序遍历
void BTPostOrder(BTNode* root)
{
if (root == NULL)
{
printf("N ");
return;
}
BTPostOrder(root->left);
BTPostOrder(root->right);
printf("%d ", root->data);
}
int main()
{
BTNode* root = CreatBinaryTree();
BTPrevOrder(root);
printf("\n");
BTInOrder(root);
printf("\n");
BTPostOrder(root);
printf("\n");
return 0;
}4.2 二叉树层序遍历
二叉树的层序遍历要借用队列数据结构来实现，将根结点入队列，根结点出队列时将其子结点入队列，当队列为空时，二叉树也就遍历到了末尾。
cpp
void BTLevelOrder(BTNode* root)
{
Queue q;
QueueInit(&q);
//根入队列
if (root)
{
QueuePush(&q, root);
}
while (!QueueEmpty(&q))
{
//取队头数据 并将其子结点入队列 循环直至队列为空(即二叉树遍历至结尾)
BTNode* front = QueueFront(&q);
QueuePop(&q);
printf("%d ", front->data);
if (front->left)
{
QueuePush(&q, front->left);
}
if (front->right)
{
QueuePush(&q, front->right);
}
}
QueueDestory(&q);
}4.3 二叉树高度
cpp
int BTHeight(BTNode* root)
{
if (root == NULL)
return 0;
int leftheight = BTHeight(root->left);
int rightheight = BTHeight(root->right);
return leftheight > rightheight ? leftheight + 1 : rightheight + 1;
}4.4 二叉树结点个数、叶子结点个数和第K层结点个数
cpp
// 二叉树节点个数
int BTSize(BTNode* root)
{
return root == NULL ? 0 : BTSize(root->left) + BTSize(root->right) + 1;
}
// 二叉树叶子节点个数
int BTLeafSize(BTNode* root)
{
if (root == NULL)
return 0;
if (root->left == NULL && root->right == NULL)
return 1;
return BTLeafSize(root->left) + BTLeafSize(root->right);
}
// 二叉树第k层节点个数
int BTLevelKSize(BTNode* root, int k)
{
if (root == NULL)
return 0;
if (k == 1)
return 1;
return BTLevelKSize(root->left, k - 1)+ BTLevelKSize(root->right, k - 1);
}4.5 二叉树查找值为X的结点
cpp
BTNode* BTFind(BTNode* root, BTDataType x)
{
if (root == NULL)
return NULL;
if (x == root->data)
return root;
BTNode* ret1 = BTFind(root->left, x);
if (ret1)
return ret1;
BTNode* ret2 = BTFind(root->right, x);
if (ret2)
return ret2;
return NULL;
}4.6 判断二叉树是否为完全二叉树
逻辑：依靠队列来实现。根入队列，出队列后把其子结点入队列，子结点为空的也入队列，当队列出到第一个空的时候开始判断，此时队列中如果有非空就不是完全二叉树，队列中全为空就是完全二叉树。
cpp
bool BTComplete(BTNode* root)
{
Queue q;
QueueInit(&q);
if (root)
{
QueuePush(&q, root);
}
//队列出到第一个空 出循环开始判断 如果队列中有非空 不是完全二叉树
while (!QueueEmpty(&q))
{
BTNode* front = QueueFront(&q);
QueuePop(&q);
if (front == NULL)
{
break;
}
QueuePush(&q, front->left);
QueuePush(&q, front->right);
}
while (!QueueEmpty(&q))
{
BTNode* front = QueueFront(&q);
QueuePop(&q);
//判断队列中有非空 就不是完全二叉树
if (front)
{
QueueDestory(&q);
return false;
}
}
QueueDestory(&q);
return true;
}