二叉树
1.树概念及结构
1.1 树的相关概念
节点的度：一个节点含有的子树的个数称为该节点的度； 如上图：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）棵互不相交的树的集合称为森林；
这些概念我们还是有必要了解一下的。有的题会用概念来考你。
比如：
一颗完全二叉树有1001个结点，其叶子结点的个数是（ ）
如果你不知道什么是叶节点你就不会做
1.2 树的表示
树结构相对线性表就比较复杂了，要存储表示起来就比较麻烦了，既然保存值域，也要保存结点和结点之间的关系，实际中树有很多种表示方式如：双亲表示法，孩子表示法、孩子双亲表示法以及孩子兄弟表示法等。我们这里就简单的了解其中最常用的孩子兄弟表示法。
typedef int DataType;
struct Node
{
struct Node* _firstChild1; // 第一个孩子结点
struct Node* _pNextBrother; // 指向其下一个兄弟结点
DataType _data; // 结点中的数据域
};
树在实际中的运用（表示文件系统的目录树结构）
2.二叉树概念及结构
一棵二叉树是结点的一个有限集合，该集合:
- 或者为空
- 由一个根节点加上两棵别称为左子树和右子树的二叉树组成
从上图可以看出：
- 二叉树不存在度大于2的结点
- 二叉树的子树有左右之分，次序不能颠倒，因此二叉树是有序树
注意：对于任意的二叉树都是由以下几种情况复合而成的：
2.2现实中的二叉树：
2.1 特殊的二叉树（重点）：
- 满二叉树：一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树。也就是说，如果一个二叉树的层数为K，且结点总数是 ，则它就是满二叉树。
- 完全二叉树：完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树而引出来的。对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树。 要注意的是满二叉树是一种特殊的完全二叉树。
2.4 二叉树的性质
- 若规定根节点的层数为1，则一棵非空二叉树的**第i层上最多有2^(i-1) **个结点.
- 若规定根节点的层数为1，则深度为h的二叉树的最大结点数是2^h - 1.
- 对任何一棵二叉树, 如果度为0其叶结点个数为n0 , 度为2的分支结点个数为n2 ,则有 n0＝n2 ＋1
- 若规定根节点的层数为1，具有n个结点的满二叉树的深度，h= log2（n+1）. (ps： 是log以2为底，n+1为对数)
- 对于具有n个结点的完全二叉树，如果按照从上至下从左至右的数组顺序对所有节点从0开始编号，则对于序号为i的结点有：
- 若i>0，i位置节点的双亲序号：(i-1)/2 i=0，i为根节点编号，无双亲节点
- 若2i+1<n，左孩子序号：2i+1，2i+1>=n否则无左孩子
- 若2i+2<n，右孩子序号：2i+2，2i+2>=n否则无右孩子
画图解释：
1.性质一
2.性质二
3.性质三
4.性质四
这个性质大家画一个满二叉树套公式计算就行，这个好理解
5.性质五
我把图画出来，只要代数就可以证明性质五了
- 某二叉树共有 399 个结点，其中有 199 个度为 2 的结点，则该二叉树中的叶子结点数为（ ）
A 不存在这样的二叉树
B 200
C 198
D 199- 在具有 2n 个结点的完全二叉树中，叶子结点个数为（ ）
A n
B n+1
C n-1
D n/2- 一棵完全二叉树的节点数位为531个，那么这棵树的高度为（ ）
A 11
B 10
C 8
D 12- 一个具有767个节点的完全二叉树，其叶子节点个数为（）
A 383
B 384
C 385
D 386
第一题：
根据上面的性质可知 ，度为 0 的节点 == 度为 2 的节点 +1
第二题：
第三题：
高度为h的完全二叉树的节点范围在【logN^(h-1) , logN^h - 1】（log默认以二为底）
所以 h=10
第四题：
答案为 A，A，B，B
3.二叉树实现堆
堆的性质：
- 堆中某个节点的值总是不大于或不小于其父节点的值；
- 堆总是一棵完全二叉树。
大根堆：父节点大于等于子节点
小根堆：父节点小于等于子节点
3.1堆的实现
typedef int HPDataType;
typedef struct Heap
{
HPDataType* a;
int size;
int capacity;
}HP;
//初始化
void HeapInit(HP* php);
//销毁
void Heapdestroy(HP* php);
//插入
void HeapPush(HP* php, HPDataType x);
//删除
void HeapPop(HP* php);
//判空
bool HeapEmpty(HP* php);
//返回堆顶元素
HPDataType HeapTop(HP* php);
//返回堆中元素个数
int HeapSize(HP* php);
初始化，销毁，插入，删除堆顶元素，判空，返回堆顶元素，返回堆中元素个数
这几个功能比较简单，大家如果自己完成过顺序表，链表一定可以看的懂
这里我挑两个难点来讲：向上调整，向下调整
//初始化
void HeapInit(HP* php)
{
assert(php);
php->a = (HPDataType*)malloc(sizeof(HPDataType) * 4);
if (php->a == NULL)
{
perror("malloc fail");
return;
}
php->size = 0;
php->capacity = 4;
}
//销毁
void Heapdestroy(HP* php)
{
assert(php);
free(php->a);
php->a = NULL;
php->size = php->capacity = 0;
}
//交换
void Swap(HPDataType* e1, HPDataType* e2)
{
HPDataType tmp = *e1;
*e1 = *e2;
*e2 = tmp;
}
//插入并向上调整
void HeapPush(HP* php, HPDataType x)
{
assert(php);
if (php->capacity == php->size)
{
HPDataType* tmp = realloc(php->a, sizeof(HPDataType) * php->capacity * 2);
if (tmp == NULL)
{
perror("realloc fail");
return;
}
php->a = tmp;
php->capacity *= 2;
}
php->a[php->size++] = x;
AdjustUp(php->a, php->size-1);
}
//删除,堆顶元素
void HeapPop(HP* php)
{
assert(php);
assert(!HeapEmpty(php));
Swap(&php->a[0], &php->a[php->size - 1]);
php->size--;
AdjustDown(php->a ,php->size,0);
}
//判空
bool HeapEmpty(HP* php)
{
assert(php);
return php->size == 0;
}
//返回堆顶元素
HPDataType HeapTop(HP* php)
{
assert(php);
return php->a[0];
}
//返回堆中元素个数
int HeapSize(HP* php)
{
assert(php);
return php->size;
}
上图我们可以了解到，大堆与小堆的特点
⭐3.2向上调整排序（重点）
我们这里只讲这两个功能：
首先如果我们要插入元素，只能在堆底插入，插入元素之后就要去调整堆
假设我们现在有一个大堆是这样的：
插入一个数据然后调整
所以我们在插入数之后要写一个向上调整（AdjustUp）
我们想要向上调整，就得知道要调整的位置（sz-1）长度减一就是最后一个元素的下标，还有堆首的地址
所以我们函数的参数设计为AdjustUp（HPDataType* a, int child），把孩子节点向上调整
知道了孩子节点还得知道它的父节点，那我们该怎么找父节点呢？
我们看图可以知道10的父节点是3
3和8的父节点是9
我们发现规律：父节点的下标 =（孩子节点的下标 - 1）/ 2
知道了下标我们就要去比较 （如果是大堆孩子比父亲大就向上调整，如果是小堆孩子比父亲小就向上调）
当孩子节点的下标 == 0的时候说明已经排完序了（孩子节点一直在向上作比较）
所以我们的向上调整排序代码如下：
//向上调整
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;
}
}
}
⭐3.3向下调整排序（重点）
向下调整排序就是我们在执行删除堆顶元素命令后，需要向下调整排序，为什么呢？，如下：
可以看到上面代码，我们说的是删除堆顶元素，实际上就是让堆顶元素与堆底元素交换，这样堆顶元素就到堆底了，把堆底元素删除就可以了，这样不会影响原来的堆，只需要再想向下调整堆顶元素就可以恢复堆了
如果我们直接删除堆顶元素，不仅要把后面数据全部都向前挪动，而且堆的顺序也乱了
就比如下面这个小堆
所以我们不能直接删除堆顶元素，要先把它与堆底元素交换，然后删除堆底元素
我们向下调整需要知道一共有几个元素（不能让孩子节点的下标超过或等于元素个数），还有要向下调整的位置，还有堆的首地址
所以向下调整的函数为AdjustDown(HPDataType* a,int n,int parent)
我们在选孩子节点的时候，先默认是左孩子节点，然后：
如果是建大堆选出左右孩子中大的那一个
如果是建小堆选出左右孩子中小的那一个
代码如下：
//在建好堆的情况下向下调整
void AdjustDown(HPDataType* a,int n,int parent)
{
int child = parent * 2 + 1;
while (child < n)
{
//如果是建大堆选出左右孩子中大的那一个
//如果是建小堆选出左右孩子中小的那一个
if (child + 1 < n && a[child] > a[child + 1])
{
child++;
}
if (a[parent] > a[child] )
{
Swap(&a[parent], &a[child]);
parent = child;
child = parent * 2 + 1;
}
else
{
break;
}
}
}
4.堆的应用
堆排序即利用堆的思想来进行排序，总共分为两个步骤：
4.1 建堆
升序：建大堆
降序：建小堆
如果给你一共数组要求你建堆。
那建堆是要用向上调整的方式建堆还是要用向下调整的方式建堆呢？
答案是使用向下调整建堆
首先我们要知道什么情况下才能向下调整建堆，
向下调整建堆的要求是在建好堆的情况下向下调整
列如下图：
如果我们想要用向下调整排序的方式来建堆，就需要倒着建堆
怎么个倒着建堆呢？
先找到最后一个元素的父亲节点节点，然后在用当前的父节点 -1 找到前面的父节点，一直到 i<0时停止。
所以建小堆只需要如下代码：
//n代表元素个数
//第一个 -1 代表尾元素
//第二个 -1 代表 左孩子节点 或者左孩子节点 -1
// /2 代表找到它的父节点
for (int i = (n-1-1)/2; i >= 0; --i)
{
AdjustDown(a, n, i);
}
那为什么向下调整比向上调整要快呢看下图分析：
所以向下调整排序的时间复杂度为O（N）
那么向上调整排序的时间复杂度为多少呢？
那向上调整排序的时间复杂度为O（N*logN）
4.2 利用堆删除思想来进行排序
TOP-K问题
TOP-K问题：即求数据结合中前K个最大的元素或者最小的元素，一般情况下数据量都比较大。
比如：专业前10名、世界500强、富豪榜、游戏中前100的活跃玩家等。
对于Top-K问题，能想到的最简单直接的方式就是排序，但是：如果数据量非常大，排序就不太可取了(可能数据都不能一下子全部加载到内存中)。最佳的方式就是用堆来解决，基本思路如下：
- 用数据集合中前K个元素来建堆
- 如果要找前k个最大的元素，则建小堆
- 如果要找前k个最小的元素，则建大堆
- 用剩余的N-K个元素依次与堆顶元素来比较，不满足则替换堆顶元素
- 将剩余N-K个元素依次与堆顶元素比完之后，堆中剩余的K个元素就是所求的前K个最小或者最大的元素。
可能大家会疑惑为什么找最大的 k 个元素要建小堆，找最小的 k 个元素要建大堆，
这里我只解释找最大的 k 个元素建小堆的原因：
首先对前 k 给元素建小堆，小堆的堆顶一定这个堆中最小的元素。
用剩下的数来跟堆顶元素作比较，如果比堆顶大就进入堆，进入堆之后再向下调整，调整之后堆顶元素一定还是这个堆中最小的数
就这样用堆顶元素一直与剩下的数比较，所有的数的比较完之后，这个堆中的数就是，所有数 N 中最大的前 k 个数
代码如下：
#include <stdio.h>
#include <time.h>
#include <stdlib.h>
void PrintTopK(int* a,int k)
{
for (int i = 0; i < k; i++)
{
printf("%d ", a[i]);
}
printf("\n");
}
//srand是创建随机数的
void TestTopk()
{
int n = 10000;
int* a = (int*)malloc(sizeof(int) * n);
if (a == NULL)
{
printf("malloc fail");
return;
}
srand(time(0));
for (int i = 0; i < n; ++i)
{
a[i] = rand() % 10000;
}
//用top这快区域来接收最大的 k 个元素
int k = 10;
int* top = (int*)malloc(sizeof(int) * k);
if (top == NULL)
{
printf("malloc fail");
return;
}
for (int i = 0; i < k; i++)
{
top[i] = a[i];
}
//这里我们用前十个数建堆
for (int i = (k - 2) / 2; i < k; i++)
{
AdjustDown(top, k, i);
}
//将剩余n - k个元素依次与top堆顶元素比较，如果满足条件就交换
// 这里我们建小堆，但小堆里要存所有数中最大的元素
// 所以我们就要让大于堆顶的数代替堆顶，然后向下调整
for (int i = k; i < n; i++)
{
if (a[i] > top[0])
{
top[0] = a[i];
AdjustDown(top, k, 0);
}
}
PrintTopK(top,k);
}
int main()
{
TestTopk();
return 0;
}
输出结果：
画图判断这里的10个数是不是小堆
通过下图我们可以确定这里的就是一个小堆
那我们怎么能确定这 10 个数到底是不是这 10000 个数里最大的数呢？
这里的方法很简单，因为我们之前在给每个元素赋值的时候都是
a【i】 = rand（）% 10000，所以每个元素都小于 10000.
我们只要给这 10000 个数中，随机十个数赋大于 10000 的值就可以通过输出结果判断我们之前的代码是否正确。
代码如下：
只是在之前的
void TestTopk()
{
int n = 10000;
int* a = (int*)malloc(sizeof(int) * n);
if (a == NULL)
{
printf("malloc fail");
return;
}
srand(time(0));
for (int i = 0; i < n; ++i)
{
a[i] = rand() % 10000;
}
a[5] = 10000 + 1;
a[1231] = 10000 + 2;
a[531] = 10000 + 3;
a[5121] = 10000 + 4;
a[115] = 10000 + 5;
a[2335] = 10000 + 6;
a[9999] = 10000 + 7;
a[76] = 10000 + 8;
a[423] = 10000 + 9;
a[3144] = 10000 + 10;
//用top这快区域来接收最大的 k 个元素
int k = 10;
int* top = (int*)malloc(sizeof(int) * k);
if (top == NULL)
{
printf("malloc fail");
return;
}
for (int i = 0; i < k; i++)
{
top[i] = a[i];
}
//这里我们用前十个数建堆
for (int i = (k - 2) / 2; i < k; i++)
{
AdjustDown(top, k, i);
}
//将剩余n - k个元素依次与top堆顶元素比较，如果满足条件就交换
// 这里我们建小堆，但小堆里要存所有数中最大的元素
// 所以我们就要让大于堆顶的数代替堆顶，然后向下调整
for (int i = k; i < n; i++)
{
if (a[i] > top[0])
{
top[0] = a[i];
AdjustDown(top, k, 0);
}
}
PrintTopK(top,k);
}
结果证明，我们上面的代码是正确的。输出的都是大于10000的数
那有的同学说这里的堆没有顺序，我们需要写一个堆排序即可
代码如下
void HeapSort(int* a, int n)
{
//n代表元素个数
//第一个 -1 代表尾元素
//第二个 -1 代表 左孩子节点 或者左孩子节点 -1
// /2 代表找到它的父节点
for (int i = (n - 1 - 1) / 2; i >= 0; --i)
{
AdjustDown(a, n, i);
}
//n是元素个数，n-1就是尾元素下标
int end = n - 1;
//尾元素下标大于0，就进入循环
//如果尾元素等于 0 那就是剩下最后一个没有排序的元素了，所以
// end > 0时进入循环就可以了
while (end > 0)
{
Swap(&a[0], &a[end]);
AdjustDown(a, end, 0);
end--;
}
}
输出结果：
4.二叉树链式结构的实现
4.1二叉树的遍历
前序遍历，中序遍历，后序遍历
所谓二叉树遍历(Traversal)是按照某种特定的规则，依次对二叉树中的节点进行相应的操作，并且每个节点只操作一次。访问结点所做的操作依赖于具体的应用问题。 遍历是二叉树上最重要的运算之一，也是二叉树上进行其它运算的基础。
按照规则，二叉树的遍历有：前序/中序/后序的递归结构遍历：
- 前序遍历(Preorder Traversal 亦称先序遍历)——访问根结点的操作发生在遍历其左右子树之前。
- 中序遍历(Inorder Traversal)——访问根结点的操作发生在遍历其左右子树之中（间）。
- 后序遍历(Postorder Traversal)——访问根结点的操作发生在遍历其左右子树之后。
学习二叉树我们就要学会把一个大的问题，分解成小问题来解决，用递归来解决问题
例如前序遍历
我们是要先访问当前节点的元素，再访问左节点，再访问右节点
我们把遍历整个树，看做成遍历一颗一颗的小的树
当 root（根节点）== NULL 时返回
我们就上图这颗树，写一下它的前序遍历：
它的前序顺序应该是上图这样，实际输出的数据是，1 > 2 > 4 > 5 > 3 > 6 > 7
那我们来用代码实现一下吧，在实现前序之前我们要先有一颗树
我们直接简单的创建一颗二叉树
#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* newnode = (BTNode*)malloc(sizeof(BTNode));
if (newnode == NULL)
{
perror("malloc fail");
return NULL;
}
newnode->data = x;
newnode->left = NULL;
newnode->right = NULL;
return newnode;
}
int main()
{
BTNode* Node1 = BuyNode(1);
BTNode* Node2 = BuyNode(2);
BTNode* Node3 = BuyNode(3);
BTNode* Node4 = BuyNode(4);
BTNode* Node5 = BuyNode(5);
BTNode* Node6 = BuyNode(6);
BTNode* Node7 = BuyNode(7);
Node1->left = Node2;
Node1->right = Node3;
Node2->left = Node4;
Node2->right = Node5;
Node3->left = Node6;
Node3->right = Node7;
return 0;
}
注意：上述代码并不是创建二叉树的方式
二叉树写好了之后我们把前序遍历来实现一下
前序遍历代码如下：
void PrevOrder(BTNode* root)
{
if (root == NULL)
return;
printf("%d ", root->data);
PrevOrder(root->left);
PrevOrder(root->right);
}
我们把Node1传给前序遍历，发现输出结果与上面画图解释的数据顺序一样。
中序，后序的遍历只是与前序遍历的访问数据的时间不同，如有不理解看下面的代码就知道为什么这样说了
中序遍历：
void InOrder(BTNode* root)
{
if (root == NULL)
return;
InOrder(root->left);
printf("%d ", root->data);
InOrder(root->right);
}
后序遍历：
void PostOrder(BTNode* root)
{
if (root == NULL)
return;
PostOrder(root->left);
PostOrder(root->right);
printf("%d ", root->data);
}
4.1 层序遍历
层序遍历：除了先序遍历、中序遍历、后序遍历外，还可以对二叉树进行层序遍历。设二叉树的根节点所在层数为1，层序遍历就是从所在二叉树的根节点出发，首先访问第一层的树根节点，然后从左到右访问第2层上的节点，接着是第三层的节点，以此类推，自上而下，自左至右逐层访问树的结点的过程就是层序遍历。
二叉树的层序遍历我们需要借助之前学过的知识点，队列来帮助我们实现。
栈和队列特性的讲解
层序遍历代码如下：
// 层序遍历
void LevelOrder(BTNode* root)
{
Queue q1;
QueueInit(&q1);
if(root != NULL)
QueuePush(&q1, root);
while (!QueueEmpty(&q1))
{
BTNode* front = QueueFront(&q1);
QueuePop(&q1);
printf("%d ", front->data);
if (front->left)
{
QueuePush(&q1, front->left);
}
if (front->right)
{
QueuePush(&q1, front->right);
}
}
}
注意我们这里要把队列的数据类型改为 struct BinaryTreeNode*
4.2 节点个数以及高度等
// 二叉树节点个数
int BinaryTreeSize(BTNode* root);
// 二叉树叶子节点个数
int BinaryTreeLeafSize(BTNode* root);
// 二叉树第k层节点个数
int BinaryTreeLevelKSize(BTNode* root, int k);
// 二叉树查找值为x的节点
BTNode* BinaryTreeFind(BTNode* root, BTDataType x);
// 二叉树销毁
void BinaryTreeDestory(BTNode** root);
// 判断二叉树是否是完全二叉树
int BinaryTreeComplete(BTNode* root);
二叉树节点个数
计算节点个数还是上面讲到的思想，把大问题化为一个小问题
如果节点为空返回 0
如果不为空返回 左节点个数 + 右节点个数 + 1（自己）
// 二叉树节点个数
int BinaryTreeSize(BTNode* root)
{
if (root == NULL)
return 0;
return BinaryTreeSize(root->left) + BinaryTreeSize(root->right) + 1;
}
二叉树叶子节点个数
求叶子节点个数，思想还是递归思想
如果 root 的左右节点都为空说明他就是叶子节点
代码如下；
// 二叉树叶子节点个数
int BinaryTreeLeafSize(BTNode* root)
{
if (root == NULL)
return 0;
if (root->left == NULL && root->right == NULL)
return 1;
return BinaryTreeLeafSize(root->left) + BinaryTreeLeafSize(root->right);
}
二叉树第k层节点个数
第 k 层节点个数，当 k == 1 时，就是第 k 层
计算当 k == 1 时的节点个数就行
代码如下；
// 二叉树第k层节点个数
int BinaryTreeLevelKSize(BTNode* root, int k)
{
if (root == NULL)
return 0;
if (k == 1)
return 1;
return BinaryTreeLevelKSize(root->left, k - 1) + BinaryTreeLevelKSize(root->right, k - 1);
}
二叉树查找值为x的节点
只需要遍历二叉树，当 root->data == x 时就返回它的节点
代码如下：
// 二叉树查找值为x的节点
BTNode* BinaryTreeFind(BTNode* root, BTDataType x)
{
if (root == NULL)
return NULL;
if (root->data == x)
return root;
//如果左不为空，说明找到了，就返回节点
BTNode* lret = BinaryTreeFind(root->left, x);
if (lret)
return lret;
//同上
BTNode* rret = BinaryTreeFind(root->right, x);
if (lret)
return lret;
return NULL;
}
二叉树的销毁
二叉树的销毁要使用后续遍历的思想来销毁，如果用前序，中序来销毁，我们销毁了当前节点，就找不到后面的节点了
后续遍历正好时先访问左子树，在访问右子树，最后访问当前节点，我们时最后释放当前节点
代码如下：
// 二叉树销毁
void BinaryTreeDestory(BTNode* root)
{
if (root == NULL)
return;
BinaryTreeDestory(root->left);
BinaryTreeDestory(root->right);
free(root);
}
判断二叉树是否是完全二叉树
使用队列来判断，如果访问到空时，后面的元素还有不为空的，二叉树就不是完全二叉树
// 判断二叉树是否是完全二叉树
bool BinaryTreeComplete(BTNode* root)
{
Queue s1;
QueueInit(&s1);
if (root)
QueuePush(&s1, root);
while (!QueueEmpty(&s1))
{
BTNode* Front = QueueFront(&s1);
QueuePop(&s1);
if (Front == NULL)
{
break;
}
else
{
QueuePush(&s1, Front->left);
QueuePush(&s1, Front->right);
}
}
while (!QueueEmpty(&s1))
{
BTNode* Front = QueueFront(&s1);
QueuePop(&s1);
if (Front)
{
Queuedestroy(&s1);
return false;
}
}
Queuedestroy(&s1);
return true;
}
2814
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
