HDU1710根据前序和后序求出中序
二叉树前序中序后序遍历算法
一、背景介绍在计算机科学中，二叉树是一种非常常见且重要的数据结构。
它由节点组成，每个节点最多有两个子节点：左子节点和右子节点。
而二叉树的遍历算法，即前序、中序和后序遍历，是对二叉树进行深度优先搜索的方法，它们在解决树相关问题时发挥着重要作用。
二、前序、中序和后序遍历算法的基本原理1. 前序遍历前序遍历算法是指先访问根节点，然后依次递归地前序遍历左子树和右子树。
在前序遍历中，节点的访问顺序是根节点 -> 左子树 -> 右子树。
这种遍历方式可以帮助我们快速了解二叉树的整体结构。
2. 中序遍历中序遍历算法是指先递归地中序遍历左子树，然后访问根节点，最后递归地中序遍历右子树。
在中序遍历中，节点的访问顺序是左子树 -> 根节点 -> 右子树。
通过中序遍历，我们可以按照从小到大的顺序访问二叉树的节点，用于排序和搜索相关的问题。
3. 后序遍历后序遍历算法是指先递归地后序遍历左子树和右子树，然后访问根节点。
在后序遍历中，节点的访问顺序是左子树 -> 右子树 -> 根节点。
这种遍历方式常常用于计算二叉树的高度和判断是否为平衡二叉树等问题。
以上三种遍历算法都是基于递归的思想来实现的，它们可以帮助我们深入理解二叉树的结构和特性，解决与二叉树相关的各种问题。
三、深度和广度的有机结合在实际应用中，了解和掌握二叉树的遍历算法不仅有助于我们解决特定的问题，还可以帮助我们提高对算法和数据结构的理解和认识。
通过深度的研究和广度的应用，我们可以更好地应对各种复杂情况，提高我们解决问题的效率和准确性。
四、总结与回顾通过本文的介绍，我们对二叉树的前序、中序和后序遍历算法有了更深入的了解。
这些算法不仅仅是一种方法，更是一种思想和理念。
在编程和技术领域，我们经常需要用到这些算法来解决各种问题，因此深入理解和掌握它们是非常重要的。
五、个人理解与观点对于我个人而言，通过学习和使用二叉树的遍历算法，我深深地体会到了算法和数据结构的重要性。
已知前序（后序）遍历序列和中序遍历序列构建二叉树（Leetcode相关题目）
已知前序（后序）遍历序列和中序遍历序列构建⼆叉树（Leetcode相关题⽬）1.⽂字描述：已知⼀颗⼆叉树的前序（后序）遍历序列和中序遍历序列，如何构建这棵⼆叉树？以前序为例⼦：前序遍历序列：ABCDEF中序遍历序列：CBDAEF前序遍历先访问根节点，因此前序遍历序列的第⼀个字母肯定就是根节点，即A是根节点；然后，由于中序遍历先访问左⼦树，再访问根节点，最后访问右⼦树，所以我们找到中序遍历中A的位置，然后A左边的字母就是左⼦树了，也就是CBD是根节点的左⼦树；同样的，得到EF为根节点的右⼦树。
将前序遍历序列分成BCD和EF，分别对左⼦树和右⼦树应⽤同样的⽅法，递归下去，⼆叉树就成功构建好了。
如下图：假如已知的是中序和后序遍历的序列，原理也⼀样。
由于后序是先访问左⼦树，然后访问右⼦树，最后访问根节点，因此我们确定后序遍历序列的最后⼀个字母为根节点。
其他步骤⼀样，⽤中序遍历序列找出两棵⼦树，再进⾏同样的操作。
2.代码实现：（1）已知前序和中序：Leetcode题⽬：105 Construct Binary Tree from Preorder and Inorder Traversal（https:///problems/construct-binary-tree-from-preorder-and-inorder-traversal/description/）代码：class Solution {public:TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {return buildTree(preorder, inorder, 0, preorder.size() - 1, 0, inorder.size() - 1);}TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder, int preStart, int preEnd, int inStart, int inEnd) {if (preStart > preEnd || inStart > inEnd) return NULL;TreeNode *res;res = new TreeNode(preorder[preStart]);int flag;for (int i = inStart; i <= inEnd; i++) {if (preorder[preStart] == inorder[i]) {flag = i;break;}}res->left = buildTree(preorder, inorder, preStart + 1, preStart + flag - inStart, inStart, flag - 1);res->right = buildTree(preorder, inorder, preStart + flag - inStart + 1, preEnd, flag + 1, inEnd);return res;}};⼀开始我采⽤的做法是遇到的每棵⼦树都⽤新的vector数组来存放它的中序和前序遍历序列，但这样⼜浪费空间⼜增加时间，我们只要⽤原来的vector数组就可以了。
前序序列中序序列后序序列的规律
标题：前序序列、中序序列和后序序列的规律分析1.概述前序序列、中序序列和后序序列是树的三种遍历方式，它们分别描述了在树结构中节点的访问顺序。
这三种遍历方式具有一定的规律，本文将对这些规律进行分析和总结。
2.前序序列、中序序列和后序序列的定义2.1 前序序列：节点的访问顺序是先访问根节点，然后依次访问左子树和右子树。
2.2 中序序列：节点的访问顺序是先访问左子树，然后访问根节点，最后访问右子树。
2.3 后序序列：节点的访问顺序是先访问左子树，然后访问右子树，最后访问根节点。
3.前序序列、中序序列和后序序列的规律分析3.1 规律一：对于任意一颗树，它的前序序列中的第一个节点必定是根节点。
3.2 规律二：对于任意一颗树，它的中序序列中，根节点的位置将左右子树分割开来。
3.3 规律三：对于任意一颗树，它的后序序列中的最后一个节点必定是根节点。
3.4 规律四：对于同一颗树，其前序序列和后序序列的第二个节点是该树的左子树的根节点。
4.应用举例4.1 求解建立二叉树4.1.1 根据前序序列和中序序列建立二叉树4.1.2 根据中序序列和后序序列建立二叉树4.2 根据前序序列和后序序列求解树的唯一性5.总结前序序列、中序序列和后序序列的规律分析，有助于我们更好地理解树的结构和遍历方式，从而在树的操作中提供了很好的指导。
在实际应用中，可根据这些规律来建立二叉树，求解树的唯一性等问题。
希望通过对这些规律的深入理解，能够更加灵活地应用于相关领域的问题解决中。
6.参考文献[1] 《数据结构与算法分析》，作者：Mark Allen Weiss[2] 《算法导论》，作者：Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, Clifford Stein致谢感谢所有对本文撰写提供过帮助的人，包括对数据结构和算法有深入研究的学者们，以及对本文提出宝贵意见和建议的朋友们。
数据结构先序中序后序理解
数据结构先序中序后序理解数据结构是计算机科学中的重要概念之一，它是指一组数据的组织方式以及对这组数据进行操作的方法。
在学习数据结构的过程中，我们经常会遇到先序、中序和后序这三个概念。
它们是用来描述二叉树的遍历方式的，也可以用来表示表达式的计算顺序。
本文将从先序、中序和后序这三个角度来解释数据结构的含义和应用。
一、先序遍历先序遍历是指按照根节点、左子树、右子树的顺序访问二叉树的节点。
在先序遍历中，我们首先访问根节点，然后递归地遍历左子树和右子树。
先序遍历的应用非常广泛，比如在文件系统的目录结构中，我们可以使用先序遍历来列出所有的文件和文件夹。
二、中序遍历中序遍历是指按照左子树、根节点、右子树的顺序访问二叉树的节点。
在中序遍历中，我们首先递归地遍历左子树，然后访问根节点，最后再递归地遍历右子树。
中序遍历在二叉搜索树的操作中非常常见，它可以按照从小到大的顺序输出二叉搜索树中的元素。
三、后序遍历后序遍历是指按照左子树、右子树、根节点的顺序访问二叉树的节点。
在后序遍历中，我们首先递归地遍历左子树和右子树，最后访问根节点。
后序遍历常用于对二叉树进行一些计算操作，比如计算二叉树的深度、判断二叉树是否对称等。
除了用于二叉树的遍历，先序、中序和后序还可以用来表示表达式的计算顺序。
在数学表达式中，运算符和操作数之间的顺序非常重要，它决定了表达式的计算结果。
先序、中序和后序可以用来表示运算符的位置，从而决定表达式的计算顺序。
先序表示法中，运算符位于操作数之前，如"+ 3 4"表示加法运算。
中序表示法中，运算符位于操作数之间，如"3 + 4"表示加法运算。
后序表示法中，运算符位于操作数之后，如"3 4 +"表示加法运算。
不同的表示法对应着不同的计算顺序，但它们都能得到相同的结果。
先序、中序和后序在数据结构中有着广泛的应用。
它们不仅仅是一种遍历方式，还可以表示表达式的计算顺序。
前序表达式中序表达式后序表达式
前序表达式中序表达式后序表达式前序表达式 , 中序表达式 , 后序表达式中序表达式中序表达式即我们⽇常使⽤的表达式，从左往右阅读，结构清晰，但是需要括号改变优先级，对计算机不友好eg：(1+4)*3+10/5，2*3/(2-1)+3*(4-1)前序表达式（波兰表⽰法Polish notation，或波兰记法）前序表达式的特点是操作符置于操作数前⾯，如果操作符的元数（+是⼆元操作符，故元数是2），则语法上不需要括号仍然能被⽆歧义的解释，不需要⼝号改变优先级。
eg：中序表达式: (1+4)*3+10/5前序表达式: + * + 1 4 3 / 10 5前序表达式的计算：eg：+ * + 1 4 3 / 10 5step1： 10 / 5 => 2new expression： + * + 1 4 3 2step2： 1 + 4 => 5new expression： + * 5 3 2step3： 5 * 3 => 15new expression： + 15 2step4： 15 + 2 => 17前序表达式的求值：⾸先要从右⾄左扫描表达式，从右边第⼀个字符开始判断，如果当前字符是数字则继续扫描，如果当前字符是运算符，将运算符右边最近的两个数字做运算，结果作为新的字符记录下来。
⼀直扫描到表达式的最左端时，最后运算的值也就是表达式的值。
后序表达式（逆波兰表⽰法（Reverse Polish notation，RPN，或逆波兰记法）后序表达式所有的操作符置于操作数后⾯，因此也被称为后缀表⽰法。
逆波兰表⽰法不需要括号标识操作符的优先级。
eg：中序表达式: (1+4)*3+10/5后序表达式: 1 4 + 3 * 10 5 / +后序表达式的计算：eg：1 4 + 3 * 10 5 / +step1： 1 + 4 => 5new expression： 5 3 * 10 5 / +step2： 5 * 3 => 15new expression： 15 10 5 / +step3： 10 / 5 => 2new expression： 15 2 +step4： 15 + 2 => 17后序表达式的求值：后序表达式的求值和前序表达式⼗分相似，后序表达式是从左⾄右扫描表达式，从左边第⼀个字符开始判断，如果的那个字符是数字继续扫描，如果是运算符，将运算符左边最近的两个数字做运算，结果作为新的字符记录下来。
前序后序中序详细讲解
前序后序中序详细讲解1.引言1.1 概述在数据结构与算法中，前序、中序和后序是遍历二叉树的三种基本方式之一。
它们是一种递归和迭代算法，用于按照特定的顺序访问二叉树的所有节点。
通过遍历二叉树，我们可以获取有关树的结构和节点之间关系的重要信息。
前序遍历是指先访问根节点，然后递归地访问左子树，最后递归地访问右子树。
中序遍历是指先递归地访问左子树，然后访问根节点，最后递归地访问右子树。
后序遍历是指先递归地访问左子树，然后递归地访问右子树，最后访问根节点。
它们的不同之处在于访问根节点的时机不同。
前序遍历可以帮助我们构建二叉树的镜像，查找特定节点，或者获取树的深度等信息。
中序遍历可以帮助我们按照节点的大小顺序输出树的节点，或者查找二叉搜索树中的某个节点。
后序遍历常用于删除二叉树或者释放二叉树的内存空间。
在实际应用中，前序、中序和后序遍历算法有着广泛的应用。
它们可以用于解决树相关的问题，例如在Web开发中，树结构的遍历算法可以用于生成网页导航栏或者搜索树结构中的某个节点。
在图像处理中，前序遍历可以用于图像压缩或者图像识别。
另外，前序和后序遍历算法还可以用于表达式求值和编译原理中的语法分析等领域。
综上所述，前序、中序和后序遍历算法是遍历二叉树的重要方式，它们在解决各种与树有关的问题中扮演着关键的角色。
通过深入理解和应用这些遍历算法，我们可以更好地理解和利用二叉树的结构特性，并且能够解决更加复杂的问题。
1.2文章结构文章结构是指文章中各个部分的布局和组织方式。
一个良好的文章结构可以使读者更好地理解和理解文章的内容。
本文将详细讲解前序、中序和后序三个部分的内容和应用。
首先，本文将在引言部分概述整篇文章的内容，并介绍文章的结构和目的。
接下来，正文部分将分为三个小节，分别对前序、中序和后序进行详细讲解。
在前序讲解部分，我们将定义和解释前序的意义，并介绍前序在实际应用中的场景。
通过详细的解释和实例，读者将能更好地理解前序的概念和用途。
数据结构二叉树先序中序后序考研题目
数据结构二叉树先序中序后序考研题目在考研所涉及的数据结构中，二叉树以及与之相关的先序、中序和后序遍历是一个重要的考察点。
通过对二叉树的各种遍历方式的理解和掌握，可以帮助考生更好地理解树这个数据结构，提高解题的效率和正确率。
本文将针对数据结构中关于二叉树先序、中序和后序遍历的考研题目进行深入探讨，并希望能为考生提供一些帮助和启发。
一、先序、中序和后序遍历的概念在开始具体讨论考研题目之前，我们先来回顾一下先序、中序和后序遍历的概念。
在二叉树中，所谓的先序、中序和后序遍历，是指对二叉树中的节点进行遍历的顺序方式。
1. 先序遍历：先访问根节点，然后依次递归地访问左子树和右子树。
在遍历过程中，对于任一节点，先访问该节点，然后再访问其左右子树。
2. 中序遍历：先递归地访问左子树，然后访问根节点，最后再递归地访问右子树。
在遍历过程中，对于任一节点，先访问其左子树，然后访问该节点，最后再访问其右子树。
3. 后序遍历：先递归地访问左子树，然后再递归地访问右子树，最后再访问根节点。
在遍历过程中，对于任一节点，先访问其左右子树，然后再访问该节点。
二、考研题目解析1. 题目一：给出一个二叉树的中序遍历和后序遍历序列，构建该二叉树。
这是一个典型的二叉树重建题目，考查对中序和后序遍历结果的理解和利用。
解题的关键在于根据后序遍历序列确定根节点，在中序遍历序列中找到对应的根节点位置，然后再将中序遍历序列分为左右两个子树部分，分别递归构建左右子树。
考生需要对二叉树遍历的特点有清晰的认识，以及对递归构建树结构有一定的掌握。
2. 题目二：给出一个二叉树的先序遍历和中序遍历序列，构建该二叉树。
这个题目与上一个题目相似，同样是考察对二叉树重建的理解和应用。
解题思路也类似，首先根据先序遍历的结果确定根节点，在中序遍历序列中找到对应的根节点位置，然后递归构建左右子树。
需要注意的是，先序遍历序列的第一个元素即为根节点，而中序遍历序列中根节点的左边是左子树，右边是右子树。
根据先序遍历求中序遍历c语言代码
根据先序遍历求中序遍历c语言代码由于只给出了先序遍历，无法确定二叉树的结构，所以无法直接计算中序遍历。
需要先通过先序遍历构建出二叉树，再通过中序遍历计算。
以下是构建二叉树的c语言代码示例：```c。
#include <stdio.h>。
#include <stdlib.h>。
typedef struct TreeNode 。
int val;。
struct TreeNode* left;。
struct TreeNode* right;。
} TreeNode;。
TreeNode* rebuildTree(int* preorder, int size) 。
if (size == 0) 。
return NULL;。
}。
TreeNode* root = (TreeNode*)malloc(sizeof(TreeNode));。
root->val = preorder[0];。
int i = 1;。
while (i < size && preorder[i] < root->val) 。
i++;。
}。
root->left = rebuildTree(preorder + 1, i - 1);。
root->right = rebuildTree(preorder + i, size - i);。
return root;。
}。
```。
其中，`rebuildTree`函数接受先序遍历数组和数组长度，返回构建出的二叉树的根节点。
具体实现为：1.如果数组长度为0，返回NULL。
2.创建一个根节点，值为数组第一个元素。
3.从数组第二个元素开始遍历，找到第一个大于根节点值的元素的下标i。
4. 递归调用`rebuildTree`函数，传入左子数组（第二个元素到i-1）和右子数组（i到末尾），分别得到左子树和右子树的根节点。
5. 将左右子树根节点分别赋值给根节点的`left`和`right`指针，返回根节点。
数据结构先序中序后序理解
数据结构先序中序后序理解数据结构是计算机科学中非常重要的概念之一，它是指一种组织和存储数据的方式。
在程序设计中，合理选择和使用数据结构是提高程序性能和效率的关键。
而在数据结构中，先序、中序和后序是三种常见的遍历方式，它们分别表示对树形结构中节点的访问顺序。
本文将从先序、中序和后序三个方面来探讨数据结构的相关概念和应用。
一、先序遍历先序遍历是一种树遍历的方法，它的访问顺序是先访问根节点，然后访问左子树，最后访问右子树。
在先序遍历中，我们可以通过递归或者使用栈的方式来实现。
先序遍历的应用非常广泛，比如在二叉树的前序遍历中，我们可以利用先序遍历的方式实现树的复制、树的序列化和反序列化等操作。
先序遍历还可以用于解决一些与树相关的问题，比如求树的深度、判断两棵树是否相等等。
二、中序遍历中序遍历是一种树遍历的方法，它的访问顺序是先访问左子树，然后访问根节点，最后访问右子树。
中序遍历同样可以通过递归或者使用栈的方式来实现。
中序遍历的一个重要应用是对二叉搜索树进行排序，因为中序遍历得到的序列是有序的。
此外，中序遍历还可以用于解决一些与树相关的问题，比如查找树中的某个元素、判断一个序列是否是二叉搜索树的后序遍历等。
三、后序遍历后序遍历是一种树遍历的方法，它的访问顺序是先访问左子树，然后访问右子树，最后访问根节点。
后序遍历同样可以通过递归或者使用栈的方式来实现。
后序遍历的一个重要应用是在二叉树中计算表达式的值，因为后序遍历可以保证操作符的顺序正确。
此外，后序遍历还可以用于解决一些与树相关的问题，比如计算树的路径和、判断一个序列是否是二叉搜索树的先序遍历等。
先序、中序和后序是三种常见的树遍历方式，它们分别表示对树形结构中节点的访问顺序。
在程序设计中，我们可以根据具体的需求选择合适的遍历方式来解决问题。
无论是先序、中序还是后序，它们都有各自的特点和应用场景。
通过深入理解和灵活运用这些遍历方式，我们可以更好地处理和组织数据，提高程序的性能和效率。
树的遍历算法介绍前序中序和后序遍历算法
树的遍历算法介绍前序中序和后序遍历算法树的遍历算法介绍——前序、中序和后序遍历算法树是一种常用的数据结构，具有分层次、有序且具备递归性质的特点。
树的遍历算法是指按照特定的顺序访问树的每个节点，以获取或处理节点的数据。
在树的遍历算法中，最常用且基础的有前序、中序和后序三种遍历方式。
本文将分别介绍这三种遍历算法的定义、特点和应用场景。
一、前序遍历算法前序遍历算法是指先根据根节点的值，然后按照“左子树-右子树”的顺序递归遍历每个节点。
具体遍历步骤如下：1. 访问当前节点；2. 递归调用前序遍历左子树；3. 递归调用前序遍历右子树。
前序遍历算法的特点是以根节点为起点，先访问根节点，再遍历其左子树，最后遍历其右子树。
前序遍历算法常用于树的构建、拷贝或输出等操作。
二、中序遍历算法中序遍历算法是指先按照“左子树-根节点-右子树”的顺序递归遍历每个节点。
具体遍历步骤如下：1. 递归调用中序遍历左子树；2. 访问当前节点；3. 递归调用中序遍历右子树。
中序遍历算法的特点是先遍历左子树，然后访问根节点，最后遍历右子树。
中序遍历算法常用于树的搜索、排序以及构建有序的输出结果等操作。
三、后序遍历算法后序遍历算法是指先按照“左子树-右子树-根节点”的顺序递归遍历每个节点。
具体遍历步骤如下：1. 递归调用后序遍历左子树；2. 递归调用后序遍历右子树；3. 访问当前节点。
后序遍历算法的特点是先遍历左子树，然后遍历右子树，最后访问根节点。
后序遍历算法常用于树的删除、释放内存以及计算表达式等操作。
综上所述，前序、中序和后序遍历算法分别具有不同的特点和应用场景。
在实际应用中，根据具体的需求来选择合适的遍历方式。
在一些特殊情况下，还可以使用层序遍历算法或其他变种的遍历算法来满足实际需要。
总结树的遍历算法包括前序、中序和后序三种遍历方式，它们分别以不同的访问顺序递归遍历树的节点。
前序遍历先访问根节点，后序遍历先遍历子树再访问根节点，中序遍历则是按照左子树-根节点-右子树的顺序遍历。
先序 中序 后序
先序中序后序首先，我们看看前序、中序、后序遍历的特性：前序遍历：1、访问根节点2、前序遍历左子树3、前序遍历右子树（个人觉得这个命名略微有误导性，因为前序的“前”容易让人误会成树的最前边（视觉上的左边）。
记住前序遍历就是最直接（直觉上的）遍历，中左右）中序遍历：1、中序遍历左子树2、访问根节点3、中序遍历右子树（同样是有误导性的名字。
遍历顺序，左中右）后序遍历：1、后序遍历左子树2、后序遍历右子树3、访问根节点（同样是有误导性的名字，“后”字没有任何意义，所有二叉树的遍历，左边一定在右边的之前进行遍历。
遍历顺序，左右中。
）最近又想出一个帮助记忆的方法，把先、中、后当做是“中”的访问时序。
如先序就是“中”排在最前面（中左右），以此类推。
接着，铭记总的方针1、找到根节点，确定左子树，确定右子树（最重要）2、对左子树进行递归分析3、对右子树进行递归分析一、已知先序、中序遍历，求后序遍历例：先序遍历:GDAFEMHZ中序遍历:ADEFGHMZ思路分析：1、根据先序遍历的特点，中左右，第一个元素一定是根节点，所以立刻确定G是根节点。
2、既然确定了G是根节点，再根据中序遍历的特点，左中右，在根节点G之前的ADEF就是左子树，根节点G之后的HMZ就是右子树。
3、接着分析左子树（思路和第1，2步一样）。
把左子树的所有元素（即ADEF这四个元素）在先序遍历和中序遍历中的顺序拿出来进行比较。
先序的顺序是DAFE（中左右），中序遍历是ADEF（左中右）。
通过先序特点得出D是左子树的节点，通过中序特点确定唯一一个在D左边的A是左子树中的左叶子，右边的是EF。
观察EF的相对位置，在先序（中左右）是FE，在中序（左中右）EF，所以得出EF的关系是左中。
到此得出左子树的形状4、接着分析右子树（思路和第1，2步一样），把右子树的元素（HMZ）在先序遍历和中序遍历中的顺序拿出来进行比较。
先序的顺序是MHZ（中左右），中序遍历是HMZ（左中右）。
数据结构-二叉树-（先序｜后序）+中序求（后序｜先序）笔记
数据结构-⼆叉树-（先序｜后序）+中序求（后序｜先序）笔记//已知先序中序#include <iostream>#include <string>using namespace std;struct Node{char data;Node *left;Node *right;};Node *search(char *pre,char *in,int length){if (length==0)return NULL;else {Node *node=new Node;node->data=*pre; //根结点int index;for(index=0;index<length;index++){if(in[index]==*pre) break; //在中序中定位根结点}node->left=search(in,pre+1,index);//在先序中左⼦树的根节点是pre的下⼀个即为pre+1//把中序中根结点左侧的部分当作左⼦树的先序遍历//index计数出左树的lengthnode->right=search(in+index+1,pre+index+1,length-(index+1));//右树的length为总length减去（index+1根结点）cout<<node->data<<endl；return node;}}int main(){char *pre="EBADCFHGIKJ";char *in="ABCDEFGHIJ";search(pre,in,10);return0;}以上程序是可⾏的已已知先序和中序为例，先通过先序求得根结点，再在中序中定位根结点，得知左右⼦树，进⽽能够在先序中分开左右⼦树。
后序加中序同理。
核⼼步骤我认为是找到根结点后定位的这⼀步，是把整棵树化解开来的基础。
二叉树的遍历（前序、中序、后序、已知前中序求后序、已知中后序求前序）
⼆叉树的遍历（前序、中序、后序、已知前中序求后序、已知中后序求前序）之前的⼀篇随笔（）只对⼆叉树的遍历进⾏了笼统的描述，这篇随笔重点对前、中、后序的遍历顺序进⾏分析⼆叉树的遍历⼆叉树的深度优先遍历可细分为前序遍历、中序遍历、后序遍历，这三种遍历可以⽤递归实现（本篇随笔主要分析递归实现），也可使⽤⾮递归实现的前序遍历：根节点->左⼦树->右⼦树（根->左->右）中序遍历：左⼦树->根节点->右⼦树（左->根->右）后序遍历：左⼦树->右⼦树->根节点（左->右->根）在进⾏已知两种遍历顺序求另⼀种遍历顺序前，先看⼀下不同遍历顺序对应的代码前序遍历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. 先序遍历：
先序遍历是指先访问根节点，然后递归地对左子树进行先序遍历，最后递归地对右子树进行先序遍历。
因此，先序遍历的顺序是根-左-右。
2. 中序遍历：
中序遍历是指先递归地对左子树进行中序遍历，然后访问根节点，最后递归地对右子树进行中序遍历。
因此，中序遍历的顺序是左-根-右。
3. 后序遍历：
后序遍历是指先递归地对左子树进行后序遍历，然后递归地
对右子树进行后序遍历，最后访问根节点。
因此，后序遍历的顺序
是左-右-根。
这三种遍历算法都是基于递归的思想实现的，它们在不同的应
用场景下都有各自的优势。
例如，先序遍历常用于复制整棵树，中
序遍历常用于二叉搜索树的查找操作，后序遍历常用于计算表达式
树的值等。
除了递归实现外，这三种遍历算法也可以通过迭代的方式实现，通常使用栈来辅助实现。
在实际应用中，根据具体的问题和数据结
构的特点，选择合适的遍历算法可以提高算法的效率和准确性。
总之，先序、中序和后序遍历算法是树结构中常用的基本算法，它们在数据结构和算法领域具有重要的意义，对于理解树的结构和
实现树相关的操作非常重要。
希望以上介绍能够帮助你更好地理解
这三种遍历算法。
已知前序中序求后续；已知中序后序求前序；
已知前序中序求后续；已知中序后序求前序；后序遍历与中序遍历，求前序遍历⾸先，⼀点基本常识，给你⼀个后序遍历，那么最后⼀个就是根（同理前序遍历，第⼀个是根）那么这个算法的核⼼就是不断的求根；接下来我⽤⼀个实例来说明怎样进⾏求根：例如以上，给出后序遍历和中序遍历，求前序遍历⾸先根据后序遍历的最后⼀个就是根，可以知道4是根，以此可将前序和后序都分为三部分；看上图，在前序遍历中，绿⾊框中的4为根，则在4的左边，红⾊框的就为以4为根的左⼦树，黄⾊框的就是以4为根的右⼦树。
则在找到4这个根之后，此题可以转换为两个⼦问题，⼀下：求红框的前序列，求黄框的前序列。
之后就可以递归了；我们再回到上⾯的图，再进⾏⼀个⼩⼩的思考；观察前序遍历和后序遍历，都可以由三部分组成，红框的左⼦树，黄框的右⼦树以及绿框的根；那么，在进⾏函数递归的时候，重点就是怎样计算各个部分的下标起始，来让程序可以递归下去；上代码：⽅法⼀：#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;}上⾯代码的关键是，⽤substr函数将字符串进⾏切割，以此来达到分离字符串三部分的操作⽐较好理解。
数据结构——已知先序中序求后序，已知中序后序求先序
数据结构——已知先序中序求后序，已知中序后序求先序 总结下⼆叉树的已知两种遍历⽅式求第三种遍历顺序的⽅法，已知先序和中序遍历或者后序与中序遍历后⼆叉树是唯⼀确定的，下⾯介绍怎么求出第三种遍历顺序。
先序遍历顺序为：根结点——左⼦结点——右⼦结点，中序遍历为：左⼦结点——根结点——右⼦结点，我们注意到，先序遍历的第⼀个元素就是⼆叉树根结点，我们在中序遍历中以该元素分为左右两部分，则左边为左⼦树，右边为右⼦树，递归即可还原⼆叉树，这个过程中可直接输出后序遍历的顺序。
同理，可以⽤后序与中序还原出先序遍历的顺序。
代码及测试数据如下：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 }。
树的先序、中序、后序遍历及其代码、层序遍历
树的先序、中序、后序遍历及其代码、层序遍历树是一种重要的数据结构，在计算机科学领域中有广泛的应用。
树的遍历是一种对树进行访问节点的方式，其中包括先序遍历、中序遍历、后序遍历以及层序遍历。
本文将详细介绍这四种遍历方式，并给出相应的代码示例，以帮助读者理解和使用。
首先，我们来了解一下树的基本概念。
树是由节点和边组成的一种非线性数据结构，其中一个节点充当树的根节点，其他节点通过边连接在一起。
每个节点可以有零个或多个子节点，而子节点又可以有自己的子节点，这样就形成了树的层级结构。
树的先序遍历是指首先访问根节点，然后按照先序遍历的方式依次访问左子树和右子树。
具体代码如下：```class TreeNode:def __init__(self, val=0, left=None, right=None):self.val = valself.left = leftself.right = rightdef preorderTraversal(root):if root is None:return []result = []result.append(root.val)result += preorderTraversal(root.left)result += preorderTraversal(root.right)return result```树的中序遍历是指按照先序遍历的方式访问左子树，然后访问根节点，最后访问右子树。
具体代码如下：```def inorderTraversal(root):if root is None:return []result = []result += inorderTraversal(root.left)result.append(root.val)result += inorderTraversal(root.right)return result```树的后序遍历是指按照先序遍历的方式依次访问左子树和右子树，最后访问根节点。
树的遍历算法前序中序和后序
树的遍历算法前序中序和后序树的遍历算法：前序、中序和后序树是一种常用的数据结构，在计算机科学中有广泛的应用。
而树的遍历算法是对树的节点进行访问的过程，一般有三种方式：前序遍历、中序遍历和后序遍历。
本文将详细介绍这三种遍历算法的原理和实现方法。
一、前序遍历算法前序遍历算法是指先访问根节点，然后递归地访问左子树，最后递归地访问右子树。
以以下树为例：```A/ \B C/ \ \D E F```按照前序遍历算法，遍历结果为：A - B - D - E - C - F。
二、中序遍历算法中序遍历算法是指先递归地访问左子树，然后访问根节点，最后递归地访问右子树。
以以上树为例，中序遍历结果为：D - B - E - A - C - F。
三、后序遍历算法后序遍历算法是指先递归地访问左子树，然后递归地访问右子树，最后访问根节点。
以以上树为例，后序遍历结果为：D - E - B - F - C - A。
以上是树的遍历算法的基本概念和实现方法。
接下来，我们将通过代码示例来更加具体地说明这三种遍历算法的实现。
```python# 定义树的节点类class Node:def __init__(self, data):self.data = dataself.left = Noneself.right = None# 前序遍历def pre_order_traversal(node):if node is not None:print(node.data)pre_order_traversal(node.left) pre_order_traversal(node.right) # 中序遍历def in_order_traversal(node):if node is not None:in_order_traversal(node.left)print(node.data)in_order_traversal(node.right) # 后序遍历def post_order_traversal(node):if node is not None:post_order_traversal(node.left) post_order_traversal(node.right) print(node.data)# 构建示例树root = Node('A')root.left = Node('B')root.right = Node('C')root.left.left = Node('D')root.left.right = Node('E')root.right.right = Node('F')# 执行前序遍历print("前序遍历结果：")pre_order_traversal(root)# 执行中序遍历print("中序遍历结果：")in_order_traversal(root)# 执行后序遍历print("后序遍历结果：")post_order_traversal(root)```运行以上代码，将得到以下输出结果：```前序遍历结果：ABDECF中序遍历结果：DBEACF后序遍历结果：DEBFCA```通过以上代码和输出结果，我们可以清晰地看到前序、中序和后序遍历算法的实现和运行情况。
二叉树前序、中序遍历的递归算法
二叉树前序、中序遍历的递归算法二叉树的前序遍历和中序遍历是二叉树遍历的两种常见方式。
在讲解这两种遍历算法之前，我们先来了解下二叉树的概念。
二叉树是一种常见的树型结构，它由若干个节点组成，每个节点最多有两个子节点，分别称为左子节点和右子节点。
一个二叉树的节点可以为空，即没有子节点，此时我们称为空节点。
在二叉树中，每个节点包含一个值和两个指向子节点的指针，分别指向左子节点和右子节点。
每个节点的顺序遍历方式有三种，分别是前序遍历、中序遍历和后序遍历。
前序遍历的顺序是先访问根节点，再访问左子节点，最后访问右子节点。
中序遍历的顺序是先访问左子节点，再访问根节点，最后访问右子节点。
现在我们就来分别讲解一下二叉树的前序遍历和中序遍历的递归算法。
首先是前序遍历算法。
前序遍历算法的递归实现很简单，可以按照以下步骤进行：1.如果当前节点为空，直接返回。
2.访问当前节点的值。
3.对当前节点的左子节点进行前序遍历。
4.对当前节点的右子节点进行前序遍历。
下面是前序遍历算法的完整代码实现：```pythondef preorder_traversal(root):if root is None:returnprint(root.val)preorder_traversal(root.left)preorder_traversal(root.right)```其中，`root`表示当前节点，`root.val`表示该节点的值。
`root.left`表示左子节点，`root.right`表示右子节点。
接下来是中序遍历算法。
中序遍历算法的递归实现也很简单，可以按照以下步骤进行：1.如果当前节点为空，直接返回。
2.对当前节点的左子节点进行中序遍历。
3.访问当前节点的值。
4.对当前节点的右子节点进行中序遍历。
下面是中序遍历算法的完整代码实现：```pythondef inorder_traversal(root):if root is None:returninorder_traversal(root.left)print(root.val)inorder_traversal(root.right)```同样，`root`表示当前节点，`root.val`表示该节点的值。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
HDU1710根据前序和后序求出中序
题意：根据前序和中序写出后序前序：1 2 4 7 3 5 8 9 6 中序：4 7 2 1 8 5 9 3 6 求出后序：7 4 2 8 9 5 6 3 1
首先得知道是如何前序遍历、中序遍历、后序遍历的，自己上网查下，我在这里就不多说了思路：第一步：根据前序可知根节点为1；第二步：根据中序可知4 7 2为根节点1的左子树和8 5 9 3 6为根节点1的右子树；第三步：递归实现，把4 7 2当做新的一棵树和8 5 9 3 6也当做新的一棵树；第四步：在递归的过程中输出后序。
代码实现
//根据前序和中序遍历写出后序遍历
#include<iostream>
using namespace std;
int t1[1001],t2[1001];
void sousuo(int a,int b,int n,int flag)
{
if(n==1)//如果存在左子树或右子树就直接输出
{
printf("%d ",t1[a]);
return ;
}
else if(n<=0)//如果不存在左子树或右子树就返回上一层
return ;
int i;//继续罚分为左子树和右子树
for(i=0;t1[a]!=t2[b+i];i++) ;//找到罚分点也就是根节点 sousuo(a+1,b,i,0);//左子树的遍历
sousuo(a+i+1,b+i+1,n-i-1,0);//右子树的遍历
if(flag==1)//最原始的跟节点
printf("%d",t1[a]);
else//一般的根节点
printf("%d ",t1[a]);
}
int main()
{
int n,i;
while(scanf("%d",&n)!=EOF)
{
for(i=1;i<=n;i++)
scanf("%d",&t1[i]);//t1中存的是前序
for(i=1;i<=n;i++)//t2中存的中序
scanf("%d",&t2[i]);
sousuo(1,1,n,1);
printf("\n");
}
return0;
}
这是根据前序和中序写出后序，我现在把题意变成根据后序和中序写出前序后序：7 4 2 8 9 5 6 3 1 中序：4 7 2 1 8 5 9 3 6 求出前序：1 2 4 7 3 5 8 9 6
代码实现：
//根据后序和中序遍历写出前序
#include<iostream>
using namespace std;
int t1[1001],t2[1001];
void sousuo(int a,int b,int n,int flag)
{
int i;
if(n==1)//存在左子树或右子树，进行遍历即可
{
printf(" %d",t1[a]);
return ;
}
else if(n<=0)//不存在左子树或者右子树，则返回上一层
return ;
if(flag==1)//最原始的根节点
printf("%d",t1[a]);
else//一般的根节点
printf(" %d",t1[a]);
for(i=0;t1[a]!=t2[b+i];i++) ;//找出根节点
sousuo(a-n+i,b,i,0);//左子树的遍历
sousuo(a-1,b+i+1,n-i-1,0);//右子树的遍历
}
int main()
{
int n,i;
while(scanf("%d",&n)!=EOF)
{
for(i=1;i<=n;i++)
scanf("%d",&t1[i]);//t1中存的是后序
for(i=1;i<=n;i++)
scanf("%d",&t2[i]);//t2中存的是中序
sousuo(n,1,n,1);//因为后序最后遍历的是根节点,所以这里和前面的开始点不同，注意一下
printf("\n"); }
return0;
}。