二叉树的基础应用
二叉树
- 树概念及结构
1.1树的概念
树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因 为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。
有一个特殊的结点，称为根结点，根节点没有前驱结点
除根节点外，其余结点被分成M(M>0)个互不相交的集合T1、T2、……、Tm，其中每一个集合Ti(1<= i <= m)又是一棵结构与树类似的子树。每棵子树的根结点有且只有一个前驱，可以有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）棵互不相交的树的集合称为森林；
注：子树是不相交的，除根结外，每个结点有且仅有一个父节点，一棵N个结点的树有N-1条边。
- 3树的表示
树结构相对线性表就比较复杂了，要存储表示起来就比较麻烦了，既然保存值域，也要保存结点和结点之间 的关系，实际中树有很多种表示方式如：双亲表示法，孩子表示法、孩子双亲表示法以及孩子兄弟表示法 等。我们这里就简单的了解其中最常用的孩子兄弟表示法（左孩子右兄弟）
typedef int DataType;
struct Node
{
struct Node* _firstChild1; // 第一个孩子结点
struct Node* _pNextBrother; // 指向其下一个兄弟结点
DataType _data; // 结点中的数据域
};
1.4树在实际中的应用
文件系统就是树在实际生活中的应用
2.二叉树概念及结构
2.1概念
一棵二叉树是结点的一个有限集合，该集合:
1. 或者为空
2. 由一个根节点加上两棵别称为左子树和右子树的二叉树组成
1. 二叉树不存在度大于2的结点
2. 二叉树的子树有左右之分，次序不能颠倒，因此二叉树是有序树
3 特殊的二叉树：
1. 满二叉树：一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树。也就是 说，如果一个二叉树的层数为K，且结点总数是 ，则它就是满二叉树。
2. 完全二叉树：完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树而引出来的。对于深度为K 的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对 应时称之为完全二叉树。 要注意的是满二叉树是一种特殊的完全二叉树
堆排序—时间复杂度O（N*logN）
Topk---类似点外卖，想吃最好吃的饭，需要在n个里面排序排除最好的。
满二叉树就是一个等比数列，从2^0+………+2^(n-1);
等于2^n-1;,
完全二叉树度为1的至多只有1个，高度为h的二叉树，节点范围是2^h-1,(满二叉树可以认为是一个特殊的完全二叉树),高度为h的完全二叉树，节点范围是[2^(h-1),2^h-1]
前h-1的节点个数（前h-1）是满二叉树，计算得2^(h-1)-1,下一层至少有一个节点，所以最小值是2^(h-1)-1+1=2^(h-1);
4 二叉树的性质
1. 若规定根节点的层数为1，则一棵非空二叉树的第i层上最多有2^(i-1) 个结点.
2. 若规定根节点的层数为1，则深度为h的二叉树的最大结点数是2^h-1 .
3. 对任何一棵二叉树, 如果度为0其叶结点个数为 , 度为2的分支结点个数为 ,则有n0 ＝ n2＋1
4. 若规定根节点的层数为1，具有n个结点的满二叉树的深度，h=log2(n+1) . (ps:log2(n+1) 是log以2 为底，n+1为对数)
5. 对于具有n个结点的完全二叉树，如果按照从上至下从左至右的数组顺序对所有节点从0开始编号，则对于序号为i的结点有：
1. 若i>0，i位置节点的双亲序号：(i-1)/2；i=0，i为根节点编号，无双亲节点
2. 若2i+1=n否则无左孩子
3. 若2i+2=n否则无右孩子
5.二叉树的存储结构
二叉树一般可以使用两种结构存储，一种顺序结构，一种链式结构。
- 顺序存储
顺序结构存储就是使用数组来存储，一般使用数组只适合表示完全二叉树，因为不是完全二叉树会有空 间的浪费。而现实中使用中只有堆才会使用数组来存储，关于堆我们后面的章节会专门讲解。二叉树顺 序存储在物理上是一个数组，在逻辑上是一颗二叉树。
下标计算父子间的关系：leftchilid=parent*2+1；rightchild=parent*2+2；
Parent=（chilid-1）/2，右孩子是偶数，左孩子是奇数，右孩子减2左孩子减1.对于偶数说-1除2跟-2除2来说得到的结果是相同的,可以看出右孩子-1/2也可以得到，所以把他们的计算形式给统一了一下。
以上的仅时候满二叉树和完全二叉树。非完全二叉树不是不可以拿数组存而是不合适。
2 堆的概念及结构
如果有一个关键码的集合K = { k0，k1 ，k2 ，…，kn-1 }，把它的所有元素按完全二叉树的顺序存储方式存储 在一个一维数组中，并满足：ki<=k2*i+1 且 ki<=k2*i+2 (ki >=k2*i+1 且 ki>=k2*i+2 ) i = 0，1， 2…，则称为小堆(或大堆)。将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。
堆的性质： 堆中某个节点的值总是不大于或不小于其父节点的值；
堆总是一棵完全二叉树。
堆算法的实现
Heap.h
#pragma once
#include
#include
#include
#include
typedef int HeapDataType;
typedef struct Heap
{
HeapDataType* array;
int size;
int capicity;
}Heap;
void HeapInit(Heap* p);//初始化
void HeapDestory(Heap* p);//销毁堆
void HeapPush(Heap* p,HeapDataType x);//插入
void HeapPop(Heap* p);//删除
HeapDataType HeapTop(Heap* p);//取堆顶
bool HeapEmpty(Heap* p);//堆是否为空
int HeapSize(Heap* p);//堆的大小
void HeapPrint(Heap* p);//打印堆
void AdjustUp(HeapDataType* a, int child);//向上调整
void AdjustDown(HeapDataType* a, int size, int parent);//向下调整
void HeapSort(HeapDataType* a, int n);//堆排序
Heap.c
#define _CRT_SECURE_NO_WARNINGS 1
#include"Heap.h"
//大堆小堆能做到的是大堆堆顶是最大的，小堆堆顶是最小的，可以用来选数
void HeapInit(Heap* p)
{
assert(p);
p->array = NULL;
p->capicity = p->size = 0;
}
void HeapDestory(Heap* p)
{
assert(p);
free(p->array);
p->array = NULL;
p->capicity = p->size = 0;
}
void Swap(HeapDataType* p1, HeapDataType* p2)
{
HeapDataType tmp = *p1;
*p1 = *p2;
*p2 = tmp;
}
void AdjustUp(HeapDataType* a, int child)//从孩子的位置向上调整(父亲小于等于孩子)
{
int parent = (child - 1 )/ 2;
while (child>0)//最坏是一路调整到根
{
//if (a[child] < a[parent])//（小根堆条件）
if (a[child] > a[parent])//（大根堆条件）
{
Swap(&a[child], &a[parent]);
child = parent;
parent = (child-1)/2;
}
else
{
break;
}
}
}
void HeapPush(Heap* p, HeapDataType x)
{
assert(p);
if(p->capicity==p->size)
{
int newcapicity = p->capicity == 0 ? 4 : 2 * p->capicity;
HeapDataType* tmp = (HeapDataType*)realloc(p->array, newcapicity*sizeof(HeapDataType));
if (tmp == NULL)
{
perror("realloc");
exit(-1);
}
p->array = tmp;
p->capicity = newcapicity;
}
p->array[p->size] = x;
p->size++;
AdjustUp(p->array, p->size - 1);
}
void HeapPrint(Heap* p)
{
for (int i = 0; i < p->size; i++)
{
printf("%d ", p->array[i]);
}
printf("\n");
}
void AdjustDown(HeapDataType*a, int size, int parent)//小堆排序都用的小于号，到时需要大堆排序只需要改成大于号
{
//至少满足左子树是小堆，右子树是小堆才能向下调整
//选出左右孩子小的一个
//小的跟父亲比较，如果比父亲要小则交换，继续向下调整
//如果比父亲大则调整结束
//最多调整到叶子节点就结束了
int child = parent * 2 + 1;
while (child a[child])//（大根堆条件）
{
++child;//默认指向小的孩子，先是指向左孩子，如果右孩子小于左孩子，++右孩子，
//如果右孩子大于左孩子，默认在左孩子上
}
//这里child一定的小的那个孩子，至于是左孩子还是右孩子是不需要关心的
//孩子跟父亲比较
//if (a[child] < a[parent])//（小根堆条件）
if (a[child] > a[parent])//(大根堆条件）
{
Swap(&a[child], &a[parent]);
parent = child;
child = parent*2+1;
}
else
{
break;
}
}
}
void HeapPop(Heap* p)//最优的是将首尾调换，将尾删去，删除其他位置的数是没有价值的（只删除堆顶的值）
{
assert(p);
assert(p->size > 0);
Swap(&(p->array[0]), &(p->array[p->size - 1]));
p->size--;
AdjustDown(p->array, p->size, 0);//删除的时候parent是0，向下删除，parent不一定是从0开始的，所以保留了这个接口
}
HeapDataType HeapTop(Heap* p)
{
assert(p);
assert(p->size > 0);
return p->array[0];
}
bool HeapEmpty(Heap* p)
{
assert(p);
return p->size == 0;//等于0就是空，不等于0就不为空
}
int HeapSize(Heap* p)
{
assert(p);
return p->size;
}
//真正的堆排序不需要堆的数据结构
void HeapSort(int *a,int n)
{
//{27，15，19，18，28，34，65，49，25，37}；
// 27
// 15 19
// 18 28 34 65
// 49 25 37
//我们将传入的数组看成是二叉树，但是此时并不是堆，因为没有排序。
建堆（向上插入帮助我们建堆）
相当于第0个位置不动，第一个位置开始插入就行，每次插入都相当于是一次向上调整
//for (int i = 1; i < n; i++)
//{
// AdjustUp(a, i);
//}
相当于一次插入的过程
//建堆
//向下调整要求左子树是堆，右子树也是堆，但现在排序的数组左右子树不是堆
//从倒数第一个非叶子节点开始调整，叶子节点不需要调。（也就是从28开始调）
//孩子比父亲大就换（37跟28比较，将37和28换，49和18调换，65和19，49和15至此左子树就调整完成）
// // 27
// 49 65
// 15 37 34 19
// 18 25 18
//28这个位置下标怎么计算：28是最后一个节点的父亲。
for (int i = (n - 1 - 1) / 2; i >= 0; i--)
//最后一个节点：n-1,算父亲再-1除以2
{
AdjustDown(a, n, i);
}//这里的i=n-1，这样写也可以，从最后一个数开始调整，只不过比上面多走了几次
//堆向上向下调整的次数，在完全二叉树下是数的高度，logN
//两个分别建堆的时间复杂度是：方式1：O（N*logN），方式2：O（N）
//第二个建堆的方法要更好一些
//升序的话，如果构建小根堆选择最小的，之后还得选择次小的，但是这时的关系全部乱了，需要继续新的建堆
//每次的时间复杂度是O（N^2）跟遍历一遍数组选出最小的一样，没有体现出堆的特性
//升序要建大堆，选出最大的数，把最大的数跟末尾的数交换，如同堆删除的思路
//之前是N个数现在可以看成是N-1个数（不看尾的数）这时不看第一个数，左子树跟右子树依旧是大堆
//要选出次大的数，向下调整一次就可以，时间复杂度是logN
//有N-1个数要选择，就要选N*logN次，对比之前建小堆或者直接遍历的O（N^2）比如一千个数，大堆才十次
int end = n - 1;
while (end>0)
{
Swap(&a[0], &a[end]);
AdjustDown(a, end, 0);//只有n-1个数选出最大的
end--;
}
//整体的时间复杂度：O（N*logN）
}
Test.c
#define _CRT_SECURE_NO_WARNINGS 1
#include"Heap.h"
void TestHeapPush()
{
Heap hp1;
HeapInit(&hp1);
int a[] = { 27,15,19,18,28,34,65,49,25,37 };
int sz = sizeof(a) / sizeof(a[0]);
for (int i = 0; i < sz; i++)
{
HeapPush(&hp1, a[i]);
}
HeapPrint(&hp1);
HeapPush(&hp1, 10);
HeapPrint(&hp1);
}
void TestHeapPop()
{
Heap hp1;
HeapInit(&hp1);
int a[] = { 27,15,19,18,28,34,65,49,25,37 };
int sz = sizeof(a) / sizeof(a[0]);
for (int i = 0; i < sz; i++)
{
HeapPush(&hp1, a[i]);
}
HeapPrint(&hp1);
HeapPop(&hp1, 27);
HeapPrint(&hp1);
HeapPop(&hp1);
HeapPrint(&hp1);
}
//这里的堆排序有两个问题
//1.你得先写一个堆的数据结构，反而复杂
//2.有O（n）的空间复杂度
void TestHeapSort()//堆排序
{
//升序打印
Heap hp1;
HeapInit(&hp1);
int a[] = { 27,15,19,18,28,34,65,49,25,37 };
int sz = sizeof(a) / sizeof(a[0]);
for (int i = 0; i < sz; i++)
{
HeapPush(&hp1, a[i]);
}
while (!HeapEmpty(&hp1))
{
printf("%d ", HeapTop(&hp1));
HeapPop(&hp1);
}
//每次只取堆顶的，堆顶就是最小的，循环直到结束会得到升序的数
HeapDestory(&hp1);
}
int main()
{
//TestHeapPush();
//TestHeapPop();
//TestHeapSort();
int a[] = { 27,15,19,18,28,34,65,49,25,37 };
HeapSort(a, sizeof(a) / sizeof(int));
for (int i = 0; i < sizeof(a) / sizeof(int); i++)
{
printf("%d ", a[i]);
}
return 0;
}
向下调整：
越上面的节点少调整次数多，越下面的节点多调整次数少
调整的次数=总节点的个数×这一层调整的次数
T(n)=2^0* (h -1)＋2^1*(h -2)+2^2*(h-3)＋2^3*(h -4)+...+2^(h-3)*2+2^(h-2)* 1①
2*T(n)=2^1* (h -1)＋2^2*(h -2)+2^3*(h-3)＋2^4*(h -4)+...+2^(h-2)*2+2^(h-1)* 1②
因此：建堆的时间复杂度为O(N)
向上调整要最后一层，向下调整不需要最后一层，从倒数第二层开始
最后一层有2^(h-1)个节点，最坏调整h-1次
T(N)=2^1*1+2^2*2+2^3*3+………….+2^(h-2)*(h-2)+2^(h-1)*(h-1)
继续用错位相减
T（N）=N*logN
TOP-K问题（N个数中找最大的/最小的前k个，N是远大于K）
TOP-K问题：即求数据结合中前K个最大的元素或者最小的元素，一般情况下数据量都比较大。
比如：专业前10名、世界500强、富豪榜、游戏中前100的活跃玩家等。
对于Top-K问题，能想到的最简单直接的方式就是排序，但是：如果数据量非常大，排序就不太可取了(可能 数据都不能一下子全部加载到内存中)。最佳的方式就是用堆来解决，基本思路如下：
找最大的前k个
- 堆排序（N*logN）
- 建N个数的大堆，Top/Pop K次 时间复杂度是O（N+logN*K）（向下建堆是O（N），向上建堆是O（N*logN），选向下） （建立N个数的堆用向下建堆，之后Pop K次，首尾互换，把尾给换掉向下调整，调整logN次，总共调整K次，是logN*K次）
- 假设N非常大，比如N是100亿，K比较小，K是100，如何求解？
问题是内存存不下这么大的数，所以1跟2方法都不适合，堆无非建立起来。
将k个数当作堆建立起来，K比较小，前k个数建立一个小堆，这里跟堆排序的思路比较类似有点反过来的感觉，排降序用的是小堆。1> 用数据集合中前K个元素来建堆，前k个最大的元素，则建小堆 ；前k个最小的元素，则建大堆
2>用剩余的N-K个元素依次与堆顶元素来比较，不满足则替换堆顶元素
将剩余N-K个元素依次与堆顶元素比完之后，堆中剩余的K个元素就是所求的前K个最小或者最大的元素。
例如排降序：1.前k个数先建立小堆 2.剩下的N-K个依次跟堆顶数据比较，如果比堆顶数据大，则替换堆顶数据进堆，走完之后，堆里面的数就是最大的前K个。如果建大堆只能选最大的那一个数，不能选最大的前k个数。
它的时间复杂度是O（k+(N-k)*logK）这个在时间效率并没有太快于第二个算法的时间，但是在内存空间上，2是需要建立很大的大堆，它的空间复杂度是k只需要开辟k个这么大的空间建堆
//这里的堆排序有两个问题
//1.你得先写一个堆的数据结构，反而复杂
//2.有O（n）的空间复杂度
void TestHeapSort()//堆排序
{
//升序打印
Heap hp1;
HeapInit(&hp1);
int a[] = { 27,15,19,18,28,34,65,49,25,37 };
int sz = sizeof(a) / sizeof(a[0]);
for (int i = 0; i < sz; i++)
{
HeapPush(&hp1, a[i]);
}
while (!HeapEmpty(&hp1))
{
printf("%d ", HeapTop(&hp1));
HeapPop(&hp1);
}
//每次只取堆顶的，堆顶就是最小的，循环直到结束会得到升序的数
HeapDestory(&hp1);
}
//不需要用自己堆的数据结构
void PrintTopK(int* a, int n, int k)
{
int* KMinHeap = malloc(sizeof(int) * k);
assert(KMinHeap);
for (int i = 0; i < k; ++i)
{
KMinHeap[i] = a[i];
}
// 1. 建堆--用a中前k个元素建堆(最后一个非叶子节点的下标开始建堆）
for (int i = (k - 1 - 1) / 2; i >= 0; i--)
{
AdjustDown(KMinHeap, k, i);
}
// 2. 将剩余n-k个元素依次与堆顶元素交换，不满则则替换(遍历剩下的n-k个数)
for (int j = k; j < n; j++)
{
if (a[j] > KMinHeap[0])
{
KMinHeap[0] = a[j];
AdjustDown(KMinHeap, k, 0);
}
}
//最后的堆里面的数就是最大的前k个数
for (int i = 0; i < k; i++)
{
printf("%d ", KMinHeap[i]);
}
printf("\n");
}
void TestTopk()
{
int n = 10000;
int* a = (int*)malloc(sizeof(int) * n);
srand(time(0));
for (int i = 0; i < n; ++i)
{
a[i] = rand() % 1000000;//每个数都小于100 0000
}
//给十个大于100 0000的数
//最后如果打印出十个下面比100 0000大的数说明程序就ok
a[5] = 1000000 + 1;
a[1231] = 1000000 + 2;
a[531] = 1000000 + 3;
a[5121] = 1000000 + 4;
a[115] = 1000000 + 5;
a[2335] = 1000000 + 6;
a[9999] = 1000000 + 7;
a[76] = 1000000 + 8;
a[423] = 1000000 + 9;
a[3144] = 1000000 + 10;
PrintTopK(a, n, 10);//10000个数据里面找10个最大的
}
链式二叉树：
如果是完全二叉树或者满二叉树，用数组的方式可以表示，如果不是完全二叉树或者满二叉树数组无非很好的表示，链式的二叉树是更合适的。链式的这种普通二叉树的增删查改没有意义。存储数据的话不如用顺序表和链表，学习它的意义：1.为我们后续学习更复杂的二叉树打好基础。（搜素二叉树，AVL树，红黑树，B树….）
学习遍历或者控制结构
二叉树的遍历
前序、中序以及后序遍历
学习二叉树结构，最简单的方式就是遍历。所谓二叉树遍历(Traversal)是按照某种特定的规则，依次对二叉 树中的节点进行相应的操作，并且每个节点只操作一次。访问结点所做的操作依赖于具体的应用问题。 遍历 是二叉树上最重要的运算之一，也是二叉树上进行其它运算的基础。
按照规则，二叉树的遍历有：前序/中序/后序的递归结构遍历：
任何一个树都要被分为根 左子树 右子树
1. 前序遍历(Preorder Traversal 亦称先序遍历)——访问根结点的操作发生在遍历其左右子树之前。 （根 左子树 右子树）
2. 中序遍历(Inorder Traversal)——访问根结点的操作发生在遍历其左右子树之中（间）。
（左子树 根 右子树）
3. 后序遍历(Postorder Traversal)——访问根结点的操作发生在遍历其左右子树之后。
由于被访问的结点必是某子树的根，所以N(Node）、L(Left subtree）和R(Right subtree）又可解释为 根、根的左子树和根的右子树。NLR、LNR和LRN分别又称为先根遍历、中根遍历和后根遍历。（左子树 右子树 根）
#：表示NULL
前序遍历结果：1 2 3 # # # 4 5 # # 6 # #（根 左 右）
中序遍历结果：# 3 # 2 # 1 # 5 # 4 # 6 #（左 根 右）
后序遍历结果：# # 3 # 2 # 5 # # 6 4 1 （左 右 根）
typedef int BTDataType;
typedef struct BinaryTreeNode
{
struct BinaryTreeNode* left;
struct BinaryTreeNode* right;
BTDataType data;
}BTNode;
BTNode* BuyNode(BTDataType x)
{
BTNode* node = (BTNode*)malloc(sizeof(BTNode));
assert(node);
node->data = x;
node->left = 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;
}
void PreOrder(BTNode*root)//前序
{
if (root == NULL)
{
printf("# ");
return;
}
printf("%d ", root->data);
PreOrder(root->left);
PreOrder(root->right);
}
void InOrder(BTNode* root)//中序
{
if (root == NULL)
{
printf("# ");
return;
}
InOrder(root->left);
printf("%d ", root->data);
InOrder(root->right);
}
void PostOrder(BTNode* root)//后序
{
if (root == NULL)
{
printf("# ");
return;
}
PostOrder(root->left);
PostOrder(root->right);
printf("%d ", root->data);
}
int main()
{
BTNode* root = CreatBinaryTree();
PreOrder(root);
printf("\n");
InOrder(root);
printf("\n");
PostOrder(root);
printf("\n");
return 0;
}
与上面我们分析结果相同；我们创造了这样一个树
这里用到了分治算法（二分查找也用到了这个算法）
分而治之，把大问题分成类似规模的小问题，这里可以用递归写；
第一次传入是1这个节点的地址（用1代表），1不是NULL，打印1，之后访问左子树，递归1的左子树，往下递归，2不是NULL再向下递归，先访问2这个子树，2继续访问左子树是3，3的左子树是NULL，打印#，并且返回，返回到上一个递归的3调用的函数中应该是右子树，3的右子树为NULL,则继续打印#，回到它调用的地方，是2左调用的，之后回到2访问右子树，2 的右子树是NULL，打印#，回到1，访问1的右树，下来是4，打印4，之后访问左子树是5，5的左子树是NULL，访问5的右子树是NULL，访问6的左子树是NULL最后访问6的右子树为NULL；最后递归结束。从物理上来看是建立栈帧；栈帧结束回到上一层栈帧；
最开始传入的是根，根节点是1，1不是NULL，遇到1 不能访问先递归走它的左子树，遇到2不能访问继续走它的左树，到3，3的左边是NULL打印#，return回去（一个函数调用完无论是return回去还是正常的执行结束都是回到调用的地方）下一个打印3，递归到3的右树，打印#，return回到上一层，上一层的左树已经调用完了直接就到了第二步打印，回到了2，访问2的右树，右树为NULL打印#，回到1，打印1，继续走1的右树，访问4，4不是NULL走4的左……直到访问完到底。
后序跟前面相同；
下面是计算二叉树存了多少个数
//遍历的思路
int count=0 ;
int TreeSize(BTNode*root)//求二叉树中存了多少个数据
{
//这里的计数不能像链表里面的计数一样放在函数里面
//链表的计数是迭代，这里的递归不能这样，每个栈帧都有一个计数的count
//int count=0；
if (root == NULL)
{
return;
}
++count;
TreeSize(root->left);
TreeSize(root->right);
}
注意在每次调用的时候要把count=0；（局部变量）置空一下；
这里如果多线程的时候可能同时用这个函数，同时计数可能会混，这个count会多个一起计数，全局可见的
//分治的思路
int TreeSize2(BTNode* root)
{
return root == NULL ? 0 : TreeSize2(root->left) + TreeSize2(root->right)+1;
//+1是因为我们计数的时候把数分成3部分，左子树 自己 右子树
}
这样调用多次也不需要每次把count置成0；
int TreeLeafSize(BTNode* root)//求叶子结点（根为0的才是叶子）
{
if (root == NULL)
{
return 0;
}
if ((root->left == NULL) && (root->right == NULL))
{
return 1;
}
//是NULL返回0个，是叶子返回1个，不是NULL也不是叶子结点转换左子树叶子节点+右子树叶子节点
return TreeLeafSize(root->left) + TreeLeafSize(root->right);
}
//继续用分治的想法把大问题分成小问题；
//换成子问题：求第k层，看成是求左子树的第k-1层+求右子树的第k-1层
int TreeKLevel(BTNode* root, int k)//求第k层的节点
{
assert(k >= 1);
if (root == NULL)
{
return 0;
}
if (k == 1)
{
return 1;
}
return TreeKLevel(root->right, k - 1) + TreeKLevel(root->left, k - 1);
}
//二叉树查找值为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;
}