二叉树详解
Posted 聪明的骑士
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了二叉树详解相关的知识，希望对你有一定的参考价值。
目录
一、树
1.树的概念
树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。
把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。
有一个特殊的结点，称为根结点，根节点没有前驱结点除根节点外，其余结点被分成M(M>0)个互不相交的集合T1、T2、……、Tm，其中每一个集合Ti(0<=i<=m)又是一棵结构与树类似的子树。每棵子树的根结点有且只有一个前驱，可以有0个或多个后继因此，树是递归定义的。
注意，不含数据的空树也是树，用空集表示
2.树与非树的判断
（1）基本概念
- 节点的度：一个节点含有的子树的个数称为该节点的度。
- 叶子节点或终端节点：度为0的节点称为叶节点。比如B、C、H、I...等节点为叶节点非终端节点或分支节点度不为0的节点
- ，比如图中D、E、F、G...等节点为分支节点。
- 双亲节点或父节点：若一个节点含有子节点，则这个节点称为其子节点的父节点。（有些人认为叫父节点忽视女性就搞了个双亲结点，不管怎么样支持男女平等，抵制田园女权）例如，A是B的父节点。
- 孩子节点或子节点：一个节点含有的子树的根节点称为该节点的子节点。例如，B是A的子节点。
- 兄弟节点：具有相同父节点的节点互称为兄弟节点。如图，B、C是兄弟节点。
- 度：一棵树中，最大的节点的度称为树的度。如图：树的度为2.
- 节点的层次：从根开始定义起，根为第1层，根的子节点为第2层，以此类推……
- 树的高度或深度：树中节点的最大层次。如图，树的高度为4.
- 堂兄弟节点：双亲在同一层的节点互为堂兄弟。如图，H、I互为兄弟节点。
- 节点的祖先：从根到该节点所经分支上的所有节点。比如，A是所有节点的祖先。
- 子孙：以某节点为根的子树中任一节点都称为该节点的子孙。如上图：所有节点都是A的子孙。
- 森林：由m（m>0）棵互不相交的树的集合称为森林。
突然想起了过年时，你爸妈让你给不认识的亲戚拜年，挨个叫人的场景……
（2）判断方法
- 子树是不相交的
- 除根节点外，每个节点只有一个父节点
- 一棵有N个节点的树有N-1条边
3.树的表示方法
我们上面图中的树都是简单的二叉树，一个树的度可以有很多，那么如何表示所有的树呢？兄弟表示法，给我们找到了出路。
typedef int DataType;
struct Node
struct Node* _firstChild1; // 第一个孩子结点
struct Node* _pNextBrother; // 指向其下一个兄弟结点
DataType _data; // 结点中的数据域
;通过树的根节点向下寻找大儿子直到需要的一代，每一代的大儿子又连接着这一代其他兄弟，这样就可以做到对树的不同度的节点的定义。
二、二叉树
1.概念及结构
（1）概念：一棵二叉树是结点的一个有限集合，该集合或者为空，或者是由一个根节点加上两棵别称为左子树和右子树的二叉树组成。
特点：
- 每个结点最多有两棵子树，即二叉树不存在度大于2的结点。
- 二叉树的子树有左右之分，其子树的次序不能颠倒。
（2）特殊的二叉树：
- 满二叉树：一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树。也就是说，如果一个二叉树的层数为K，且结点总数是(2^k) -1 ，则它就是满二叉树。
- 完全二叉树：完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树而引出来的。对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树。 要注意的是满二叉树是一种特殊的完全二叉树。
注意，完全二叉树必须最多只有最后一层不满
2.二叉树的实现方法
二叉树一般可以使用两种结构存储，一种顺序结构，一种链式结构。在这里我们首先使用顺序结构，也就是通过数组实现二叉树；然后通过链表的模式实现二叉树。
顺序结构二叉树的性质：
- 若规定根节点的层数为1，则一棵非空二叉树的第i层上最多有2^(i-1) 个结点。
- 若规定根节点的层数为1，则深度为h的二叉树的最大结点数是2^h- 1.
- 对任何一棵二叉树, 如果度为0其叶结点个数为 n0, 度为2的分支结点个数为 n2,则有n0＝n2＋1.
- 若规定根节点的层数为1，具有n个结点的满二叉树的深度，h=Log2(n+1). (Log2(n+1)是log以2为底，n+1为对数)
- 对于具有n个结点的完全二叉树，如果按照从上至下从左至右的数组顺序对所有节点从0开始编号，则对于序号为i的结点有：若i>0，i位置节点的双亲序号为(i-1)/2；i=0，i为根节点编号，无父节点；若2i+1，左孩子序号：2i+1，2i+1>=n否则无左孩子；若2i+2，右孩子序号：2i+2，2i+2>=n否则无右孩子。
三、堆
1.堆的概念
普通的二叉树是不适合用数组来存储的，因为可能会存在大量的空间浪费。而完全二叉树更适合使用顺序结构存储，这种顺序的二叉树最具有代表性的数据结构就是堆。
我们引入堆的概念：
如果有一个关键码的集合K = k0，k1， k2，…，kn-1，把它的所有元素按完全二叉树的顺序存储方式存储在一个一维数组中，并满足：Ki i+1 且 Kii+2 (Ki >= K2i+1 且 Ki >= K2i+2) i = 0，1，2…，则称为小堆(或大堆)。
现实中我们通常把堆(一种二叉树)使用顺序结构的数组来存储，需要注意的是这里的堆和操作系统虚拟进程地址空间中的堆区是两回事，一个是数据结构，一个是操作系统中管理内存的一块区域分段。
将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。
堆的性质：堆中某个节点的值总是不大于或不小于其父节点的值，堆总是一棵完全二叉树。
2.堆的实现
注意，我们这里建堆建的是大根堆
（1）初始化
void HeapInit(HP* php);
单纯的顺序表初始化（确信）
void HeapInit(HP* php)
assert(php);
php->capacity = 0;
php->size = 0;
php->a = NULL;
（2）打印堆元素
void HeapPrint(HP* php);
单纯的顺序表打印（确信）
void HeapPrint(HP* php)
assert(php);
int i = 0;
for (i = 0; i < php->size; i++)
printf("%d ", php->a[i]);
printf("\\n");
（3）交换元素
void Swap(HPDataType* p1, HPDataType* p2);
在许多函数中需要交换不同位置的数据，我们写一个函数
void Swap(HPDataType* p1, HPDataType* p2)
assert(p1 && p2);
HPDataType temp;
temp = *p1;
*p1 = *p2;
*p2 = temp;
（4）向上调整
void AdjustUp(HPDataType* a, int child);
我们在向堆中插入数据时会遇到父节点数据小于子节点的情况，那我们就需要让这个元素与父节点进行比较，如果父节点小于子节点就交换这两个元素，直到父节点大于或等于子节点就停止交换。
void AdjustUp(HPDataType* a, int child)
assert(a);
int parent = (child-1)/2;
while(parent>0)
if(a[parent]<a[child])
swap(&a[parent],&a[child]);
child = parent;
parent = (child-1)/2;
else
break;
（5）插入元素
void HeapPush(HP* php, HPDataType x);
首先和顺序表一样插入元素，然后对这个元素与父节点进行比较，交换位置至对应位置处。
堆的建立只需要多次插入数据即可。
void AdjustDown(HPDataType* a, int n, int parent)
assert(a);
int need_child = parent*2+1;
while(need_child<n)//节点的下标一定在有效数据范围内
if(a[need_child]<a[need_child+1] && need_child+1<n)//比较左孩子和右孩子哪一个最大，大的作为交换的对象
need_child++;
if(a[need_child]>a[parent])
swap(&a[need_child],&a[parent]);
parent = need_child;
need_child = parent*2+1;
else
break;
（6）向下调整
void AdjustDown(HPDataType* a, int n, int parent);
我们在删除元素的时候会遇到数据父节点小于子节点的情况，此时我们就需要将这个节点向下调整到对应位置。
//向堆中插入数据
void HeapPush(HP* php, HPDataType x)
assert(php);
if (php->capacity == php->size)
int newcapacity = (php->capacity == 0 ? 4 : 2 * php->capacity);
HPDataType* p1 = (HPDataType*)realloc(php->a, sizeof(HPDataType)*newcapacity);
if (p1 == NULL)
perror("realloc fail");
return;
php->a = p1;
php->a[php->size] = x;
php->size++;
AdjustUp(php->a, php->size - 1);
（7）删除数据
void HeapPop(HP* php);
堆的元素删除一般都是删除堆顶的头节点。所以，我们首先将末位元素与首元素交换。然后，有效数据的个数减一，让堆不能管理那块空间。最后，将堆顶的元素换到想订的位置。
// 删除堆顶元素
void HeapPop(HP* php)
assert(php);
Swap(&php->a[0], &php->a[php->size - 1]);
php->size--;
AdjustDown(php->a, php->size, 0);
（8）返回堆顶元素
HPDataType HeapTop(HP* php);
直接返回数组第一个元素。
// 返回堆顶的元素
HPDataType HeapTop(HP* php)
assert(php);
return php->a[0];
（9）判断堆是否为空
bool HeapEmpty(HP* php);
看size为不为0
bool HeapEmpty(HP* php)
assert(php);
return php->size == 0;
（10）堆的大小
int HeapSize(HP* php);
返回size
int HeapSize(HP* php)
assert(php);
return php->size;
（11）堆的销毁
void HeapDestroy(HP* php);
老步骤，数据个数变零，释放空间，指针置空
void HeapDestroy(HP* php)
assert(php);
php->capacity = 0;
php->size = 0;
php->a = NULL;
free(php->a);
3.堆排序
堆排序是一个效率十分高的排序算法，它真的可以说吊打我们学过的冒泡排序，下面介绍一下堆排序的步骤：
（1）建立大堆
你可能会想，为什么不建小堆呢？小堆可以让数组更加有序。
其实不然，小堆确实可以确定头节点为最小值，数组也相对有序。但是，你无法找到次小元素，因为小堆只保证父节点小于子节点，但是你无法判断左右子节点数据的大小。所以，我们通过建立大堆就一定可以在头节点找到最大的元素。
（2）交换首尾元素并让堆的有效数据减一
大堆的头节点一定是最大的元素，那么我们交换最大的数据到最后，它也就在了它最终该在的位置。然后有效数据减一，让整个堆不再管辖最后的这个正确位置的数据。
（3）重新建堆
并不是把整个堆清空，而是将你交换到头节点的元素向下调整构成新的堆。
（4）重复上述步骤直到堆中不存在元素即可
整体思路就是删除数据的变形
（5）代码实现
void HeapSort(int* a, int n)
HP s;
HP* p = &s;
HeapInit(p);
int i = 0;
for (i = 0; i < n; i++)//通过一个一个插入数据来建堆
HeapPush(p, a[i]);
for (i = 0; i < p->size; i++)
Swap(&p->a[0], &p->a[p->size - 1 - i]);//交换首元素和尾元素
AdjustDown(p->a, p->size - i - 1, 0);//将首元素向下调整
for (i = 0; i < n; i++)//将堆数组中的所有数据传回给原数组
a[i] = p->a[i];
HeapDestroy(p);
四、链式二叉树的实现
1.链式二叉树的概念
类似于双向带头循环链表，二叉树每一个节点是由一个left指针，一个right指针还有一个有效数据组成的一个结构体。
其中左指针指向它左子树的头节点（子树可以为空），右指针指向它右子树的头节点，数据储存在有效数据内。这样一层一层地向下构建就形成了二叉树。
不管如何，我们先建立起下面这个树
//构建二叉树
BTNode* BinaryTreeCreate()
BTNode* n1 = (BTNode*)malloc(sizeof(BTNode));
BTNode* n2 = (BTNode*)malloc(sizeof(BTNode));
BTNode* n3 = (BTNode*)malloc(sizeof(BTNode));
BTNode* n4 = (BTNode*)malloc(sizeof(BTNode));
BTNode* n5 = (BTNode*)malloc(sizeof(BTNode));
BTNode* n6 = (BTNode*)malloc(sizeof(BTNode));
BTNode* n7 = (BTNode*)malloc(sizeof(BTNode));
n1->data = 1;
n2->data = 2;
n3->data = 3;
n4->data = 4;
n5->data = 5;
n6->data = 6;
n7->data = 7;
n1->left = n2;
n1->right = n4;
n2->left = n3;
n2->right = NULL;
n3->left = NULL;
n3->right = NULL;
n4->left = n5;
n4->right = n6;
n5->left = NULL;
n5->right = NULL;
n6->left = n7;
n6->right = NULL;
n7->left = NULL;
n7->right = NULL;
return n1;
2.前序遍历
前序遍历是指我们在访问一棵二叉树的时候先访问根节点数据，后访问左子树，最后访问右子树，当左右子树为空树的时候就返回前面的节点。
对于上面的二叉树，我们对它进行前序遍历
有些人可能已经学过了前序遍历，但是前对于空树的遍历那部分依旧模糊，我们可以通过遇到空树打印的方式更加熟悉前序遍历。
代码实现：
//二叉树前序遍历
void TreePrevOrder(BTNode* root)
//空树返回
if (root == NULL)
printf("NULL ");//可以注释掉，打印是为了更好理解前序遍历
return;
//根
printf("%d ", root->data);
//左子树
TreePrevOrder(root->left);
//右子树
TreePrevOrder(root->right);
3.中序遍历与后序遍历
所谓的前中后序遍历就是指访问节点数据的顺序在前在中还是在后，这三个遍历二叉树的方式都要使用递归。
根据前序遍历的思想可知，中序遍历会先遍历左子树，然后读取根节点，最后遍历右子树；后序遍历会先遍历左子树，然后遍历右子树，最后读取根节点。
所以对于上面的这个树而言，遍历的结果如下（控制遇到NULL也打印）：
前序遍历：1 2 3 NULL NULL NULL 4 5 NULL NULL 6 7 NULL NULL NULL
中序遍历：NULL 3 NULL 2 NULL 1 NULL 5 NULL 4 NULL 7 NULL 6 NULL
后序遍历：NULL NULL 3 NULL 2 NULL NULL 5 NULL NULL 7 NULL 6 4 1
代码实现：
//二叉树中序遍历
void TreeInOrder(BTNode* root)
//空树返回
if (root == NULL)
printf("NULL ");
return;
//左子树
TreeInOrder(root->left);
//根
printf("%d ", root->data);
//右子树
TreeInOrder(root->right);
//二叉树后序遍历
void TreePostOrder(BTNode* root)
//空树返回
if (root == NULL)
printf("NULL ");
return;
//左子树
TreePostOrder(root->left);
//右子树
TreePostOrder(root->right);
//根
printf("%d ", root->data);
4.层序遍历
层序遍历，顾名思义就是一层一层遍历元素，它是二叉树遍历中一种不需要递归的方式，它可以解决递归过深栈溢出的问题。
层序遍历需要用到栈，大致思路就是当我们遍历完根节点后先出栈该节点，然后入栈左子树和右子树的根节点，当左右子树为空树时就不再入栈。
打印完上一层的一个节点就入栈下面的两个节点，由于栈先入先出的特点，各个节点会逐个打印。这一层的所有节点打印完成或，下一层的节点也已经全部入栈，重复这样的步骤即可完成层序遍历。
//层序遍历
void TreeLevelOrder(BTNode* root)
queue pq;
queue* p = &pq;
initqueue(p);
if (root)
queuepush(p, root);
while (!QueueEmpty(p))
BTNode* front = queuefront(p);//另外保存一份地址
queuepop(p);//出队列的是该节点的地址的数据，原来二叉树的那个节点依旧存在
printf("%d ", front->data);//打印该节点
if (front->left)
queuepush(p, front->left);//入栈左节点
if (front->right)
queuepush(p, front->right);//入栈右节点
destory(p);
二叉树基础详解
目录
1.树的定义和基本性质
树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。有一个特殊的结点，称为根结点，根节点没有前驱结点除根节点外，其余结点被分成M(M>0)个互不相交的集合T1、T2、……、Tm，其中每一个集合Ti(1<= i <= m)又是一棵结构与树类似的子树。每棵子树的根结点有且只有一个前驱，可以有0个或多个后继因此，树是递归定义的。
它之所以叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。它具有以下的特点：
(1) 每个节点有零个或多个子节点；
(2) 没有父节点的节点称为根节点；
(3) 每一个非根节点有且只有一个父节点；
(4) 除了根节点外，每个子节点可以分为多个不相交的子树。(5)一颗N个节点的树有N-1条边
2.树的相关概念：
在这里解释一下什么是节点的度：
2.1节点的度：
结点拥有的子树数目称为结点的度
2.2节点的关系：
结点子树的根结点为该结点的孩子结点。相应该结点称为孩子结点的双亲结点。
图2.2中，A为B的双亲结点，B为A的孩子结点。
同一个双亲结点的孩子结点之间互称兄弟结点。
图2.2中，结点B与结点C互为兄弟结点。
2.3：节点层次：
从根开始定义起，根为第一层，根的孩子为第二层，以此类推
3.树的表示：
树结构相对线性表就比较复杂了，要存储表示起来就比较麻烦了，既然保存值域，也要保存结点和结点之间的关系，实际中树有很多种表示方式如：双亲表示法，孩子表示法、孩子双亲表示法以及孩子兄弟表示法等。我们这里就简单的了解其中最常用的孩子兄弟表示法。
typedef int DataType;
struct Node
struct Node* _firstChild1;
// 第一个孩子结点
struct Node* _pNextBrother; // 指向其下一个兄弟结点
DataType _data;
// 结点中的数据域
；
树在实际中的应用：
二叉树概念及结构（重点）
二叉树是n(n>=0)个节点的有限集合，该集合或者为空集（称为空二叉树），或者由一个根节点和两棵互不相交的、分别称为根节点的左子树和右子树组
从图上不难看出：
由二叉树定义以及图示分析得出二叉树有以下特点：
1）每个结点最多有两颗子树，所以二叉树中不存在度大于2的结点。
2）左子树和右子树是有顺序的，次序不能任意颠倒。
3）即使树中某结点只有一棵子树，也要区分它是左子树还是右子树
二叉树的性质：
1）在二叉树的第i层上最多有2i-1 个节点 。（i>=1）
2）二叉树中如果深度为k,那么最多有2k-1个节点。(k>=1）
3）n0=n2+1 n0表示度数为0的节点数，n2表示度数为2的节点数。
4）在完全二叉树中，具有n个节点的完全二叉树的深度为[log2n]+1，其中[log2n]是向下取整。
5）若对含 n 个结点的完全二叉树从上到下且从左至右进行 1 至 n 的编号，则对完全二叉树中任意一个编号为 i 的结点有如下特性：(1) 若 i=1，则该结点是二叉树的根，无双亲, 否则，编号为 [i/2] 的结点为其双亲结点;
(2) 若 2i>n，则该结点无左孩子， 否则，编号为 2i 的结点为其左孩子结点；
(3) 若 2i+1>n，则该结点无右孩子结点， 否则，编号为2i+1 的结点为其右孩子结点。
3.斜树
所有的结点都只有左子树的二叉树叫左斜树。所有结点都是只有右子树的二叉树叫右斜树。这两者统称为斜树。
左斜树
右斜树
4满二叉树：
在一棵二叉树中。如果所有分支结点都存在左子树和右子树，并且所有叶子都在同一层上，这样的二叉树称为满二叉树。
满二叉树的特点有：
1）叶子只能出现在最下一层。出现在其它层就不可能达成平衡。
2）非叶子结点的度一定是2。
3）在同样深度的二叉树中，满二叉树的结点个数最多，叶子数最多
5.完全二叉树
1.对一颗具有n个结点的二叉树按层编号，如果编号为i(1<=i<=n)的结点与同样深度的满二叉树中编号为i的结点在二叉树中位置完全相同，则这棵二叉树称为完全二叉树。
2. 完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树而引出来的。对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树。 要注意的是满二叉树是一种特殊的完全二叉树。
完全二叉树的特点：
1）叶子结点只能出现在最下层和次下层。
2）最下层的叶子结点集中在树的左部。
3）倒数第二层若存在叶子结点，一定在右部连续位置。
4）如果结点度为1，则该结点只有左孩子，即没有右子树。
5）同样结点数目的二叉树，完全二叉树深度最小
6.二叉搜索树：
6.1
二叉搜索树又称二叉查找树，亦称为二叉排序树。设x为二叉查找树中的一个节点，x节点包含关键字key，节点x的key值记为key[x]。如果y是x的左子树中的一个节点，则key[y] <= key[x]；如果y是x的右子树的一个节点，则key[y] >= key[x]。
6.2性质：
（1）若左子树不空，则左子树上所有节点的值均小于它的根节点的值；
（2）若右子树不空，则右子树上所有节点的值均大于它的根节点的值；
（3）左、右子树也分别为二叉搜索树；
（具体内容后面会写专门的博客介绍）
平衡二叉树：
简称平衡二叉树。由前苏联的数学家 Adelse-Velskil 和 Landis 在 1962 年提出的高度平衡的二叉树，根据科学家的英文名也称为 AVL 树。它具有如下几个性质：
- 可以是空树。
- 假如不是空树，任何一个结点的左子树与右子树都是平衡二叉树，并且高度之差的绝对值不超过 1。
平衡之意，如天平，即两边的分量大约相同。
二叉树的存储结构
二叉树一般可以使用两种结构存储，一种顺序结构，一种链式结构。1. 顺序存储顺序结构存储就是使用数组来存储，一般使用数组只适合表示完全二叉树，因为不是完全二叉树会有空间的浪费。而现实中使用中只有堆才会使用数组来存储，关于堆我们后面的章节会专门讲解。二叉树顺序存储在物理上是一个数组，在逻辑上是一颗二叉树。
从图中我们可以看出
当二叉树为完全二叉树时，结点数刚好填满数组。
那么当二叉树不为完全二叉树时，采用顺序存储形式如何呢？
那么对应顺序存储形式将会是这样的：
二叉树的链式存储：
叉树的链式存储结构是指，用链表来表示一棵二叉树，即用链来指示元素的逻辑关系。 通常的方法是链表中每个结点由三个域组成，数据域和左右指针域，左右指针分别用来给出该结点左孩子和右孩子所在的链结点的存储地址
定义节点的代码：
typedef int BTDataType
struct BinaryTreeNode
struct BinTreeNode* _pLeft; // 指向当前节点左孩子
struct BinTreeNode* _pRight; // 指向当前节点右孩子
BTDataType _data; // 当前节点值域
;
那么上面的那个图就可以表示成这样
二叉树的遍历
二叉树遍历是指从二叉树的根结点出发，按照某种次序依次访问二叉树中的所有结点，使得每个结点被访问一次，且仅被访问一次。
二叉树的访问次序可以分为四种：
前序遍历
中序遍历
后序遍历
层序遍历
1.前序遍历
前序遍历通俗的说就是从二叉树的根结点出发，当第一次到达结点时就输出结点数据，按照先访问左子树在访问右子树的顺序
上图所示二叉树前序遍历如下：
从根结点出发，则第一次到达结点A，故输出A;
继续向左访问，第一次访问结点B，故输出B；
按照同样规则，输出D，输出H；
当到达叶子结点H，返回到D，此时已经是第二次到达D，故不在输出D，进而向D右子树访问，D右子树不为空，则访问至I，第一次到达I，则输出I；
I为叶子结点，则返回到D，D左右子树已经访问完毕，则返回到B，进而到B右子树，第一次到达E，故输出E；
向E左子树，E的左树为空返回到E进而访问E的右树J输出G
按照同样的访问规则，继续输出C、F K、G；故上图所示树的前序遍历为： 所示二叉树的前序遍历输出为：
ABDHIEJCFKG
2.中序遍历
就是从二叉树的根结点出发，当第二次到达结点时就输出结点数据，按照先访问左子树在访问右子树的顺序访问
上图所示的二叉树的访问顺序如下：
从根结点出发，则第一次到达结点A，不输出A，继续向左访问，第一次访问结点B，不输出B；继续到达D，H；
到达H，H左子树为空，则返回到H，此时第二次访问H，故输出H；
H右子树为空，则返回至D，此时第二次到达D，故输出D，在访问D的右树I，I的右树为空，返回到 I，此时第二次到达I 故输出I；
由D返回至B，第二次到达B，故输出B；
按照同样规则继续访问，输出E J、A、F，K、C、G
3.后序遍历：
上图所示树的后序遍历如下：
从根结点出发，则第一次到达结点A，不输出A，继续向左访问，第一次访问结点B，不输出B；继续到达D，H；
到达H，H左子树为空，则返回到H，此时第二次访问H，不输出H；
H右子树为空，则返回至H，此时第三次到达H，故输出H；
由H返回至D，第二次到达D，不输出D；
继续访问至I，I左右子树均为空，故第三次访问I时，输出I；
返回至D，此时第三次到达D，故输出D；
按照同样规则继续访问，输出J、E、B、K ，F、G、C，A；故上述遍历的结果为：HIDJEBKFGCA
4.上述图对应代码：
4.1前序遍历：
void PrevOrder(TreeNode* root) if (!root)return;//root走到空了就返回 cout << root->val << "";//访问当前节点 PrevOrder(root->_left);//访问左子树 PrevOrder(root->_right);访问右子树
4.2中序遍历：
void InOrder(TreeNode* root) if (!root)return;//root走到空了就返回 InOrder(root->_left);//访问左子树 cout << root->val << " ";//访问根 InOrder(root->_right);//访问右子树
4.3后序遍历：
void PostOrder(TreeNode* root) if (!root)return; PostOrder(root->_left);//访问左子树 PostOrder(root->_right);//访问右子树 cout << root->val << " ";//访问根
对应总代码：
#include<iostream>
using namespace std;
struct TreeNode
TreeNode(int val=0)
:_left(nullptr)
,_right(nullptr)
,val(val)
TreeNode* _left;
TreeNode* _right;
char val;
;
//前序遍历
void PrevOrder(TreeNode* root)
if (!root)return;//root走到空了就返回
cout << root->val << " ";
PrevOrder(root->_left);
PrevOrder(root->_right);
//中序遍历
void InOrder(TreeNode* root)
if (!root)return;//root走到空了就返回
InOrder(root->_left);//访问左子树
cout << root->val << " ";//访问根
InOrder(root->_right);//访问右子树
//后序遍历
void PostOrder(TreeNode* root)
if (!root)return;
PostOrder(root->_left);//访问左子树
PostOrder(root->_right);//访问右子树
cout << root->val << " ";//访问根
int main()
TreeNode* A = new TreeNode('A');
TreeNode* B= new TreeNode('B');
TreeNode* C = new TreeNode('C');
TreeNode* D = new TreeNode('D');
TreeNode* E = new TreeNode('E');
TreeNode* F = new TreeNode('F');
TreeNode* G = new TreeNode('G');
TreeNode* H = new TreeNode('H');
TreeNode* J = new TreeNode('j');
TreeNode* I = new TreeNode('I');
TreeNode* K = new TreeNode('k');
A->_left = B;
A->_right = C;
B->_left = D;
B->_right = E;
D->_left = H;
D->_right = I;
E->_right = J;
C->_left = F;
C->_right = G;
F->_right = K;
PrevOrder(A);
cout << endl;
InOrder(A);
cout << endl;
PostOrder(A);
return 0;
5.二叉树的层序遍历：
层次遍历就是按照树的层次自上而下的遍历二叉树。针对上图所示二叉树的层次遍历结果为：ABCDEFGHIJK
二叉树分好多层，因为要按层遍历，所以如果直接采用函数递归的话，一下子就深入层底了，达不到按层的目的。
所以在这里我们按照队列顺序输出！
实现思路：
在这里我们换一颗比较简单 的树来讲思路：
步骤如下
1、把根节点A放入队列中，此时队列为：A，队列头指针指向A，也就是队列第一个元素
2.访问当前队列队头指针所指的数据，并将其从队列中弹出，如果当前队列指针所指向的左孩子不为空，将其访入队列中，否则不放入队列中。如果当前队列指针所指向右孩子不为空，将其放入队列中，否则不放入队列中
3. 不断重复2步骤将B的右孩子和C的左孩子放入队列中
4.结束条件当队列为空说明已经访问完了，此时我们可以结束循环了
废话不多少我们来看代码：
void TreeLevelOrder(TreeNode* root) queue<TreeNode*>q;//定义队列 if (root) q.push(root);//如果这颗树一个节点也没有就没有必要入 while (!q.empty()) //队列不为空则继续入 TreeNode* top = q.front(); //取队头的数据 q.pop();//将其从队列中弹出 cout << top->val << " ";//访问当前节点的数据 if (top->_left) //如果单前节点的左孩子不为空就将左孩子放到队列中 q.push(top->_left); if (top->_right) //如果当前队列的右孩子不为空，就将其放入队列中 q.push(top->_right);
对应总代码：
#include<iostream> #include<queue> using namespace std; struct TreeNode //创建节点 TreeNode(int val=0) :_left(nullptr) ,_right(nullptr) ,val(val) TreeNode* _left; TreeNode* _right; char val; ; void PrevOrder(TreeNode* root) if (!root)return;//root走到空了就返回 cout << root->val << " "; PrevOrder(root->_left); PrevOrder(root->_right); void InOrder(TreeNode* root) if (!root)return;//root走到空了就返回 InOrder(root->_left);//访问左子树 cout << root->val << " ";//访问根 InOrder(root->_right);//访问右子树 void PostOrder(TreeNode* root) if (!root)return; PostOrder(root->_left);//访问左子树 PostOrder(root->_right);//访问右子树 cout << root->val << " ";//访问根 void TreeLevelOrder(TreeNode* root) queue<TreeNode*>q;//定义队列 if (root) q.push(root);//如果这颗树一个节点也没有就没有必要入 while (!q.empty()) //队列不为空则继续入 TreeNode* top = q.front(); //取队头的数据 q.pop();//将其从队列中弹出 cout << top->val << " ";//访问当前节点的数据 if (top->_left) //如果单前节点的左孩子不为空就将左孩子放到队列中 q.push(top->_left); if (top->_right) //如果当前队列的右孩子不为空，就将其放入队列中 q.push(top->_right); int main() TreeNode* A = new TreeNode('A'); TreeNode* B = new TreeNode('B'); TreeNode* C = new TreeNode('C'); TreeNode* D = new TreeNode('D'); TreeNode* E= new TreeNode('E'); A->_left = B; A->_right = C; B->_right = D; C->_left = E; TreeLevelOrder(A); return 0;
运行结果：
遍历常考考点：
）已知前序遍历序列和中序遍历序列，确定一棵二叉树。
例题：若一棵二叉树的前序遍历为ABCDEF，中序遍历为CBAEDF，请画出这棵二叉树。
分析：前序遍历第一个输出结点为根结点，故A为根结点。早中序遍历中根结点处于左右子树结点中间，故结点A的左子树中结点有CB，右子树中结点有EDF。
照同样的分析方法，对A的左右子树进行划分，最后得出二叉树的形态
已知后序遍历序列和中序遍历序列，确定一棵二叉树。
后序遍历中最后访问的为根结点，因此可以按照上述同样的方法，找到根结点后分成两棵子树，进而继续找到子树的根结点，一步步确定二叉树的形态。
注意：已知前序遍历序列和后序遍历序列，不可以唯一确定一棵二叉树，应为它无法区分左右子树。
二叉树节点的个数：
实现思路：
根据递归函数实现，如果树不为空，根节点为1
1 统计根节点左子树节点的个数
2 统计根节点右子树节点的个数
3 将左子树节点个数+右子树节点个数+根节点个数（1）即为整颗树的节点个数
4 统计左右子树的节点个数也是按照1~3的步骤进行
5 当树为空时，根节点的个数为0，即为递归函数的出口。
也就是整颗树节点的个数=左子树节点的个数+右子树节点的个数+根节点（也就是1）
代码实现：
size_t TreeSize(TreeNode* root) if (!root)return 0;//走到空树，空树的节点个数为0； return TreeSize(root->_left) + TreeSize(root->_right) + 1;// //总节点的个数等于左子树节点的个数+右子树节点的个树+根节点的个数+1（也就是根节点）
这个代码到底对不对了我们可以去OJ上去测试一下：
https://leetcode-cn.com/problems/count-complete-tree-nodes/
图片可能看不清大家可以复制链接去letecode里面看
对应代码：
class Solution public: int countNodes(TreeNode* root) if(root==nullptr) return 0; return countNodes(root->left)+countNodes(root->right)+1; ;
二叉树叶子节点的个数：
实现思路：
1. 如果给定节点T为NULL，则是空树，叶子节点为0，返回0；
2. 如果给定节点T左、右子树均为NULL，则是叶子节点，且叶子节点数为1，返回1；
3. 如果给定节点p左、右子树不都为NULL，则不是叶子节点，以p为根节点的子树叶子节点数 = p左子树叶子节点数 + p右子树叶子节点数；树中的叶子节点的个数 = 左子树中叶子节点的个数 + 右子树中叶子节点的个数。
利用递归代码实现，简单，易懂。
代码实现：
size_t TreeLeafSize(TreeNode* root) if (!root)return 0;//空树则它的叶子节点的个数为0； if (!root->_left && !root->_right)return 1; //如果它的左为空并且右为空那么它一定就是叶子节点 return TreeLeafSize(root->_left) + TreeLeafSize(root->_right); //整颗树叶子节点的个数等于对应左子树叶子节点的个数+对应右子树节点的个数
求二叉树第k层有多少个节点（k>1)：
实现思路：
假设根节点是第一层：
1.第k层节点的个数等价于求以根节点的左孩子为根的k-1层节点的个数+以根节点的右孩子为根的k-1层的节点的个数
2.把k作为计数器通过参数递归传递，递归的过程中不断减1
3.递归终止条件：如果走到空了说明该条路径深度小于k则返回0，如果K==1了则返回1
对应代码实现：
size_t TreeKLeveSize(TreeNode* root,int k) if (!root||k<1)return 0;//空树返回0；防止k不合法 if (k == 1)return 1; return TreeKLeveSize(root->_left, k - 1) + TreeKLeveSize(root->_right, k - 1);
拓展求第k层叶子节点的个数
思路上面叉不多之间看代码吧：
int GetTreeKthLevelLeafSize(TreeNode* root,int k) if (!root || k < 0)return 0;//空树则返回0； if (k == 1) if (!root->_left && !root->_right)//判断是否为叶子节点 return 1; else return 0; return GetTreeKthLevelLeafSize(root->_left,k-1) + GetTreeKthLevelLeafSize(root->_right,k-1);
二叉树中查找值为x的节点：
实现思路：
1:单边递归查找。
2：先对左子树递归查找。如果未找到x,则返回NULL,如果找到x，便返回x所在节点。3：根据返回值判断是否需要进行右递归查找操作
代码实现：
TreeNode* TreeFind(TreeNode* root, int x) if (!root)return nullptr; if (root->val == x)return root;//判断当前树是不是，如果是则返回 TreeNode* leftRet = TreeFind(root->_left,x);//去root的左子树找 if(leftRet) return leftRet;//找到了则返回 TreeNode* rightRet = TreeFind(root->_right); if (rightRet) return rightRet; return nullptr;//对应左子树和右子树都没有找到
二叉树的销毁
由于比较简单在这里就不赘述了：
void TreeDestroy(TreeNode* root) if (!root)return; TreeDestroy(root->_left); TreeDestroy(root->_right); delete root;
判断一颗二叉树是否为完全二叉树：
什么是完全二叉树了在上面已经说过了：
完全二叉树也就是没有满的满二叉树，它的节点在每一层一定是连续分布的。如果出现哪一层中两个非空节点间隔一个空节点，那一定不是完全二叉树。如下图所示：
完全二叉树的一些规律：
有了这我们就可以写代码了：
思路：
1.判断是否为完全二叉 树的关键是找到不饱和节点
2.完全二叉树每一层非空节点都是一个接一个连续分布的不可能出现两个非空节点之间出现空节点。
3.通过层序遍历来遍历树中的每一个结点
4.采取特殊结点值为 NULL替代 NULL结点，5入队列的标记方法每一个结点分为两种情况：
5.1.如果当前结点不为空，直接将当前结点入队列
5.2.如果当前结点为空，将结点值为 null 的标记结点入队列
6当出队列的结点的值为标记结点 null 时，终止循环
7.接着循环队列，条件为队列不为空，进行出队列操作，
8.当出现队列出的结点的值不为 null 时，返回 false如果循环结束，返回 true，说明是一个完全二叉树
对应代码实现：
bool isTreeComplete(TreeNode* root) queue<TreeNode*>q; if (root)q.push(root); while (!q.empty()) TreeNode* top = q.front(); q.pop(); if (top == nullptr)break;//出到空跳出循环 q.push(top->_left); q.push(top->_right); while (!q.empty()) auto top = q.front(); q.pop(); if (top)return false;//有不为空的则不是完全二叉树 return true;
非递归实现二叉树的（前中后序遍历重点）
首先，有一点是明确的：非递归写法一定会用到栈，这个应该不用太多的解释。我们先看前序遍历：
1. 前序遍历的递归定义：先根节点，后左子树，再右子树。如何写非递归代码呢？一句话：让代码跟着思维走：
2.假设你面前有一棵二叉树，现要求你写出它的前序遍历序列，如果你对前序遍历很熟悉的话你一定是先访问根节点在访问左子树其实是右子树，遍历完根之后我就要遍历左子树一直遍历到左子树的最下边的节点所以这段代码是理所当然的
stack<TreeNode*>stk;
TreeNode* cur = root;
while (cur)
q.push(root);
cout << root->val << " ";
cur = cur->_left;
一路保存根节点的原因是：遍历完左子树后，需要借助根节点进入右子树。
大致思路如下：
首先我们应该创建一个stack用来存放节点，首先我们想要打印根节点的数据，此时Stack里面的内容为空，所以我们优先将头结点加入stack，然后打印。
之后我们应该先打印左子树，然后右子树。所以先加入stack的就是右子树，然后左子树。
步鄹：
前序遍历：①首先访问根节点是否为空，则入栈→输出栈顶元素→当前节点的左子树入栈
②当左子树为空，则栈顶元素出栈，转向该节点的右子树
③全部元素出栈以后，结束循环
图解：
代码实现：
class Solution
public:
vector<int> preorderTraversal(TreeNode* root)
vector<int>res;
stack<TreeNode*>st;
TreeNode*cur=root;
while(!st.empty()||cur)
while(cur)
res.push_back(cur->val);
st.push(cur);
cur=cur->left;
TreeNode*top=st.top();
st.pop();
cur=top->right;
return res;
;对应letecode链接：
中序遍历：
二叉树的前序，中序非递归遍历的唯一不同是出栈的时间
中序遍历：①入栈→当前节点的左子树入栈
②当左子树为空，则栈顶元素出栈，输出栈顶元素→转向该节点的右子树
③栈为空时，结束循环
对应动图：
代码实现：
class Solution
public:
vector<int> inorderTraversal(TreeNode* root)
vector<int>res;
stack<TreeNode*>st;
TreeNode*cur=root;
while(cur||!st.empty())
while(cur)
st.push(cur);
cur=cur->left;
TreeNode*top=st.top();
st.pop();
res.push_back(top->val);
cur=top->right;
return res;
;对应letecode链接：
后序遍历：
表的后序非递归遍历:cur指向当前的节点，lastnode指向前一个节点
①根节点入栈，如果栈不为空，则判断栈顶元素节点的左右节点是否为空，同时判断
前一个节点是否是当前节点的左孩子或者右孩子
②如果①为真，则输出当前节点且栈顶元素出栈，同时令cur等于当前节点
③如果①为假，则当前节点的孩子节点入栈
④当栈为空时，退出循环
对应图：
对应代码：
class Solution
public:
vector<int> postorderTraversal(TreeNode* root)
vector<int>res;
stack<TreeNode*>st;
TreeNode*cur=root;
TreeNode*lastNode=nullptr;//最近访问的节点
while(!st.empty()||cur)
while(cur)
st.push(cur);
cur=cur->left;
TreeNode*top=st.top();
if(top->right==nullptr||lastNode==top->right)
res.push_back(top->val);
lastNode=top;
st.pop();
else
cur=top->right;
return res;
;对应letecode链接：
上述代码汇总：
#include<iostream> #include<stack> #include<queue> using namespace std; struct TreeNode TreeNode(int val=0) :_left(nullptr) ,_right(nullptr) ,val(val) TreeNode* _left; TreeNode* _right; char val; ; void PrevOrder(TreeNode* root) if (!root)return;//root走到空了就返回 cout << root->val << " "; PrevOrder(root->_left); PrevOrder(root->_right); void InOrder(TreeNode* root) if (!root)return;//root走到空了就返回 InOrder(root->_left);//访问左子树 cout << root->val << " ";//访问根 InOrder(root->_right);//访问右子树 void PostOrder(TreeNode* root) if (!root)return; PostOrder(root->_left);//访问左子树 PostOrder(root->_right);//访问右子树 cout << root->val << " ";//访问根 void TreeLevelOrder(TreeNode* root) queue<TreeNode*>q;//定义队列 if (root) q.push(root);//如果这颗树一个节点也没有就没有必要入 while (!q.empty()) //队列不为空则继续入 TreeNode* top = q.front(); //取队头的数据 q.pop();//将其从队列中弹出 cout << top->val << " ";//访问当前节点的数据 if (top->_left) //如果单前节点的左孩子不为空就将左孩子放到队列中 q.push(top->_left); if (top->_right) //如果当前队列的右孩子不为空，就将其放入队列中 q.push(top->_right); size_t TreeSize(TreeNode* root) if (!root)return 0;//走到空树，空树的节点个数为0； return TreeSize(root->_left) + TreeSize(root->_right) + 1;// //总节点的个数等于左子树节点的个数+右子树节点的个树+根节点的个数+1（也就是根节点） size_t TreeLeafSize(TreeNode* root) if (!root)return 0;//空树则它的叶子节点的个数为0； if (!root->_left && !root->_right)return 1;//如果它的左为空并且右为空那么它一定就是叶子节点 return TreeLeafSize(root->_left) + TreeLeafSize(root->_right); //整颗树叶子节点的个数等于对应左子树叶子节点的个数+对应右子树节点的个数 size_t TreeKLeveSize(TreeNode* root,int k) if (!root||k<1)return 0;//空树返回0；防止k不合法 if (k == 1)return 1; return TreeKLeveSize(root->_left, k - 1) + TreeKLeveSize(root->_right, k - 1); TreeNode* TreeFind(TreeNode* root, int x) if (!root)return nullptr; if (root->val == x)return root;//判断当前树是不是，如果是则返回 TreeNode* leftRet = TreeFind(root->_left,x);//去root的左子树找 if(leftRet) return leftRet;//找到了则返回 TreeNode* rightRet = TreeFind(root->_right); if (rightRet) return rightRet; return nullptr;//对应左子树和右子树都没有找到 void TreeDestroy(TreeNode* root) if (!root)return; TreeDestroy(root->_left); TreeDestroy(root->_right); delete root; bool isTreeComplete(TreeNode* root) queue<TreeNode*>q; if (root)q.push(root); while (!q.empty()) TreeNode* top = q.front(); q.pop(); if (top == nullptr)break;//出到空跳出循环 q.push(top->_left); q.push(top->_right); while (!q.empty()) auto top = q.front(); q.pop(); if (top)return false;//有不为空的则不是完全二叉树 return true; int GetTreeKthLevelLeafSize(TreeNode* root,int k) if (!root || k < 0)return 0;//空树则返回0； if (k == 1) if (!root->_left && !root->_right)//判断是否为叶子节点 return 1; else return 0; return GetTreeKthLevelLeafSize(root->_left,k-1) + GetTreeKthLevelLeafSize(root->_right,k-1); int main() TreeNode* A = new TreeNode('A'); TreeNode* B = new TreeNode('B'); TreeNode* C = new TreeNode('C'); TreeNode* D = new TreeNode('D'); TreeNode* E= new TreeNode('E'); A->_left = B; A->_right = C; B->_right = D; C->_left = E; TreeLevelOrder(A); return 0;
总结：
在非递归版本中的几个要点：
①、我们需要理解三种遍历方法的思想（以跟节点为基准）；
②、所有的节点都可看做是父节点(叶子节点可看做是两个孩子为空的父节点)；
③ 、利用堆栈来保存中间值，来实现非递归版本。
如果觉得写的不错的话可以点个赞！如果有错误请在评论区留言谢谢！
以上是关于二叉树详解的主要内容，如果未能解决你的问题，请参考以下文章