10*：二叉树初探：（定义、二叉树、二叉树的4种遍历方法）（二叉数顺序存储、二叉数链式存储）
问题
目录
1：树（定义、二叉树、二叉树的4种遍历方法）
2：二叉数顺序存储
3：二叉数链式存储
预备
正文
一：树
树是数据结构中的重中之重，尤其以各类二叉树为学习的难点。
1：定义
树（Tree）是n（n>=0)个结点的有限集。n=0时称为空树。在任意一颗非空树中：
1）有且仅有一个特定的称为根（Root）的结点；
2）当n>1时，其余结点可分为m(m>0)个互不相交的有限集T1、T2、......、Tn，其中每一个集合本身又是一棵树，并且称为根的子树。
此外，树的定义还需要强调以下两点：
1）n>0时根结点是唯一的，不可能存在多个根结点，数据结构中的树只能有一个根结点。
2）m>0时，子树的个数没有限制，但它们一定是互不相交的。
示例树：
下图为一棵普通的树：
-
结点：树中的一个独立单元。包含一个数据元素及若干指向其他子树的分支。例如，A, B, C, D 等都是结点.
-
结点的度：结点拥有的子树数量称谓结点的度，例如 A 的度是 3, C 的度为 1, D 的度为 3, F 的度为 0
-
树的度：数的度是树内各结点度的最大值，例如，上图中的应该是 3
-
叶子：度为 0 的结点称谓叶子或终端结点，例如，K, J, F, G, M,I,J 都是树的叶子
-
非终端结点：度不为 0 的结点称为非终端结点或分支结点。除了根结点以外，非终端结点也称为内部结点
-
双亲和孩子：结点的子树的根称为该结点的孩子，相应地，该结点称为孩子的双亲，例如，B 的双亲为 A, B的孩子有 E 和 F
-
兄弟：同一个双亲的孩子之间称为兄弟结点，例如 H，I 和 J 互为兄弟
-
祖先：从根到该结点所经历的分支上的所有结点，例如，M 的祖先为 A, D, H。
-
子孙：以某结点为根的子树中的任一结点都称为该结点的子孙。例如，B 的子孙为 E, F
-
层次：结点的层次从根开始定义起，根为第一层，根的孩子为第二层。树中任一层次等于双亲结点的层次加 1
-
堂兄弟：双亲在同一层的节点互为堂兄弟。例如，结点 G 与 E, F, H,I, J 互为堂兄弟。
-
有序树和无序树：如果将树的结点的各子树看成从左到右是有次序的（即不能互换）则称为该树为有序树；否则是无序树，在有序树中最左边的子树的根称为第一个孩子，最右边的称为最后一个孩子。什么叫有序树，就类似在家语中第一房太太，到第五房太太以及孩子是有顺序的。这样存在顺序关系叫有序树
-
节点的高度：节点到叶子节点的最长路径（边数）
-
节点的深度：根结点到这个结点所经历的边的个数
-
节点的层数：节点的深度-1
-
树的高度：根结点的高度
2：二叉树
1：定义
二叉树是n(n>=0)个结点的有限集合，该集合或者为空集（称为空二叉树），或者由一个根结点和两棵互不相交的、分别称为根结点的左子树和右子树组成。
下图展示了一棵普通二叉树：
2：二叉树特点
由二叉树定义以及图示分析得出二叉树有以下特点：
1）每个结点最多有两颗子树，所以二叉树中不存在度大于2的结点。
2）左子树和右子树是有顺序的，次序不能任意颠倒。
3）即使树中某结点只有一棵子树，也要区分它是左子树还是右子树。
4）叶子结点：度为0的结点
3：二叉树性质
1）在二叉树的第i层上最多有-1 个节点 。（i>=1）
2）二叉树中如果深度为k,那么最多有-1个节点。(k>=1）
3）n0=n2+1 n0表示度数为0的节点数，n2表示度数为2的节点数。
上图中GFHI是度数为0的结点，ABD是度数为2的节点。
4）在完全二叉树中，具有n个节点的完全二叉树的深度为[log2n]+1，其中[log2n]是向下取整。
5）若对含 n 个结点的完全二叉树从上到下且从左至右进行 1 至 n 的编号，则对完全二叉树中任意一个编号为 i 的结点有如下特性：
A.如果i>1，那么序号为i的结点的双亲结点序号为i/2;
B.如果i=1，那么序号为i的结点为根节点，无双亲结点;
C.如果2i<=n，那么序号为i的结点的左孩子结点序号为2i;
D.如果2i>n，那么序号为i的结点无左孩子;
E.如果2i+1<=n，那么序号为i的结点右孩子序号为2i+1;
F.如果2i+1>n，那么序号为i的结点无右孩子。
4：斜树
斜树：所有的结点都只有左子树的二叉树叫左斜树。所有结点都是只有右子树的二叉树叫右斜树。这两者统称为斜树。
5：满二叉树
满二叉树：在一棵二叉树中。如果所有分支结点都存在左子树和右子树，并且所有叶子都在同一层上，这样的二叉树称为满二叉树。
满二叉树的特点有：
1）叶子只能出现在最下一层。出现在其它层就不可能达成平衡。
2）非叶子结点的度一定是2。
3）在同样深度的二叉树中，满二叉树的结点个数最多，叶子数最多
如果二叉树中除了叶子结点，每个结点的度都为 2，则此二叉树称为满二叉树。
满二叉树除了满足普通二叉树的性质，还具有以下性质：
- 1.满二叉树中第 i 层的节点数为 2i-1个。
- 2.深度为 k 的满二叉树必有 2k-1 个节点 ，叶子数为 2k-1。
- 3.满二叉树中不存在度为 1 的节点，每一个分支点中都两棵深度相同的子树，且叶子节点都在最底层。
- 4.具有 n 个节点的满二叉树的深度为 log2(n+1)。
6：完全二叉树
完全二叉树：对一颗具有n个结点的二叉树按层编号，如果编号为i(1<=i<=n)的结点与同样深度的满二叉树中编号为i的结点在二叉树中位置完全相同，则这棵二叉树称为完全二叉树。
图展示一棵完全二叉树
1）叶子结点只能出现在最下层和次下层。
2）最下层的叶子结点集中在树的左部。
3）倒数第二层若存在叶子结点，一定在右部连续位置。
4）如果结点度为1，则该结点只有左孩子，即没有右子树。
5）同样结点数目的二叉树，完全二叉树深度最小。
注：满二叉树一定是完全二叉树，但反过来不一定成立。
如果二叉树中除去最后一层节点为满二叉树，且最后一层的结点依次从左到右分布，则此二叉树被称为完全二叉树。
完全二叉树除了具有普通二叉树的性质，它自身也具有一些独特的性质，比如说，n 个结点的完全二叉树的深度为 ⌊log2n⌋+1。
⌊log2n⌋ 表示取小于 log2n 的最大整数。例如，⌊log24⌋ = 2，而 ⌊log25⌋ 结果也是 2。
对于任意一个完全二叉树来说，如果将含有的结点按照从上至下和从左至右的顺序从1开始编号，对于任意一个结点 i ，完全二叉树还有以下几个结论成立：
- 1.当 i>1 时，父亲结点为结点 [i/2] 。（i=1 时，表示的是根结点，无父亲结点）
- 2.如果 2*i>n（总结点的个数） ，则结点 i 肯定没有左孩子（为叶子结点）；否则其左孩子是结点 2*i 。
- 3.如果 2*i+1>n ，则结点 i 肯定没有右孩子；否则右孩子是结点 2*i+1 。
3：二叉树的4种遍历方法（根据根节点的遍历顺序命名）
1：前序遍历（先序遍历）（根左右）
二：二叉数顺序存储
二叉树的顺序存储结构就是使用一维数组存储二叉树中的结点，并且结点的存储位置，就是数组的下标索引。
那么当二叉树不为完全二叉树时，采用顺序存储形式如何呢？
因此，顺序存储一般适用于完全二叉树。
1：定义结点：
#define MAXSIZE 100 /* 存储空间初始分配量 */ #define MAX_TREE_SIZE 100 /* 二叉树的最大结点数 */ typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 */ typedef int CElemType; /* 树结点的数据类型，目前暂定为整型 */ typedef CElemType SqBiTree[MAX_TREE_SIZE]; /* 0号单元存储根结点 */ CElemType Nil = 0; /*设整型以0为空 或者以 INT_MAX(65535)*/ typedef struct { int level; //结点层 int order; //本层的序号(按照满二叉树给定序号规则) }Position;
2：基本操作
#pragma mark -- 二叉树的基本操作 //6.1 visit Status visit(CElemType c){ printf("%d ",c); return OK; } //6.2 构造空二叉树T,因为T是固定数组,不会改变. Status InitBiTree(SqBiTree T){ for (int i = 0; i < MAX_TREE_SIZE; i++) { //将二叉树初始化值置空 T[i] = Nil; } return OK; } //6.3 按层序次序输入二叉树中的结点值(字符型或整型),构造顺序存储的二叉树T Status CreateBiTree(SqBiTree T){ int i = 0; //printf("按层序输入结点的值(整型),0表示空结点, 输入999结束.结点数<=%d\n",MAX_TREE_SIZE); /* 1 -->1 2 3 -->2 4 5 6 7 -->3 8 9 10 -->4 1 2 3 4 5 6 7 8 9 10 Nil Nil Nil */ while (i < 10) { T[i] = i+1; printf("%d ",T[i]); //结点不为空,且无双亲结点 if (i != 0 && T[(i+1)/2-1] == Nil && T[i] != Nil) { printf("出现无双亲的非根结点%d\n",T[i]); exit(ERROR); } i++; } //将空赋值给T的后面的结点 while (i < MAX_TREE_SIZE) { T[i] = Nil; i++; } return OK; } //技巧: //如果大家想要2个函数的结果一样,但是目的不同; //在顺序存储结构中, 两个函数完全一样的结果 #define ClearBiTree InitBiTree /*6.4 判断二叉树是否为空 初始条件: 二叉树已存在 操作结果: 若T为空二叉树,则返回TRUE,否则返回FALSE; */ Status BiTreeEmpty(SqBiTree T){ //根结点为空,则二叉树为空 if (T[0] == Nil) return TRUE; return FALSE; } /*6.5 获取二叉树的深度 初始条件: 二叉树已存在 操作结果: 返回二叉树T深度; */ int BiTreeDepth(SqBiTree T){ int j = -1; int i; //找到最后一个结点 //MAX_TREE_SIZE -> 100 -> 10 目的找到最后一个结点10的位置 for (i = MAX_TREE_SIZE-1 ; i>=0; i--) { if (T[i] != Nil) break; } do { j++; } while ( powl(2, j) <= i); //计算2的次幂 return j; } /*6.6 返回处于位置e(层,本层序号)的结点值 初始条件: 二叉树T存在,e是T中某个结点(的位置) 操作结构: 返回处于位置e(层,本层序号)的结点值 */ CElemType Value(SqBiTree T,Position e){ /* Position.level -> 结点层.表示第几层; Position.order -> 本层的序号(按照满二叉树给定序号规则) */ //pow(2,e.level-1) 找到层序 printf("%d\n",(int)pow(2,e.level-1)); //e.order printf("%d\n",e.order); //4+2-2; return T[(int)pow(2, e.level-1)+e.order-2]; } /*6.7 获取二叉树跟结点的值 初始条件: 二叉树T存在 操作结果: 当T不空,用e返回T的根, 返回OK; 否则返回ERROR */ Status Root(SqBiTree T,CElemType *e){ if (BiTreeEmpty(T)) { return ERROR; } *e = T[0]; return OK; } /* 6.8 给处于位置e的结点赋值 初始条件: 二叉树存在,e是T中某个结点的位置 操作结果: 给处于位置e的结点赋值Value; */ Status Assign(SqBiTree T,Position e,CElemType value){ //找到当前e在数组中的具体位置索引 int i = (int)powl(2, e.level-1)+e.order -2; //叶子结点的双亲为空 if (value != Nil && T[(i+1)/2-1] == Nil) { return ERROR; } //给双亲赋空值但是有叶子结点 if (value == Nil && (T[i*2+1] != Nil || T[i*2+2] != Nil)) { return ERROR; } T[i] = value; return OK; } /* 6.9 获取e的双亲; 初始条件: 二叉树存在,e是T中的某一个结点 操作结果: 若e是T的非根结点, 则返回它的双亲,否则返回"空" */ CElemType Parent(SqBiTree T, CElemType e){ //空树 if (T[0] == Nil) { return Nil; } for (int i = 1 ; i < MAX_TREE_SIZE; i++) { //找到e if (T[i] == e) { return T[(i+1)/2 - 1]; } } //没有找到 return Nil; } /* 6.10 获取某个结点的左孩子; 初始条件:二叉树T存在,e是某个结点 操作结果:返回e的左孩子,若e无左孩子,则返回"空" */ CElemType LeftChild(SqBiTree T,CElemType e){ //空树 if (T[0] == Nil) { return Nil; } for (int i = 0 ; i < MAX_TREE_SIZE-1; i++) { //找到e if (T[i] == e) { return T[i*2+1]; } } //没有找到 return Nil; } /* 6.11 获取某个结点的右孩子; 初始条件:二叉树T存在,e是某个结点 操作结果:返回e的左孩子,若e无左孩子,则返回"空" */ CElemType RightChild(SqBiTree T,CElemType e){ //空树 if (T[0] == Nil) { return Nil; } for (int i = 0 ; i < MAX_TREE_SIZE-1; i++) { //找到e if (T[i] == e) { return T[i*2+2]; } } //没有找到 return Nil; } /* 6.12 获取结点的左兄弟 初始条件: 二叉树T存在,e是T中某个结点 操作结果: 返回e的左兄弟。若e是T的左孩子或无左兄弟,则返回＂空＂ */ CElemType LeftSibling(SqBiTree T,CElemType e) { /* 空树 */ if(T[0]==Nil) return Nil; for(int i=1;i<=MAX_TREE_SIZE-1;i++) /* 找到e且其序号为偶数(是右孩子) */ if(T[i]==e&&i%2==0) return T[i-1]; return Nil; /* 没找到e */ } /* 6.13 获取结点的右兄弟 初始条件: 二叉树T存在,e是T中某个结点 操作结果: 返回e的右兄弟。若e是T的右孩子或无右兄弟,则返回＂空＂ */ CElemType RightSibling(SqBiTree T,CElemType e) { /* 空树 */ if(T[0]==Nil) return Nil; for(int i=1;i<=MAX_TREE_SIZE-1;i++) /* 找到e且其序号为奇数(是左孩子) */ if(T[i]==e&&i%2==1) return T[i+1]; return Nil; /* 没找到e */ }
3：前序遍历
从根结点出发，则第一次到达结点A，故输出A;
继续向左访问，第一次访问结点B，故输出B；
按照同样规则，输出D，输出H；
当到达叶子结点H，返回到D，此时已经是第二次到达D，故不在输出D，进而向D右子树访问，D右子树不为空，则访问至I，第一次到达I，则输出I；
I为叶子结点，则返回到D，D左右子树已经访问完毕，则返回到B，进而到B右子树，第一次到达E，故输出E；
向E左子树，故输出J；
按照同样的访问规则，继续输出C、F、G；
输出结果： ABDHIEJCFG
void PreTraverse(SqBiTree T,int e){ //打印结点数据 visit(T[e]); //先序遍历左子树 if (T[2 * e + 1] != Nil) { PreTraverse(T, 2*e+1); } //最后先序遍历右子树 if (T[2 * e + 2] != Nil) { PreTraverse(T, 2*e+2); } } Status PreOrderTraverse(SqBiTree T){ //树不为空 if (!BiTreeEmpty(T)) { PreTraverse(T, 0); } printf("\n"); return OK; }
4：中序遍历
中序遍历就是从二叉树的根结点出发，当第二次到达结点时就输出结点数据，按照先向左在向右的方向访问。
上图所示二叉树中序访问如下：
从根结点出发，则第一次到达结点A，不输出A，继续向左访问，第一次访问结点B，不输出B；继续到达D，H；
到达H，H左子树为空，则返回到H，此时第二次访问H，故输出H；
H右子树为空，则返回至D，此时第二次到达D，故输出D；
由D返回至B，第二次到达B，故输出B；
按照同样规则继续访问，输出J、E、A、F、C、G；
则3.13所示二叉树的中序遍历输出为：
HDIBJEAFCG
void InTraverse(SqBiTree T, int e){ /* 左子树不空 */ if (T[2*e+1] != Nil) InTraverse(T, 2*e+1); visit(T[e]); /* 右子树不空 */ if (T[2*e+2] != Nil) InTraverse(T, 2*e+2); } Status InOrderTraverse(SqBiTree T){ /* 树不空 */ if (!BiTreeEmpty(T)) { InTraverse(T, 0); } printf("\n"); return OK; }
5：后序遍历
后序遍历就是从二叉树的根结点出发，当第三次到达结点时就输出结点数据，按照先向左在向右的方向访问。
图所示二叉树后序访问如下：
从根结点出发，则第一次到达结点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、F、G、C，A；
则图3.13所示二叉树的后序遍历输出为：
HIDJEBFGCA
void PostTraverse(SqBiTree T,int e) { /* 左子树不空 */ if(T[2*e+1]!=Nil) PostTraverse(T,2*e+1); /* 右子树不空 */ if(T[2*e+2]!=Nil) PostTraverse(T,2*e+2); visit(T[e]); } Status PostOrderTraverse(SqBiTree T) { if(!BiTreeEmpty(T)) /* 树不空 */ PostTraverse(T,0); printf("\n"); return OK; }
6：层序遍历
层次遍历就是按照树的层次自上而下的遍历二叉树。针对图3.13所示二叉树的层次遍历结果为：
ABCDEFGHIJ
/* 6.14 层序遍历二叉树 */ void LevelOrderTraverse(SqBiTree T){ int i = MAX_TREE_SIZE-1; //找到最后一个非空结点的序号 while (T[i] == Nil) i--; //从根结点起,按层序遍历二叉树 for (int j = 0; j <= i; j++) //只遍历非空结点 if (T[j] != Nil) visit(T[j]); printf("\n"); }
7：测试
int main(int argc, const char * argv[]) { // insert code here... printf("二叉树顺序存储结构实现!\n"); Status iStatus; Position p; CElemType e; SqBiTree T; InitBiTree(T); CreateBiTree(T); printf("建立二叉树后,树空否？%d(1:是 0:否) \n",BiTreeEmpty(T)); printf("树的深度=%d\n",BiTreeDepth(T)); p.level=3; p.order=2; e=Value(T,p); printf("第%d层第%d个结点的值: %d\n",p.level,p.order,e); iStatus = Root(T, &e); if (iStatus) { printf("二叉树的根为:%d\n",e); }else { printf("树为空,无根!\n"); } //向树中3层第2个结点位置上结点赋值99 e = 99; Assign(T, p, e); //获取树中3层第2个结点位置结点的值是多少: e=Value(T,p); printf("第%d层第%d个结点的值: %d\n",p.level,p.order,e); //找到e这个结点的双亲; printf("结点%d的双亲为%d_",e,Parent(T, e)); //找到e这个结点的左右孩子; printf("左右孩子分别为:%d,%d\n",LeftChild(T, e),RightChild(T, e)); //找到e这个结点的左右兄弟; printf("结点%d的左右兄弟:%d,%d\n",e,LeftSibling(T, e),RightSibling(T, e)); Assign(T, p, 5); printf("二叉树T层序遍历:"); LevelOrderTraverse(T); printf("二叉树T先序遍历:"); PreOrderTraverse(T); printf("二叉树T中序遍历:"); InOrderTraverse(T); printf("二叉树T后序遍历:"); PostOrderTraverse(T); return 0; }
三：二叉数链式存储
typedef char CElemType; CElemType Nil=' '; /* 字符型以空格符为空 */ typedef struct BiTNode /* 结点结构 */ { CElemType data; /* 结点数据 */ struct BiTNode *lchild,*rchild; /* 左右孩子指针 */ }BiTNode,*BiTree;
2：二叉树赋值
int indexs = 1; typedef char String[24]; /* 0号单元存放串的长度 */ String str; Status StrAssign(String T,char *chars) { int i; if(strlen(chars)>MAXSIZE) return ERROR; else { T[0]=strlen(chars); for(i=1;i<=T[0];i++) T[i]=*(chars+i-1); return OK; } }
所示的二叉树可以采用图表示。
typedef char CElemType; CElemType Nil=' '; /* 字符型以空格符为空 */ typedef struct BiTNode /* 结点结构 */ { CElemType data; /* 结点数据 */ struct BiTNode *lchild,*rchild; /* 左右孩子指针 */ }BiTNode,*BiTree; /*7.1 打印数据*/ Status visit(CElemType e) { printf("%c ",e); return OK; } /* 7.2 构造空二叉树T */ Status InitBiTree(BiTree *T) { *T=NULL; return OK; } /* 7.3 销毁二叉树 初始条件: 二叉树T存在。 操作结果: 销毁二叉树T */ void DestroyBiTree(BiTree *T) { if(*T) { /* 有左孩子 */ if((*T)->lchild) DestroyBiTree(&(*T)->lchild); /* 销毁左孩子子树 */ /* 有右孩子 */ if((*T)->rchild) DestroyBiTree(&(*T)->rchild); /* 销毁右孩子子树 */ free(*T); /* 释放根结点 */ *T=NULL; /* 空指针赋0 */ } } #define ClearBiTree DestroyBiTree /*7.4 创建二叉树 按前序输入二叉树中的结点值(字符),#表示空树; */ void CreateBiTree(BiTree *T){ CElemType ch; //获取字符 ch = str[indexs++]; //判断当前字符是否为'#' if (ch == '#') { *T = NULL; }else { //创建新的结点 *T = (BiTree)malloc(sizeof(BiTNode)); //是否创建成功 if (!*T) { exit(OVERFLOW); } /* 生成根结点 */ (*T)->data = ch; /* 构造左子树 */ CreateBiTree(&(*T)->lchild); /* 构造右子树 */ CreateBiTree(&(*T)->rchild); } } /* 7.5 二叉树T是否为空; 初始条件: 二叉树T存在 操作结果: 若T为空二叉树,则返回TRUE,否则FALSE */ Status BiTreeEmpty(BiTree T) { if(T) return FALSE; else return TRUE; } /* 7.6 二叉树T的深度 初始条件: 二叉树T存在 操作结果: 返回T的深度 */ int BiTreeDepth(BiTree T){ int i,j; if(!T) return 0; //计算左孩子的深度 if(T->lchild) i=BiTreeDepth(T->lchild); else i=0; //计算右孩子的深度 if(T->rchild) j=BiTreeDepth(T->rchild); else j=0; //比较i和j return i>j?i+1:j+1; } /* 7.7 二叉树T的根 初始条件: 二叉树T存在 操作结果: 返回T的根 */ CElemType Root(BiTree T){ if (BiTreeEmpty(T)) return Nil; return T->data; } /* 7.8 返回p所指向的结点值; 初始条件: 二叉树T存在，p指向T中某个结点 操作结果: 返回p所指结点的值 */ CElemType Value(BiTree p){ return p->data; } /* 7.8 给p所指结点赋值为value; 初始条件: 二叉树T存在，p指向T中某个结点 操作结果: 给p所指结点赋值为value */ void Assign(BiTree p,CElemType value) { p->data=value; }
4：前序递归遍历
遍历右⼦树
/* 7.8 前序递归遍历T 初始条件:二叉树T存在; 操作结果: 前序递归遍历T */ void PreOrderTraverse(BiTree T) { if(T==NULL) return; printf("%c",T->data);/* 显示结点数据，可以更改为其它对结点操作 */ PreOrderTraverse(T->lchild); /* 再先序遍历左子树 */ PreOrderTraverse(T->rchild); /* 最后先序遍历右子树 */ }
5：中序递归遍历
规则: 若⼆叉树为空,则空操作返回; 否则先访问根结点,然后前序遍历左⼦树,在前序
遍历右⼦树
/* 7.9 中序递归遍历T 初始条件:二叉树T存在; 操作结果: 中序递归遍历T */ void InOrderTraverse(BiTree T) { if(T==NULL) return ; InOrderTraverse(T->lchild); /* 中序遍历左子树 */ printf("%c",T->data);/* 显示结点数据，可以更改为其它对结点操作 */ InOrderTraverse(T->rchild); /* 最后中序遍历右子树 */ }
6：后序递归遍历
规则: 若⼆叉树为空,则空操作返回; 否则从根结点开始(注意并不是先访问根结点),
中序遍历根结点的左⼦树,然后是访问根结点,最后中序遍历右⼦树
/* 7.10 后序递归遍历T 初始条件:二叉树T存在; 操作结果: 中序递归遍历T */ void PostOrderTraverse(BiTree T) { if(T==NULL) return; PostOrderTraverse(T->lchild); /* 先后序遍历左子树 */ PostOrderTraverse(T->rchild); /* 再后序遍历右子树 */ printf("%c",T->data);/* 显示结点数据，可以更改为其它对结点操作 */ }
7：测试
int main(int argc, const char * argv[]) { // insert code here... printf("二叉树链式存储结构实现!\n"); int i; BiTree T; CElemType e1; InitBiTree(&T); StrAssign(str,"ABDH#K###E##CFI###G#J##"); CreateBiTree(&T); printf("二叉树是否为空%d(1:是 0:否),树的深度=%d\n",BiTreeEmpty(T),BiTreeDepth(T)); e1=Root(T); printf("二叉树的根为: %c\n",e1); printf("\n前序遍历二叉树:"); PreOrderTraverse(T); printf("\n中序遍历二叉树:"); InOrderTraverse(T); printf("\n后序遍历二叉树:"); PostOrderTraverse(T); printf("\n"); return 0; }
四：遍历常考考点
对于二叉树的遍历有一类典型题型。
1）已知前序遍历序列和中序遍历序列，确定一棵二叉树。
例题：若一棵二叉树的前序遍历为ABCDEF，中序遍历为CBAEDF，请画出这棵二叉树。
分析：前序遍历第一个输出结点为根结点，故A为根结点。早中序遍历中根结点处于左右子树结点中间，故结点A的左子树中结点有CB，右子树中结点有EDF。
如图所示
按照同样的分析方法，对A的左右子树进行划分，最后得出二叉树的形态如图所示：
后序遍历中最后访问的为根结点，因此可以按照上述同样的方法，找到根结点后分成两棵子树，进而继续找到子树的根结点，一步步确定二叉树的形态。
注：已知前序遍历序列和后序遍历序列，不可以唯一确定一棵二叉树。
注意
