目录
[4.2 二叉树结点个数](#4.2 二叉树结点个数)
[4.6 二叉树查找值为x的结点](#4.6 二叉树查找值为x的结点)
二叉树对比前面的内容确实更加难以理解，我们在学习的过程中要把物理上的存储结构（数组或链表）和思维上的逻辑结构（图中的形状）分清楚。有不理解的一点要去多复习几遍前面的内容！
一、树
1.1树的概念
树是一种非线性的数据结构，它是由n个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。
我们要注意，树形结构中，子树之间不能有交集，否则就不是树形结构，像下面这样
我们关于树的结构中有以下概念：
结点的度：一个结点含有的子树的个数称为该结点的度； 如下图：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的子孙。
1.2数的表示方法
树结构相对线性表比较复杂了，因为不仅要储存节点，也要储存结点和结点之间的关系，实际中树有很多种表示方式如：双亲表示法，孩子表示法、孩子双亲表示法以及孩子兄弟表示法等。我们这里就简单的了解其中最常用的孩子兄弟表示法。
typedef int DataType;
struct Node
{
struct Node* firstChild1; // 孩子结点
struct Node* pNextBrother; // 下一个兄弟结点
DataType data; // 结点中的数据域
};二、二叉树
2.1二叉树的概念
二叉树是树的一个简化，它只由一个根结点加上两棵别称为左子树和右子树的二叉树组成。如下图
我们所研究的一般是二叉树中的两个特例，完全二叉树和满二叉树。
**满二叉树：**一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树。也就是说，如果一个二叉树的层数为K，且结点总数是，则它就是满二叉树。
完全二叉树 ：完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树而引出来的。对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树。 要注意的是满二叉树是一种特殊的完全二叉树。
如下图
2.2二叉树的一些数学性质
层数为h的二叉树的最大结点数是2^h-1,h=log2(n+1)
对于具有n个结点的完全二叉树，如果按照从上至下从左至右的数组顺序对所有结点从0开始编号，则对于序号为i的结点有：
1. 若i>0，i位置结点的双亲序号：(i-1)/2；i=0，i为根结点编号，无双亲结点
2. 若2i+1<n，左孩子序号：2i+1，2i+1>=n否则无左孩子
3. 若2i+2<n，右孩子序号：2i+2，2i+2>=n否则无右孩子
2.3二叉树的存储结构
2.3.1顺序存储
顺序结构存储就是使用数组来存储，一般使用数组只适合表示完全二叉树，因为不是完全二叉树会有空间的浪费。而现实中使用中只有堆（后面会说）才会使用数组来存储，二叉树顺序存储在物理上是一个数组，在逻辑上是一颗二叉树。
2.3.2链式存储
二叉树的链式存储结构是指，用链表来表示一棵二叉树，即用链来指示元素的逻辑关系。 通常的方法是链表中每个结点由三个域组成，数据域和左右指针域，左右指针分别用来给出该结点左孩子和右孩子所在的链结点的存储地址 。
三、二叉树顺序结构的实现
我们通常把堆(一种二叉树)使用顺序结构的数组来存储。堆我们又分为大堆和小堆，大堆理解就是父亲永远比孩子大，小堆就是父亲永远比孩子小。如下
3.1（小）堆的创建
我们这里提醒一下堆只是一种顺序储存的完全二叉树，我们使用数组为底层逻辑结构创建
注意我们这里的例子都是基于小堆
typedef int HPDataType;
typedef struct Heap
{
HPDataType* a;
int size;
int capacity;
}HP;3.2堆的初始化和销毁
这里和我们顺序表的思路是相同的，因为它们的结构比较相似
//初始化
void HPInit(HP* php)
{
php->a = NULL;
php->capacity = 0;
php->size = 0;
}
//销毁
void HPDestroy(HP* php)
{
free(php->a);
php->a = NULL;
php->capacity = 0;
php->size = 0;
}3.3添加数据
我们添加数据的操作就不再过多赘述，有不理解的可以去看顺序表中的尾插操作，现在的问题是我i们创建的是小堆即使添加数据也不能破坏我们小堆的结构，因此我们添加的数据必须进行向上调节，如图
实现调节的过程中我们需要不停把孩子节点和父亲节点作比较，如果孩子比父亲小就需要交换两人的位置然后再让孩子与上面的父亲进行比较，知道孩子比父亲大就停下。我们这里就需要用到在数组中父亲和孩子节点的关系就是我们上面说过的二叉树的数学性质。
用数组中下标父子关系:
假设父亲在数组中的下标: i
左孩子在数组中的下标: 2i+1
右孩子在数组中的下标: 2i+2
假设孩子在数组中的下标: j
父亲在数组中的下标: (j-1)/2
//交换指针
void Swap(HPDataType* p1, HPDataType* p2)
{
HPDataType* ret = p1;
p1 = p2;
p2 = ret;
}
//升序
void AdjustUp(HPDataType* a, int child)
{
int parent = (child - 1) / 2;
while (child > 0)
{
if (a[child] < a[parent])
{
Swap(&child, &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* ret = (HPDataType*)realloc(php->a, newcapacity * sizeof(HPDataType));
if (ret == NULL)
{
perror("realloc fail");
exit(1);
}
php->capacity = newcapacity;
}
php->a[php->size] = x;
php->size++;
AdjustUp(php->a, php->size - 1);
}3.4删除数据
我们删除数据是操作就有些不一样，我们要知道大堆和小堆我们使用它们一般都是要那个最大值和最小值，也就是堆顶所以我们一般删除也是要删除堆顶数据。
不要忘记不论是大堆还是小堆逻辑上来看他像一个三角形但不能改变它的本质还是一个数组，这里数组删除数据直接size--是最简单的方法，但我们要删除的是第一个数据，所以先把它俩交换位置在size--。但我们别忘了我们把之前最后的数据调到前面了，所以它不一定是最小的，我们需要把它向下调整。
//降序
void AdjustDown(HPDataType* 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(&child, &parent);
parent = child;
child = parent * 2 + 1;
}
else
{
break;
}
}
}
//删除数据
void HPPop(HP* php)
{
assert(php);
assert(php->size);
Swap(&php->a[0], &php->a[php->size - 1]);
php->size--;
AdjustDown(php->a, php->size, 0);
}3.5获取顶部数据
//获取顶部数据
HPDataType HPTop(HP* php)
{
assert(php);
assert(php->size);
return php->a[0];
}3.6判空
//判断是否尾空
bool HPEmpty(HP* php)
{
assert(php);
return php->size == 0;
}3.7堆排序
堆排序顾名思义就是用堆实现排序就像我们之前的冒泡排序，我们一般用大堆实现升序，用小堆实现降序。
如下要找到最大的k个数，我们要建大堆，然后打印堆顶数据再删掉再打印堆顶
//找出最大的前k个
int k = 0;
scanf("%d", &k);
while (k--)
{
printf("%d ", HPTop(&hp));
HPPop(&hp);
}
printf("\n");但如果是要找到数据中最大的前k个数，我们的思路又不一样了。我们应该建小堆，把剩下的数据和对顶的进行比较然后比堆顶大的就收进来，再形成小堆，再比较......
void Create()
{
int n = 10000;
srand(time(0));
//打开文件，写入
const char* file = "data.txt";
FILE* pf = fopen(file, "w");
if (pf == NULL)
{
perror("fopen");
exit(1);
}
for (int i = 0; i < n; i++)
{
int x = (rand()+i) % 10000000;
fprintf(pf, "%d", x);
}
fclose(pf);
}
void Test3()
{
//创建数组
int k = 0;
printf("请输入k->\n");
scanf("%d", &k);
int* kminheap = (int*)malloc(sizeof(int) * k);
if (kminheap == NULL)
{
perror("fail malloc");
exit(1);
}
//打开文件，读取
const char* file = "data.txt";
FILE* p = fopen(file, "r");
if (p == NULL)
{
perror("fopen");
exit(1);
}
for (int i = 0; i < k; i++)
{
fscanf(p, "%d", &kminheap[i]);
}
//变成小堆
for (int i = (k-1-1)/2; i >= 0; i--)
{
AdjustDown(kminheap, k, i);
}
//把其他数据拿来对比
int x = 0;
while (fscanf(p, "%d", &x) > 0)
{
if (x > kminheap[0])
{
kminheap[0] = x;
AdjustDown(kminheap, k, 0);
}
}
//打印
printf("最大的前%d个数", k);
for (int i = 0; i < k; i++)
{
printf("%d ", kminheap[i]);
}
printf("\n");
}四、二叉树链式结构的实现
在开始学习二叉树时我们想要创建一颗树是比较困难的，因为对很多结构内容都不理解，所以我们这里先手搓一棵树,方便后续研究。注意这里的学习要频繁用到递归
typedef int BTDataType;
typedef struct BinaryTreeNode
{
BTDataType data;
struct BinaryTreeNode* left;
struct BinaryTreeNode* right;
}BTNode;
BTNode* BuyNode(int x)
{
BTNode* node = (BTNode*)malloc(sizeof(BTNode));
if (node == NULL)
{
perror("fail malloc");
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.1前，中，后序遍历
遍历是按照某种特定的规则，依次对二叉树中的结点进行相应的操作，并且每个结点只操作一次。访问结点所做的操作依赖于具体的应用问题。 遍历是二叉树上最重要的运算之一，也是二叉树上进行其它运算的基础。
-
前序遍历------访问根结点的操作发生在遍历其左右子树之前。
-
中序遍历------访问根结点的操作发生在遍历其左右子树之中（间）。
-
后序遍历------访问根结点的操作发生在遍历其左右子树之后。
// 二叉树前序遍历
void PreOrder(BTNode* root)
{
if (root == NULL)
{
printf("N ");
return;
}
printf("%d ", root->data);
PreOrder(root->left);
PreOrder(root->right);
}
// 二叉树中序遍历
void InOrder(BTNode* root)
{
if (root == NULL)
{
printf("N ");
return;
}
InOrder(root->left);
printf("%d ", root->data);
InOrder(root->right);
}
// 二叉树后序遍历
void PostOrder(BTNode* root)
{
if (root == NULL)
{
printf("N ");
return;
}
PostOrder(root->left);
PostOrder(root->right);
printf("%d ", root->data);
}如果不能很好理解的我们可以画一个递归展开图帮助理解。不要嫌弃麻烦，画一遍是在帮助直接理清思路。
4.2 二叉树结点个数
我们在研究二叉树的节点个数时要用到递归的思路（大问题化作小问题），我们把求节点个数的问题化作求左子树节点个数加右子树节点个数加1。
// 二叉树结点个数
int TreeSize(BTNode* root)
{
if (root == NULL)
{
return 0;
}
return TreeSize(root->left) + TreeSize(root->right) + 1;
}4.3二叉树叶子个数
叶子节点就是左孩子和右孩子都为空的节点，如果只有的一个根节点那叶子个数就是1，如果不是，那我们就要把问题化为左子树上的叶子个数加上右子树上的叶子个数。
// 二叉树叶子个数
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);
}4.4二叉树层数
二叉树的层数就是要求左子树的层数和右子树的层数大的那个然后加1（根节点也是一层），我们要注意的是用一个变量把每次递归出的值记住，要不然每次都要重复递归
// 二叉树层数
int TreeHighSize(BTNode* root)
{
if (root == NULL)
{
return 0;
}
int lefthigh = TreeHighSize(root->left);
int righthigh = TreeHighSize(root->right);
return lefthigh > righthigh ? lefthigh + 1 : righthigh + 1;
}4.5二叉树第k层结点个数
第k层的节点个数是相对根节点而言的，所以我们可以把问题逐步化简下去如图
// 二叉树第k层结点个数
int TreeLevelKSize(BTNode* root, int k)
{
if (root == NULL)
{
return 0;
}
if (k == 1)
{
return 1;
}
return TreeLevelKSize(root->right, k - 1) + TreeLevelKSize(root->left, k - 1);
}
4.6 二叉树查找值为x的结点
找值为x的节点本质就是一个遍历的过程，我们这里就是先看根节点是不是再到左子树里去找，最后到右子树里去找。
// 二叉树查找值为x的结点
BTNode* TreeFind(BTNode* root, BTDataType x)
{
if (root == NULL)
{
return;
}
if (root->data == x)
{
return root;
}
BTNode* left = TreeFind(root->left, x);
if (left)
{
return left;
}
BTNode* right = TreeFind(root->right, x);
if (right)
{
return right;
}
return NULL;
}4.7二叉树的销毁
// 二叉树销毁
void TreeDestory(BTNode* root)
{
if (root == NULL)
{
return;
}
TreeDestory(root->left);
TreeDestory(root->right);
free(root);
}4.8通过遍历数组构建二叉树
都是前面一些的应用，需要注意的是在传递数组下标元素（i）时都使用指针传递（pi），这是由于实参和形参的关系。
struct TreeNode {
char val;
struct TreeNode* left;
struct TreeNode* right;
};
typedef struct TreeNode TreeNode;
TreeNode* createtree(char* a,int* pi)
{
if(a[*(pi)] == '#')
{
(*pi)++;
return NULL;
}
TreeNode*root = (TreeNode*)malloc(sizeof(TreeNode));
root->val = a[(*pi)++];
root->left = createtree(a,pi);
root->right = createtree(a,pi);
return root;
}
//中序遍历
void inorder (TreeNode* root)
{
if (root == NULL)
{
return;
}
inorder(root->left);
printf("%c ",root->val);
inorder(root->right);
}
//销毁
void freetree(TreeNode* root)
{
if (root == NULL)
{
return;
}
freetree(root->left);
freetree(root->right);
freetree(root);
}
int main() {
char a[101] = {0};
while (scanf("%s",a) != EOF) {
int i = 0;
TreeNode*root = createtree(a,&i);
inorder(root);
printf("\n");
freetree(root);
}
return 0;
}4.9判断二叉树是否为完全二叉树
这个问题需要自己画图体会，这里不多说了，源代码放在这里，不理解的可以私信我
// 判断二叉树是否是完全二叉树
bool TreeComplete(BTNode* root)
{
Queue pq;
QueueInit(&pq);
if (root)
{
QueuePush(&pq, root);
BTNode* front = QueueFront(&pq);
QueuePop(&pq);
}
while (!QueueEmpty(&pq))
{
BTNode* front = QueueFront(&pq);
QueuePop(&pq);
if (front == NULL)
{
break;
}
QueuePush(&pq, front->left);
QueuePush(&pq, front->right);
}
while (!QueueEmpty(&pq))
{
BTNode* front = QueueFront(&pq);
QueuePop(&pq);
if (front)
{
QueueDestroy(&pq);
return false;
}
}
QueueDestroy(&pq);
return true;
}