根据后序和中序遍历写出前序
二叉树遍历（前序、中序、后序、层次、广度优先、深度优先遍历）
⼆叉树遍历（前序、中序、后序、层次、⼴度优先、深度优先遍历）⽬录转载：⼆叉树概念⼆叉树是⼀种⾮常重要的数据结构，⾮常多其他数据结构都是基于⼆叉树的基础演变⽽来的。
对于⼆叉树，有深度遍历和⼴度遍历，深度遍历有前序、中序以及后序三种遍历⽅法，⼴度遍历即我们寻常所说的层次遍历。
由于树的定义本⾝就是递归定义，因此採⽤递归的⽅法去实现树的三种遍历不仅easy理解并且代码⾮常简洁，⽽对于⼴度遍历来说，须要其他数据结构的⽀撑。
⽐⽅堆了。
所以。
对于⼀段代码来说，可读性有时候要⽐代码本⾝的效率要重要的多。
四种基本的遍历思想前序遍历：根结点 ---> 左⼦树 ---> 右⼦树中序遍历：左⼦树---> 根结点 ---> 右⼦树后序遍历：左⼦树 ---> 右⼦树 ---> 根结点层次遍历：仅仅需按层次遍历就可以⽐如。
求以下⼆叉树的各种遍历前序遍历：1 2 4 5 7 8 3 6中序遍历：4 2 7 5 8 1 3 6后序遍历：4 7 8 5 2 6 3 1层次遍历：1 2 3 4 5 6 7 8⼀、前序遍历1）依据上⽂提到的遍历思路：根结点 ---> 左⼦树 ---> 右⼦树，⾮常easy写出递归版本号：public void preOrderTraverse1(TreeNode root) {if (root != null) {System.out.print(root.val+" ");preOrderTraverse1(root.left);preOrderTraverse1(root.right);}}2）如今讨论⾮递归的版本号：依据前序遍历的顺序，优先訪问根结点。
然后在訪问左⼦树和右⼦树。
所以。
对于随意结点node。
第⼀部分即直接訪问之，之后在推断左⼦树是否为空，不为空时即反复上⾯的步骤，直到其为空。
若为空。
则须要訪问右⼦树。
注意。
在訪问过左孩⼦之后。
前序遍历中序遍历后序遍历的例题
前序遍历中序遍历后序遍历的例题一、前序遍历、中序遍历和后序遍历的概念和定义前序遍历、中序遍历和后序遍历是二叉树遍历的三种常见方式，它们是根据根节点在遍历序列中的位置进行定义的。
1. 前序遍历：前序遍历是指先访问二叉树的根节点，再依次对左子树和右子树进行前序遍历。
在前序遍历中，根节点总是在最开始的位置。
2. 中序遍历：中序遍历是指先遍历二叉树的左子树，然后访问根节点，最后遍历右子树。
在中序遍历中，根节点总是在左子树和右子树之间。
3. 后序遍历：后序遍历是指先遍历二叉树的左子树和右子树，然后访问根节点。
在后序遍历中，根节点总是在最后的位置。
二、前序遍历、中序遍历和后序遍历的应用前序遍历、中序遍历和后序遍历在二叉树的构建、搜索和遍历等方面起着重要的作用。
对于一个给定的二叉树，我们可以根据前序遍历和中序遍历来唯一确定它的结构。
类似地，我们也可以根据中序遍历和后序遍历来唯一确定二叉树的结构。
这个特性在解析和构建二叉树的过程中非常有用。
假设我们已知一个二叉树的前序遍历和中序遍历序列，我们可以根据这两个序列来构建出这个二叉树。
具体方法是：1. 从前序遍历序列中找到根节点，根节点是第一个元素；2. 在中序遍历序列中找到根节点的位置，根节点左侧的元素是左子树的节点，右侧的元素是右子树的节点；3. 根据上一步得到的左子树和右子树的节点，在前序遍历序列中找到对应的部分，分别对左子树和右子树进行递归构建。
这个方法可以保证我们得到的二叉树是原始二叉树的一个唯一构建。
同样地，我们也可以根据中序遍历和后序遍历来构建二叉树的过程类似。
三、实例分析：前序遍历中序遍历后序遍历的例题让我们通过一个具体的例题来深入理解前序遍历、中序遍历和后序遍历的应用。
假设我们有以下一棵二叉树：```/ \2 3/ \ / \4 5 6 7```给定该二叉树的前序遍历序列为1, 2, 4, 5, 3, 6, 7，中序遍历序列为4, 2, 5, 1, 6, 3, 7，后序遍历序列为4, 5, 2, 6, 7, 3, 1。
信息学初赛复习资料-综合练习
信息学初赛复习资料（综合练习）初赛考的知识点就是计算机基本常识、基本操作和程序设计基础知识。
其中选择题考查的是知识，而问题解决类型的题目更加重视能力的考查。
一般说来，选择题只要多用心积累就可以了。
问题解决题目的模式比较固定，大家应当做做以前的题目。
写运行结果和程序填空也需要多做题目，并且培养良好的程序阅读和分析能力，就像语文的阅读理解一样。
近几年来，初赛的考查范围有了很大的变化，越来越紧跟潮流了。
这就需要大家有比较广泛的知识，包括计算机硬件、软件、网络、简单的数据结构（例如栈、队列、树和图等）和简单的算法（例如排序、查找和搜索等），程序设计语言以及一些基本的数学知识和技巧（例如排列组合）。
但最主要的，还是取决于你对程序设计语言的熟悉程度，再加上认真仔细的心态。
综合练习下面四个不同进制的数中，最小的一个是。
（A）（11011001）2 （B）（75）10（C）（37）8（D）（A7）16如果52-19=33是成立的，则52、19、33分别是。
（A）八进制、十进制、十六进制（B）十进制、十六进制、八进制（C）八进制、十六进制、十进制（D）十进制、八进制、十六进制把下列二进制数分别化成八进制数、十六进制数和十进制数。
（1）1110B （2）-101010B （3）10.0101B (4) 101101.11B把下列十进制数转换成二进制数（按0舍1入取6位二进制小数）。
（1） 75 （2）1024 （3）0.2 (4)18.692用8位二进制定点整数或定点小数写出下列真值的原码、补码形式，然后用2位十六进制数表示。
（1）11001B （2）-10010B （3）100000B （4）-100000B （5）0.1B（6）-0.1B (7) 0.100111B (8) –0.100111B (9)-15/128D已知x的补码，写出补码的十六进制表示，再求出x的原码。
（1）[x]补=01010011B （2）[x]补=10001001B（3）[x]补=11111111B （4）[x]补=11000000B已知[x]原=10011011是定点纯小数，写出x的浮点数规格化形式。
前序后序中序详细讲解
前序后序中序详细讲解1.引言1.1 概述在数据结构与算法中，前序、中序和后序是遍历二叉树的三种基本方式之一。
它们是一种递归和迭代算法，用于按照特定的顺序访问二叉树的所有节点。
通过遍历二叉树，我们可以获取有关树的结构和节点之间关系的重要信息。
前序遍历是指先访问根节点，然后递归地访问左子树，最后递归地访问右子树。
中序遍历是指先递归地访问左子树，然后访问根节点，最后递归地访问右子树。
后序遍历是指先递归地访问左子树，然后递归地访问右子树，最后访问根节点。
它们的不同之处在于访问根节点的时机不同。
前序遍历可以帮助我们构建二叉树的镜像，查找特定节点，或者获取树的深度等信息。
中序遍历可以帮助我们按照节点的大小顺序输出树的节点，或者查找二叉搜索树中的某个节点。
后序遍历常用于删除二叉树或者释放二叉树的内存空间。
在实际应用中，前序、中序和后序遍历算法有着广泛的应用。
它们可以用于解决树相关的问题，例如在Web开发中，树结构的遍历算法可以用于生成网页导航栏或者搜索树结构中的某个节点。
在图像处理中，前序遍历可以用于图像压缩或者图像识别。
另外，前序和后序遍历算法还可以用于表达式求值和编译原理中的语法分析等领域。
综上所述，前序、中序和后序遍历算法是遍历二叉树的重要方式，它们在解决各种与树有关的问题中扮演着关键的角色。
通过深入理解和应用这些遍历算法，我们可以更好地理解和利用二叉树的结构特性，并且能够解决更加复杂的问题。
1.2文章结构文章结构是指文章中各个部分的布局和组织方式。
一个良好的文章结构可以使读者更好地理解和理解文章的内容。
本文将详细讲解前序、中序和后序三个部分的内容和应用。
首先，本文将在引言部分概述整篇文章的内容，并介绍文章的结构和目的。
接下来，正文部分将分为三个小节，分别对前序、中序和后序进行详细讲解。
在前序讲解部分，我们将定义和解释前序的意义，并介绍前序在实际应用中的场景。
通过详细的解释和实例，读者将能更好地理解前序的概念和用途。
根据二叉树的后序遍历和中序遍历还原二叉树解题方法
【题目】假设一棵二叉树的后序遍历序列为DGJHEBIFCA ，中序遍历序列为DBGEHJACIF ，则其前序遍历序列为( ) 。
A. ABCDEFGHIJB. ABDEGHJCFIC. ABDEGHJFICD. ABDEGJHCFI由题，后序遍历的最后一个值为A，说明本二叉树以节点A为根节点（当然，答案中第一个节点都是A，也证明了这一点）下面给出整个分析过程【第一步】由后序遍历的最后一个节点可知本树根节点为【A】加上中序遍历的结果，得知以【A】为根节点时，中序遍历结果被【A】分为两部分【DBGEHJ】【A】【CIF】于是作出第一幅图如下【第二步】将已经确定了的节点从后序遍历结果中分割出去即【DGJHEBIFC】---【A】此时，位于后序遍历结果中的最后一个值为【C】说明节点【C】是某棵子树的根节点又由于【第一步】中【C】处于右子树，因此得到，【C】是右子树的根节点于是回到中序遍历结果【DBGEHJ】【A】【CIF】中来，在【CIF】中，由于【C】是根节点，所以【IF】都是这棵子树的右子树，【CIF】子树没有左子树，于是得到下图【第三步】将已经确定了的节点从后序遍历中分割出去即【DGJHEBIF】---【CA】此时，位于后序遍历结果中的最后一个值为【F】说明节点【F】是某棵子树的根节点又由于【第二步】中【F】处于右子树，因此得到，【F】是该右子树的根节点于是回到中序遍历结果【DBGEHJ】【A】【C】【IF】中来，在【IF】中，由于【F】是根节点，所以【I】是【IF】这棵子树的左子树，于是得到下图【第四步】将已经确定了的节点从后序遍历中分割出去即【DGJHEB】---【IFCA】此时，位于后序遍历结果中的最后一个值为【B】说明节点【B】是某棵子树的根节点又由于【第一步】中【B】处于【A】的左子树，因此得到，【B】是该左子树的根节点于是回到中序遍历结果【DBGEHJ】【A】【C】【F】【I】中来，根据【B】为根节点，可以将中序遍历再次划分为【D】【B】【GEHJ】【A】【C】【F】【I】，于是得到下图【第五步】将已经确定了的节点从后序遍历中分割出去即【DGJHE】---【BIFCA】此时，位于后序遍历结果中的最后一个值为【E】说明节点【E】是某棵子树的根节点又由于【第四步】中【E】处于【B】的右子树，因此得到，【E】是该右子树的根节点于是回到中序遍历结果【D】【B】【GEHJ】【A】【C】【F】【I】中来，根据【B】为根节点，可以将中序遍历再次划分为【D】【B】【G】【E】【HJ】【A】【C】【F】【I】，于是得到下图【第六步】将已经确定了的节点从后序遍历中分割出去即【DGJH】---【EBIFCA】此时，位于后序遍历结果中的最后一个值为【H】说明节点【H】是某棵子树的根节点又由于【第五步】中【H】处于【E】的右子树，因此得到，【H】是该右子树的根节点于是回到中序遍历结果【D】【B】【G】【E】【HJ】【A】【C】【F】【I】中来，根据【H】为根节点，可以将中序遍历再次划分为【D】【B】【G】【E】【H】【J】【A】【C】【F】【I】，于是得到下图至此，整棵二叉树已经还原现在对该二叉树进行前序遍历便能得到我们想要的答案【B】。
树和森林的遍历方式
树和森林的遍历方式
树和森林是常见的数据结构，它们是由节点和边组成的非线性结构。
遍历是对树和森林进行操作的重要方法之一。
树的遍历方式有三种：前序遍历、中序遍历和后序遍历。
前序遍历是先遍历根节点，再遍历左子树和右子树；中序遍历是先遍历左子树，再遍历根节点和右子树；后序遍历是先遍历左子树和右子树，再遍历根节点。
这三种遍历方式都能够遍历树中的所有节点，但遍历顺序不同。
森林是由多棵树组成的结构，因此其遍历方式可以看作是多棵树的遍历。
对于森林的遍历，可以采用先序遍历、中序遍历和后序遍历的方式，依次对每棵树进行遍历。
除了以上三种常见的遍历方式外，还有层次遍历。
层次遍历是从根节点开始，按照层次逐层遍历树中的节点。
具体做法是使用队列数据结构，将根节点入队列，然后依次出队列并将其子节点入队列，直到队列为空。
对于树和森林的遍历方式，需要根据具体的需求来选择合适的方式。
比如，前序遍历可以用于复制树的结构，中序遍历可以用于输出有序的节点序列，后序遍历可以用于释放树的空间。
层次遍历则可以用于求解树的深度、宽度等问题。
- 1 -。
吉林省专升本数据结构习题——二叉树的遍历和构造
吉林省专升本数据结构习题、参考答案及解析——二叉树的遍历和构造1、已知一棵二叉树如下图所示，请写出该二叉树的前序、中序、后序、层序遍历序列。
参考答案前序遍历：ABDCEFGH中序遍历：BDACGFHE后序遍历：DBGHFECA层序遍历：ABCDEFGH解析：前序遍历是D(根)L(左子树)R(右子树)的顺序，左右子树也需要进行前序遍历。
中序遍历是LDR顺序，后序遍历是LRD顺序。
层序遍历是从上层到下层同层之间从左到右的顺序进行遍历。
2、已知一棵二叉树的前序和中序遍历序列分别是ABCDEFH和BCAEDFH,构造该二叉树，并写出后序遍历序列。
参考答案后序遍历序列：CBEHFDA解析： 1）、前序遍历的顺序是DLR，所以序列的第一个结点是根结点。
2）、中序遍历的顺序是LDR，在前序确定了根结点的情况下，中序序列能区分左右子树。
3）、左右子树的构造方法重复1、2即可。
3、已知一棵二叉树的中序和后序遍历序列分别是ACBEFDG和CFEGDBA,构造该二叉树，并写出前序遍历序列。
参考答案前序遍历：ABCDEFG解析：后序和中序构造二叉树的方法参考前序和中序构造二叉树的方法。
后序遍历LRD顺序，确定序列的最后一个元素是根结点，再用中序分左右子树。
4、已知一棵表达式树的前序遍历序列和中序遍历序列分别是-*+abcd和a+b*c-d。
构造该表达式树，并写出后序遍历序列。
参考答案后序遍历：ab+c*d-解析：表达式树的分支结点应该是+-*/这类运算符，而叶子结点放abcd这些操作数。
在一些题目中会出现重复使用的运算符，通过这个性质就能区分出正确的表达式树。
5、已知一棵表达式树的中序遍历序列和后序遍历序列分别是a+b*c-d+e/f和ab+c*de+f/-。
构造该表达式树，并写出前序遍历序列。
前序遍历：-*+abc/+def。
二叉树遍历实验报告
二叉树遍历实验报告二叉树遍历实验报告一、引言二叉树是计算机科学中常用的数据结构之一，它由节点组成，每个节点最多有两个子节点。
二叉树的遍历是指按照一定的规则访问二叉树中的所有节点。
本实验旨在通过实际操作，探索二叉树的三种遍历方式：前序遍历、中序遍历和后序遍历，并分析它们的应用场景和性能特点。
二、实验方法1. 实验环境本实验使用Python编程语言进行实现，并在Jupyter Notebook中运行代码。
2. 实验步骤（1）定义二叉树节点类首先，我们定义一个二叉树节点类，该类包含节点值、左子节点和右子节点三个属性。
（2）构建二叉树在主函数中，我们手动构建一个二叉树，包含多个节点，并将其保存为根节点。
（3）实现三种遍历方式通过递归的方式，实现二叉树的前序遍历、中序遍历和后序遍历。
具体实现过程如下：- 前序遍历：先访问根节点，然后递归遍历左子树，最后递归遍历右子树。
- 中序遍历：先递归遍历左子树，然后访问根节点，最后递归遍历右子树。
- 后序遍历：先递归遍历左子树，然后递归遍历右子树，最后访问根节点。
（4）测试遍历结果在主函数中，我们调用实现的三种遍历方式，对构建的二叉树进行遍历，并输出结果。
三、实验结果与分析经过实验，我们得到了二叉树的前序遍历、中序遍历和后序遍历的结果。
以下是我们的实验结果及分析：1. 前序遍历结果前序遍历结果为：A - B - D - E - C - F - G前序遍历的应用场景包括：复制整个二叉树、计算二叉树的深度和宽度等。
前序遍历的时间复杂度为O(n)，其中n为二叉树的节点数。
2. 中序遍历结果中序遍历结果为：D - B - E - A - F - C - G中序遍历的应用场景包括：二叉搜索树的中序遍历可以得到有序的节点序列。
中序遍历的时间复杂度为O(n)，其中n为二叉树的节点数。
3. 后序遍历结果后序遍历结果为：D - E - B - F - G - C - A后序遍历的应用场景包括：计算二叉树的高度、判断二叉树是否对称等。
树的运算概念
树的运算概念树是一种非线性数据结构，它由节点和边组成，并具有层次结构。
在树中，除了根节点外，每个节点都有一个唯一的父节点，同时可能有多个子节点。
树的运算概念包括树的遍历、树的搜索、树的插入和删除等。
1. 树的遍历：树的遍历是指按照某种顺序访问树中的每一个节点。
常见的树的遍历方式包括前序遍历、中序遍历和后序遍历。
- 前序遍历：先访问根节点，然后递归地前序遍历左子树，最后递归地前序遍历右子树。
- 中序遍历：先递归地中序遍历左子树，然后访问根节点，最后递归地中序遍历右子树。
- 后序遍历：先递归地后序遍历左子树，然后递归地后序遍历右子树，最后访问根节点。
2. 树的搜索：树的搜索是指在树中查找指定节点或特定条件的节点。
常见的树的搜索方式包括深度优先搜索（DFS）和广度优先搜索（BFS）。
- 深度优先搜索：从根节点开始，沿每个分支一直搜索下去，直到找到目标节点或无法继续搜索为止。
- 广度优先搜索：首先访问根节点，然后按层次依次访问每个节点的所有子节点，直到找到目标节点或搜索完所有节点为止。
3. 树的插入：树的插入是指向已有树中插入新节点的操作。
在插入节点时，需要考虑保持树的结构和特性的完整性，例如二叉搜索树的插入要保持节点的值符合二叉搜索树的性质。
- 对于二叉搜索树，插入新节点的过程是从根节点开始，不断比较新节点的值与当前节点的值的大小关系，确定新节点应该插入到当前节点的左子树还是右子树，直到找到合适的插入位置。
- 对于平衡二叉树，插入新节点后需要通过旋转等操作来调整树的平衡性，以保持整棵树的高度平衡，例如AVL树和红黑树。
4. 树的删除：树的删除是指删除树中一个或多个节点的操作。
在删除节点时，同样需要考虑保持树的结构和特性的完整性。
- 对于二叉搜索树，删除节点时需考虑删除后的树结构是否满足二叉搜索树的性质。
如果要删除的节点没有子节点，可以直接删除；如果要删除的节点有一个子节点，可以将该子节点替代要删除的节点的位置；如果要删除的节点有两个子节点，可以找到该节点的中序后继（或前驱）节点替代要删除的节点，并删除中序后继（或前驱）节点。
(完整word版)数据结构(C语言)
《数据结构与算法》复习题应用简答题.1．有下列几种用二元组表示的数据结构，画出它们分别对应的逻辑图形表示，并指出它们分别属于何种结构。
(1）A ＝｛D，R｝,其中：D＝｛a，b，c，d，e，f，g，h｝,R ＝｛r｝，r ＝｛<a,b>，<b,c>，〈c，d〉,〈d，e>，〈e,f〉，<f,g>，<g，h〉｝（2）B ＝｛D,R｝，其中：D＝{a，b，c，d,e，f，g，h｝，R ＝｛r｝，r ＝｛<d，b>，〈d，g〉,<d，a〉,<b,c>，<g，e>,<g,h〉，〈e,f〉｝(3)C ＝｛D,R｝，其中：D＝｛1，2,3，4,5，6｝，R ＝｛r｝，r ＝｛（1，2），（2,3）,（2，4），(3，4），（3，5），（3，6），（4，5),（4，6）｝2．简述顺序表和链表存储方式的特点。
答:顺序表的优点是可以随机访问数据元素，缺点是大小固定，不利于增减结点（增减结点操作需要移动元素）。
链表的优点是采用指针方式增减结点，非常方便（只需改变指针指向，不移动结点)。
其缺点是不能进行随机访问，只能顺序访问。
另外，每个结点上增加指针域，造出额外存储空间增大.3．对链表设置头结点的作用是什么?（至少说出两条好处）答：其好处有：(1）对带头结点的链表,在表的任何结点之前插入结点或删除表中任何结点，所要做的都是修改前一个结点的指针域,因为任何元素结点都有前驱结点（若链表没有头结点，则首元素结点没有前驱结点，在其前插入结点和删除该结点时操作复杂些）。
（2）对带头结点的链表，表头指针是指向头结点的非空指针，因此空表与非空表的处理是一样的。
4．对于一个栈,给出输入项A ，B,C 。
如果输入项序列由A ，B,C 组成,试给出全部可能的输出序列。
5．设有4个元素1、2、3、4依次进栈,而栈的操作可随时进行（进出栈可任意交错进行，但要保证进栈次序不破坏1、2、3、4的相对次序），请写出所有不可能的出栈次序和所有可能的出栈次序.6．现有稀疏矩阵A 如图所示，要求画出三元组表示法和十字链表表示法：⎥⎥⎥⎥⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎢⎢⎢⎢⎣⎡--000280000000910000000060000003130150220157．设4维数组的4个下标的范围分别为［-1，0］,[1,2],［1,3],[-2，-1]，请分别按行序和列序列出各元素。
数据结构复习题目及答案
《数据结构-C语言版》第一章绪论单项选择题1．在数据结构中，数据的基本单位是_____ ____。
A. 数据项B. 数据类型C. 数据元素D. 数据变量2．数据结构中数据元素之间的逻辑关系被称为__ ____。
A. 数据的存储结构B. 数据的基本操作C. 程序的算法D. 数据的逻辑结构3．在数据结构中，与所使用计算机无关的是数据的____ ___。
A. 存储结构B. 逻辑和物理结构C. 逻辑结构D. 物理结构4．在链式存储结构中，数据之间的关系是通过____ ____体现的。
A. 数据在存的相对位置B. 指示数据元素的指针C. 数据的存储地址D. 指针5．计算算法的时间复杂度是属于一种____ ___。
A. 事前统计的方法B. 事前分析估算的方法C. 事后统计的方法D. 事后分析估算的方法6．在对算法的时间复杂度进行估计的时候，下列最佳的时间复杂度是____ __。
A. n2B. nlognC. nD. logn7．设使用某算法对n个元素进行处理，所需的时间是T(n)=100nlog2n+200n+2000，则该算法的渐近时间复杂度为____ ___。
A. O(1)B. O(n)C. O(200n)D. O(nlog2n)CDCBBDD第二章线性表单项选择题1．链表不具有的特点是____ ____。
A. 可随机访问任一元素B. 插入和删除时不需要移动元素C. 不必事先估计存储空间D. 所需空间与线性表的长度正比2．设顺序表的每个元素占8个存储单元。
第1个单元的存储地址是100，则第6个元素占用的最后一个存储单元的地址为。
A. B. 140 C. 147 D. 1483．在线性链表存储结构下，插入操作算法。
A. 需要判断是否表满B. 需要判断是否表空C. 不需要判断表满D. 需要判断是否表空和表满4．在一个单链表中，若删除p所指结点的后继结点，则执行。
A. p->next = p->next->next;B. p->next = p->next;C. p = p->next->next;D. p = p->next; p->next = p->next->next;5．将长度为n的单链表接在长度为m的单链表之后的算法时间复杂度为。
二叉树的遍历（前序、中序、后序、已知前中序求后序、已知中后序求前序）
⼆叉树的遍历（前序、中序、后序、已知前中序求后序、已知中后序求前序）之前的⼀篇随笔（）只对⼆叉树的遍历进⾏了笼统的描述，这篇随笔重点对前、中、后序的遍历顺序进⾏分析⼆叉树的遍历⼆叉树的深度优先遍历可细分为前序遍历、中序遍历、后序遍历，这三种遍历可以⽤递归实现（本篇随笔主要分析递归实现），也可使⽤⾮递归实现的前序遍历：根节点->左⼦树->右⼦树（根->左->右）中序遍历：左⼦树->根节点->右⼦树（左->根->右）后序遍历：左⼦树->右⼦树->根节点（左->右->根）在进⾏已知两种遍历顺序求另⼀种遍历顺序前，先看⼀下不同遍历顺序对应的代码前序遍历1/* 以递归⽅式前序遍历⼆叉树 */2void PreOrderTraverse(BiTree t, int level)3 {4if (t == NULL)5 {6return ;7 }8 printf("data = %c level = %d\n ", t->data, level);9 PreOrderTraverse(t->lchild, level + 1);10 PreOrderTraverse(t->rchild, level + 1);11 }中序遍历1/* 以递归⽅式中序遍历⼆叉树 */2void PreOrderTraverse(BiTree t, int level)3 {4if (t == NULL)5 {6return ;7 }8 PreOrderTraverse(t->lchild, level + 1);9 printf("data = %c level = %d\n ", t->data, level);10 PreOrderTraverse(t->rchild, level + 1);11 }后序遍历1/* 以递归⽅式后序遍历⼆叉树 */2void PreOrderTraverse(BiTree t, int level)3 {4if (t == NULL)5 {6return ;7 }8 PreOrderTraverse(t->lchild, level + 1);9 PreOrderTraverse(t->rchild, level + 1);10 printf("data = %c level = %d\n ", t->data, level);11 }三种遍历⽅式对应的代码⼏乎相同，只是⼀条语句的位置发⽣了变化printf("data = %c level = %d\n ", t->data, level);只看⽂字和代码来理解遍历的过程是⽐较困难的，建议读者亲⾃去遍历，为了理清遍历的过程下⾯上题（图⽚来源：）前序遍历前序的遍历的特点，根节点->左⼦树->右⼦树，注意看前序的遍历的代码printf语句是放在两条递归语句之前的，所以先访问根节点G，打印G，然后访问左⼦树D，此时左⼦树D⼜作为根节点，打印D，再访问D的左⼦树AA⼜作为根节点，打印A，A没有左⼦树或者右⼦树，函数调⽤结束返回到D节点（此时已经打印出来的有：GDA）D节点的左⼦树已经递归完成，现在递归访问右⼦树F，F作为根节点，打印F，F有左⼦树访问左⼦树E，E作为根节点，打印E，（此时已经打印出来的有：GDAFE），E没有左⼦树和右⼦树，函数递归结束返回F节点，F的左⼦树已经递归完成了，但没有右⼦树，所以函数递归结束，返回D节点，D节点的左⼦树和右⼦树递归全部完成，函数递归结束返回G节点，访问G节点的右⼦树M，M作为根节点，打印M，访问M的左⼦树H，H作为根节点，打印H，（此时已经打印出来的有：GDAFEMH）H没有左⼦树和右⼦树，函数递归结束，返回M节点，M节点的左⼦树已经递归完成，访问右⼦树Z，Z作为根节点，打印Z，Z没有左⼦树和右⼦树，函数递归结束，返回M节点，M节点的左⼦树右⼦树递归全部完成，函数递归结束，返回G节点，G节点的左右⼦树递归全部完成，整个⼆叉树的遍历就结束了（MGJ，终于打完了··）前序遍历结果：GDAFEMHZ总结⼀下前序遍历步骤第⼀步：打印该节点（再三考虑还是把访问根节点这句话去掉了）第⼆步：访问左⼦树，返回到第⼀步（注意：返回到第⼀步的意思是将根节点的左⼦树作为新的根节点，就好⽐图中D是G的左⼦树但是D也是A节点和F节点的根节点）第三步：访问右⼦树，返回到第⼀步第四步：结束递归，返回到上⼀个节点前序遍历的另⼀种表述：（1）访问根节点（2）前序遍历左⼦树（3）前序遍历右⼦树（在完成第2,3步的时候，也是要按照前序遍历⼆叉树的规则完成）前序遍历结果：GDAFEMHZ中序遍历（详细遍历过程就不再赘述了，(┬＿┬)）中序遍历步骤第⼀步：访问该节点左⼦树第⼆步：若该节点有左⼦树，则返回第⼀步，否则打印该节点第三步：若该节点有右⼦树，则返回第⼀步，否则结束递归并返回上⼀节点（按我⾃⼰理解的中序就是：先左到底，左到不能在左了就停下来并打印该节点，然后返回到该节点的上⼀节点，并打印该节点，然后再访问该节点的右⼦树，再左到不能再左了就停下来）中序遍历的另⼀种表述：（1）中序遍历左⼦树（2）访问根节点（3）中序遍历右⼦树（在完成第1，3步的时候，要按照中序遍历的规则来完成）所以该图的中序遍历为：ADEFGHMZ后序遍历步骤第⼀步：访问左⼦树第⼆步：若该节点有左⼦树，返回第⼀步第三步：若该节点有右⼦树，返回第⼀步，否则打印该节点并返回上⼀节点后序遍历的另⼀种表述：（1）后序遍历左⼦树（2）后序遍历右⼦树（3）访问根节点（在完成1,2步的时候，依然要按照后序遍历的规则来完成）该图的后序遍历为：AEFDHZMG（读者如果在纸上遍历⼆叉树的时候，仍然容易将顺序搞错建议再回去看⼀下三种不同遍历对应的代码）进⼊正题，已知两种遍历结果求另⼀种遍历结果（其实就是重构⼆叉树）第⼀种：已知前序遍历、中序遍历求后序遍历前序遍历：ABCDEF中序遍历：CBDAEF在进⾏分析前读者需要知道不同遍历结果的特点1、前序遍历的第⼀元素是整个⼆叉树的根节点2、中序遍历中根节点的左边的元素是左⼦树，根节点右边的元素是右⼦树3、后序遍历的最后⼀个元素是整个⼆叉树的根节点（如果读者不明⽩上述三个特点，建议再回去看⼀下三种不同遍历对应的代码，并在纸上写出⼀个简单的⼆叉树的三种不同的遍历结果，以加深对三种不同遍历的理解）⽤上⾯这些特点来分析遍历结果，第⼀步：先看前序遍历A肯定是根节点第⼆步：确认了根节点，再来看中序遍历，中序遍历中根节点A的左边是CBD，右边是EF，所有可以确定⼆叉树既有左⼦树⼜有右⼦树第三步：先来分析左⼦树CBD，那么CBD谁来做A的左⼦树呢？这个时候不能直接⽤中序遍历的特点（左->根->右）得出左⼦树应该是这个样⼦因为有两种情况都满⾜中序遍历为CBD⽆法直接根据中序遍历来直接得出左⼦树的结构，这个时候就要返回到前序遍历中去观察前序遍历ABCDEF，左⼦树CBD在前序遍历中的顺序是BCD，意味着B是左⼦树的根节点（这么说可能不太好理解，换个说法就是B是A的左⼦树）,得出这个结果是因为如果⼀个⼆叉树的根节点有左⼦树，那么这个左⼦树⼀定在前序遍历中⼀定紧跟着根节点（这个是⽤前序遍历的特点（根->左->右）得出的）,到这⾥就可以确认B是左⼦树的根节点第四步：再观察中序遍历CBDAEF，B元素左边是C右边是D，说明B节点既有左⼦树⼜有右⼦树，左右⼦树只有⼀个元素就可以直接确定了，不⽤再返回去观察前序遍历第五步：到这⾥左⼦树的重建就已经完成了，现在重建右⼦树，因为重建右⼦树的过程和左⼦树的过程⼀模⼀样，步骤就不像上⾯写这么细了（(┬＿┬)），观察中序遍历右⼦树为EF，再观察前序遍历ABCDEF中右⼦树的顺序为EF，所以E为A的右⼦树，再观察中序便利中E只有右边有F，所有F为E的右⼦树，最后得到的⼆叉树是这个样⼦的所有求得的后序遍历为：CDBFEA总结⼀下上述步骤：先观察前序遍历找到根节点->观察中序遍历将根节点左边归为左⼦树元素，右边归为右⼦树元素（可能会出现只有左⼦树或者右⼦树的情况）->观察前序遍历中左\右⼦树⼏个元素的顺序，最靠前的为左\右⼦树的根节点->重复前⾯的步骤第⼆种：已知中序遍历、后序遍历求前序遍历（题还是上⾯这道）中序遍历：CBDAEF后序遍历为：CDBFEA仍然是根据不同遍历⽅式结果的特点来重构⼆叉树，过程很相似这⾥就不详细说了，后序遍历的最后⼀个元素A是根节点，在中序遍历中以根节点A作为分界将元素分为左⼦树（CBD）和右⼦树（EF），再观察后序遍历中左⼦树的顺序是CDB，可以判断出B是左⼦树的根节点（因为后序遍历是：左->右->根），再观察中序遍历，B元素左边是C右边是D，说明B节点既有左⼦树⼜有右⼦树，左右⼦树只有⼀个元素就可以直接确定了，不⽤再返回去观察后序遍历，左⼦树重建完成，现在来看右⼦树，右⼦树有两个元素EF，观察后序遍历E在F的后⾯，所以E是右⼦树的根节点，然后看中序遍历中E只有右边⼀个F元素了，即F是E的右⼦树，此时整个⼆叉树重构完成总结⼀下上述步骤：先观察后序遍历找到根节点->观察中序遍历将根节点左边归为左⼦树元素，右边归为右⼦树元素（可能会出现只有左⼦树或者右⼦树的情况）->观察后序遍历中左\右⼦树⼏个元素的顺序，最靠后的为左\右⼦树的根节点->重复前⾯的步骤注意：已知前序遍历、后序遍历⽆法求出中序遍历（因为由前序后序重构出来的⼆叉树不⽌⼀种）举个栗⼦左图这两种⼆叉树前序（BEFA）和后序（AFEB）⼀样，但对应的中序遍历结果不⼀样（左边的是AFEB右边的是BEFA），所以仅靠前序后序是重构出唯⼀的⼆叉树。
树的前序遍历、中序遍历、后序遍历详解
树的前序遍历、中序遍历、后序遍历详解1.前序遍历图1对于当前节点，先输出该节点，然后输出他的左孩⼦，最后输出他的右孩⼦。
以上图为例，递归的过程如下：（1）：输出 1，接着左孩⼦；（2）：输出 2，接着左孩⼦；（3）：输出 4，左孩⼦为空，再接着右孩⼦；（4）：输出 6，左孩⼦为空，再接着右孩⼦；（5）：输出 7，左右孩⼦都为空，此时 2 的左⼦树全部输出，2 的右⼦树为空，此时 1 的左⼦树全部输出，接着 1 的右⼦树；（6）：输出 3，接着左孩⼦；（7）：输出 5，左右孩⼦为空，此时 3 的左⼦树全部输出，3 的右⼦树为空，⾄此 1 的右⼦树全部输出，结束。
2.中序遍历对于当前结点，先输出它的左孩⼦，然后输出该结点，最后输出它的右孩⼦。
以上图为例：（1）：1-->2-->4，4 的左孩⼦为空，输出 4，接着右孩⼦；（2）：6 的左孩⼦为空，输出 6，接着右孩⼦；（3）：7 的左孩⼦为空，输出 7，右孩⼦也为空，此时 2 的左⼦树全部输出，输出 2，2 的右孩⼦为空，此时 1 的左⼦树全部输出，输出1，接着 1 的右孩⼦；（4）：3-->5，5 左孩⼦为空，输出 5，右孩⼦也为空，此时 3 的左⼦树全部输出，⽽ 3 的右孩⼦为空，⾄此 1 的右⼦树全部输出，结束。
3.后序遍历对于当前结点，先输出它的左孩⼦，然后输出它的右孩⼦，最后输出该结点。
依旧以上图为例：（1）：1->2->4->6->7，7 ⽆左孩⼦，也⽆右孩⼦，输出 7，此时 6 ⽆左孩⼦，⽽ 6 的右⼦树也全部输出，输出 6，此时 4 ⽆左⼦树，⽽ 4的右⼦树全部输出，输出 4，此时 2 的左⼦树全部输出，且 2 ⽆右⼦树，输出 2，此时 1 的左⼦树全部输出，接着转向右⼦树；（2）：3->5，5 ⽆左孩⼦，也⽆右孩⼦，输出 5，此时 3 的左⼦树全部输出，且 3 ⽆右孩⼦，输出 3，此时 1 的右⼦树全部输出，输出 1，结束。
二叉树的先序,中序,后序遍历的递归工作栈的关系
二叉树的先序,中序,后序遍历的递归工作栈的关系在计算机科学中，二叉树是一种非常重要的数据结构，它在很多算法和数据处理中都有着广泛的应用。
而二叉树的先序、中序、后序遍历以及它们与递归和工作栈的关系更是程序员面试中常见的问题。
本文将从深度和广度两个方面，按照先序、中序、后序的顺序逐步展开对这个主题的探讨。
一、先序遍历先序遍历是指先访问根节点，然后递归地先序遍历左子树，最后递归地先序遍历右子树。
在实际的计算机算法中，我们可以使用递归或者栈来实现先序遍历。
1.1 递归实现当我们使用递归来实现先序遍历时，可以很容易地写出下面这段代码：```pythondef preorderTraversal(root):if not root:return []return [root.val] + preorderTraversal(root.left) + preorderTraversal(root.right)```这段代码非常简洁明了，但是在实际执行时，会使用工作栈来保存递归中间结果。
因为递归本质上就是一个栈结构，在调用递归函数时，会将当前函数的局部变量和参数压入栈中，直到递归结束，栈中的内容才会依次出栈执行。
1.2 栈实现除了递归之外，我们也可以使用显式栈来实现先序遍历。
这种方法通常会更加高效一些，因为递归会有一定的性能损耗。
栈的实现思路是，我们首先将根节点压入栈中，然后弹出栈顶节点并访问它，接着先将右子节点压入栈中，再将左子节点压入栈中。
重复上述操作直到栈为空。
这样就可以保证先访问根节点，再访问左子树，最后访问右子树，符合先序遍历的要求。
二、中序遍历中序遍历是指先递归地中序遍历左子树，然后访问根节点，最后递归地中序遍历右子树。
中序遍历同样可以用递归或者显式栈来实现。
2.1 递归实现递归实现中序遍历同样非常简单：```pythondef inorderTraversal(root):if not root:return []return inorderTraversal(root.left) + [root.val] + inorderTraversal(root.right)```在这个递归函数中，同样使用了递归的工作栈来保存中间结果。
已知中序遍历，后序遍历，求前序遍历
已知中序遍历，后序遍历，求前序遍历现在知道中序，后序，则再后序遍历中最后⼀个为根节点，然后我们要求的为前序遍历，先输出根节点，然后在中序遍历中找到第⼀个根节点，会将中序遍历分为两⼤部分，就是左右两棵⼦树。
再对应的除去第⼀个根节点后，在后序遍历中根据中序遍历分的两个⼦树，分别对应后序遍历的部分，再在后序遍历中寻找到下⼀个根节点再继续递归。
打个⽐⽅：中序ACGDBHZKX，后序CDGAHXKZB，⾸先可找到主根B；那么我们找到中序遍历中的B，由这种遍历的性质，可将中序遍历分为ACGD和HZKX两棵⼦树，那么对应可找到后序遍历CDGA和HXKZ（从头找即可）从⽽问题就变成求1.中序遍历ACGD，后序遍历CDGA的树 2.中序遍历HZKX，后序遍历HXKZ的树；接着递归，按照原先⽅法，找到1.⼦根A，再分为两棵⼦树2.⼦根Z，再分为两棵⼦树。
代码：#include<cstdio>#include<iostream>#include<cstring>using namespace std;void beford(string in,string after){if (in.size()>0){char ch=after[after.size()-1];cout<<ch;//找根输出int k=in.find(ch);beford(in.substr(0,k),after.substr(0,k));beford(in.substr(k+1),after.substr(k,in.size()-k-1));//递归左右⼦树；}}int main(){string inord,aftord;cin>>inord;cin>>aftord;//读⼊beford(inord,aftord);cout<<endl;return0;}。
前序遍历 中序遍历 后序遍历
前序遍历中序遍历后序遍历1.遍历思想前序遍历首先访问根节点，然后访问左子树，最后访问右子树。
中序遍历先访问左子树，然后访问根节点，最后访问右子树。
后续遍历先访问左子树，然后访问右子树，最后访问根节点。
层序遍历则是从上到下，从左到右的进行遍历。
遍历树结构如下所示：。
2.实际代码1.首先建立节点类public class Node {private String data;private Node leftNode;private Node rightNode;public Node(String data,Node leftNode,Node rightNode){ this.data = data;this.leftNode = leftNode;this.rightNode = rightNode;}public String getData({return this.data;}public Node getLeftNode({return this.leftNode;}public Node getRightNode({return this.rightNode;}}。
2.实现前序遍历，中序遍历，后序遍历，层序遍历的遍历工具类，前序遍历，中序遍历，后序遍历实现方法采用递归方法。
而层序遍历使用了队列容器对结点进行遍历。
import java.util.Queue;import java.util.concurrent.LinkedBlockingQueue;public class TraverseTool {//前序遍历public void preTraverse(Node node){System.out.print(node.getData();preTraverse(node.getLeftNode(); }if(node.getRightNode( != null){preTraverse(node.getRightNode(); }}//中序遍历public void midTraverse(Node node){if(node.getLeftNode( != null){midTraverse(node.getLeftNode(); }System.out.print(node.getData();if(node.getRightNode( != null){midTraverse(node.getRightNode(); }}//后续遍历public void postTraverse(Node node){postTraverse(node.getLeftNode();}if(node.getRightNode( != null){postTraverse(node.getRightNode();}System.out.print(node.getData();}//层序遍历public void seqTraverse(Node node){Queue<Node> queue = new LinkedBlockingQueue<>(; queue.add(node);Node nextNode;while (!queue.isEmpty(){nextNode = queue.remove(;if(nextNode.getLeftNode( !=null){queue.add(nextNode.getLeftNode();}if(nextNode.getRightNode( !=null){queue.add(nextNode.getRightNode();}System.out.print(nextNode.getData();}}}。
前序遍历中序遍历后序遍历例题
前序遍历中序遍历后序遍历例题前序遍历、中序遍历和后序遍历是树的三种基本遍历方式，它们在树的操作和应用中都有很重要的作用。
在本文中，我将以从简到繁的方式，结合例题，深入探讨前序遍历、中序遍历和后序遍历的定义、应用和实际操作。
通过逐步分析和比较，我将帮助你更深入地理解这三种遍历方式的本质和用途。
1. 前序遍历在前序遍历中，首先访问根节点，然后递归地对左子树进行前序遍历，最后递归地对右子树进行前序遍历。
这种遍历方式常常用于构建表达式树、复制树等操作中。
对于树的结构：```1/ \2 3/ \4 5```前序遍历的结果为：1-2-4-5-3。
这种遍历方式在一些特定的操作中具有独特的优势，如寻找树的深度、判断两个树是否相等等。
2. 中序遍历在中序遍历中，首先递归地对左子树进行中序遍历，然后访问根节点，最后递归地对右子树进行中序遍历。
中序遍历的应用非常广泛，常用于对树进行排序、寻找二叉搜索树中的下一个节点等操作。
以同样的树结构为例，中序遍历的结果为：4-2-5-1-3。
3. 后序遍历在后序遍历中，首先递归地对左子树进行后序遍历，然后递归地对右子树进行后序遍历，最后访问根节点。
后序遍历在一些特定的操作中非常高效，例如求树的直径、构建表达式树等。
以同样的树结构为例，后序遍历的结果为：4-5-2-3-1。
通过以上例题和分析，你应该对前序遍历、中序遍历和后序遍历有了初步的了解。
接下来，我将从实际操作的角度给你更多的详细解释。
☞更多有关前序遍历、中序遍历和后序遍历的内容，请点击[阅读原文]查看。
前序遍历、中序遍历和后序遍历是树的三种基本遍历方式，它们在树的操作和应用中都有着重要的作用。
从简到繁地深入探讨这三种遍历方式的定义、应用和实际操作可以帮助我们更深入地理解它们的本质和用途。
对于前序遍历，我们首先访问根节点，然后递归地对左子树进行前序遍历，最后递归地对右子树进行前序遍历。
这种遍历方式常常用于构建表达式树、复制树等操作中。
通过二叉树的中序序列和后序序列获取前序序列
通过⼆叉树的中序序列和后序序列获取前序序列⼆叉树的遍历⽅式常见的三种是：先序遍历(ABC)、中序遍历(BAC)、后序遍历(BCA) 先序遍历： 若⼆叉树为空，则空操作；否则：1. 访问根结点;2. 先序遍历左⼦树；3. 先序遍历右⼦树。
中序遍历： 若⼆叉树为空，则空操作；否则：1. 中序遍历左⼦树；2. 访问根结点；3. 中序遍历右⼦树。
后序遍历： 若⼆叉树为空，则空操作；否则：1. 后序遍历左⼦树；2. 后序遍历右⼦树；3. 访问根结点。
在学习到根据遍历序列确定⼆叉树时，知道了：可以通过⼆叉树的先中或者中后遍历序列唯⼀确定⼀棵⼆叉树。
根据算法描述使⽤java 码出依据中后遍历序列来获取先序遍历序列的代码：1package learn.normalcode;23import java.util.ArrayList;45public class BlankD {6public static ArrayList<Character> ansList = new ArrayList<>(11);7//通过⼆叉树的中序序列和后序序列获取前序序列8public static void getAns(String middle, String back) {9//后序序列的最后⼀个结点为根结点10int backLength = back.length(), middleLength = middle.length();11char c = '#';12if (backLength > 0) {13 c = back.charAt(backLength - 1);14 ansList.add(c);1516//从中/后序序列中分裂出左右⼦树的中/后序序列17int indexOfRoot = middle.indexOf(c);18 getAns(middle.substring(0, indexOfRoot), back.substring(0, indexOfRoot));19 getAns(middle.substring(indexOfRoot + 1, middleLength), back.substring(indexOfRoot, backLength - 1));20 }21return;2223 }24public static void main(String[] args) {25 String middle = "SMBDCEAFHG", back = "MSDECBHGFA";26 getAns(middle, back);27 System.out.println(ansList);2829 ansList.clear();30 middle = "DCBA";31 back = "DCBA";32 getAns(middle, back);33 System.out.println(ansList);3435 ansList.clear();36 middle = "SMBDCEA";37 back = "MSDECBA";38 getAns(middle, back);39 System.out.println(ansList);40 }41 }。
数据结构——已知先序中序求后序，已知中序后序求先序
数据结构——已知先序中序求后序，已知中序后序求先序 总结下⼆叉树的已知两种遍历⽅式求第三种遍历顺序的⽅法，已知先序和中序遍历或者后序与中序遍历后⼆叉树是唯⼀确定的，下⾯介绍怎么求出第三种遍历顺序。
先序遍历顺序为：根结点——左⼦结点——右⼦结点，中序遍历为：左⼦结点——根结点——右⼦结点，我们注意到，先序遍历的第⼀个元素就是⼆叉树根结点，我们在中序遍历中以该元素分为左右两部分，则左边为左⼦树，右边为右⼦树，递归即可还原⼆叉树，这个过程中可直接输出后序遍历的顺序。
同理，可以⽤后序与中序还原出先序遍历的顺序。
代码及测试数据如下：1 #include <iostream>2 #include <cstdio>3 #include <cstring>4 #include <algorithm>5 #include <malloc.h>6 #include <string>7 #include <vector>8 #include <stack>9 #include <queue>10 #include <set>11 #include <map>1213#define FRER() freopen("in.txt", "r", stdin);1415using namespace std;1617//函数状态码定义18#define TRUE 119#define FALSE 020#define OK 121#define ERROR 022#define INFEASIBLE -123#define OVERFLOW -22425 typedef char TElemType;26 typedef int Status;2728 typedef struct BiNode {29 TElemType data;30struct BiNode *lchild, *rchild;31 }BiNode, *BiTree;3233 BiTree BinaryTreeFormorderings(char *, char *, int);34 BiTree BinaryTreePostorderings(char *, char *, int);3536/*37ABDECFG38DBEAFCG39DEBFGCA40*/4142int main()43 {44 FRER()45int n;46char str[100], ptr[100];47 cin >> n >> str >> ptr;48 BinaryTreePostorderings(str, ptr, n);49return0;50 }5152 BiTree BinaryTreeFormorderings(char *pre, char *in, int len) {53if(len <= 0)54return NULL;55 BiNode *node = new BiNode;56 node->data = *pre;57int idx = 0;58while(idx < len) {59if(*(in + idx) == *pre)60break;61 ++idx;62 }63 node->lchild = BinaryTreeFormorderings(pre + 1, in, idx);64 node->rchild = BinaryTreeFormorderings(pre + idx + 1, in + idx + 1, len - (idx + 1));65 cout << node->data << '';66return node;67 }6869 BiTree BinaryTreePostorderings(char *in, char *post, int len) {70if(len == 0)71return NULL;72 BiNode *node = new BiNode;73 node->data = *(post + len - 1);74 cout << node->data << '';75int idx = 0;76while(idx < len) {77if(*(in + idx) == *(post + len - 1))78break;79 ++idx;80 }81 node->lchild = BinaryTreePostorderings(in, post, idx);82 node->rchild = BinaryTreePostorderings(in + idx + 1, post + idx, len - (idx + 1)); 83return node;84 }。