二叉树已知先序中序求后序
前序遍历和后续遍历
首先明确：一颗二叉树的前序遍历=根节点+左子树前序遍历+右子树前序遍历
一颗二叉树的中序遍历=左子树中序遍历+根节点+右子树中序遍历
那么从前序遍历中取第一个点，就是根节点，知道了根节点，就可以找到中序遍历中跟节点的位置，那么就可以在中序遍历中找到左子树和右子树。
首先，我们看看前序、中序、后序遍历的特性：
前序遍历：
1.访问根节点
2.前序遍历左子树
3.前序遍历右子树
中序遍历：
1.中序遍历左子树
2.访问根节点
3.中序遍历右子树
后序遍历：
1.后序遍历左子树
2.后序遍历右子树
3.访问根节点
好了，先说说用前序遍历和中序遍历求后序遍历
假设前序遍历为adbgcefh, 中序遍历为dgbaechf
前序遍历是先访问根节点，然后再访问子树的，而中序遍历则先访问左子树再访问根节点
那么把前序的a 取出来，然后查找a 在中序遍历中的位置就得到dgb a echf
那么我们就知道dgb 是左子树echf 是右子树，因为数量要吻合
所以前序中相应的dbg 是左子树cefh 是右子树
然后就变成了一个递归的过程，具体代码如下：
而已知后序遍历和中序遍历求前序遍历的过程差不多，但由于后序遍历是最后才访问根节点的所以要从后开始搜索，例如上面的例子，后序遍历为gbdehfca，中序遍历为dgbaechf
后序遍历中的最后一个元素是根节点，a，然后查找中序中a的位置
把中序遍历分成dgb a echf，而因为节点个数要对应
后序遍历分为gbd ehfc a，gbd为左子树，ehfc为右子树，这样又可以递归计算了
其他一些附带的代码上面已经有，这里就不重复贴了，具体代码如下：。
已知一棵二叉树的前序序列为bacdeghf,中序序列为cadbhgef,则后序序列为
已知一棵二叉树的前序序列为bacdeghf,中序序列为cadbhgef,则后序序列为根据二叉树的前序序列bacdeghf和中序序列cadbhgef，可以确定该二叉树的结构。
二叉树是一种特殊的树，它只有左右两个子树，每个节点最多只有两个子节点。
二叉树的前序序列，可以从根节点开始，按照从上到下，从左到右的顺序依次访问每个节点，以根节点b开头的前序序列bacdeghf中，b为根节点，a和c为b的左右子节点，d为a的左子节点，e为a的右子节点，g为c的左子节点，h为c的右子节点。
二叉树的中序序列，可以从左到右依次访问每个节点，从根节点开始，先遍历左子树，再遍历右子树，以根节点b开头的中序序列cadbhgef中，c为b的左子节点，a为c的左子节点，d为a的左子节点，b为d的右子节点，h为b的右子节点，g为h的左子节点，e为g的右子节点。
根据前序序列和中序序列，可以绘制出该二叉树的结构。
其根节点为b，左子节点为c，右子节点为e，c的左子节点为a，a的左子节点为d，d的右子节点为b，e的左子节点为g，g的右子节点为h。
由此可知，该二叉树的后序序列为cdebhgfe，从右向左，从下到上的顺序依次访问每个节点，以根节点b结尾。
由前序序列和中序序列可以直接确定二叉树的结构，而后序序列可以帮助我们更好地理解二叉树的结构。
在许多算法中，后序序列的结构也是非常重要的。
二叉树的前序序列、中序序列和后序序列都是树的一种遍历方式，它们都可以用来确定一棵树的结构，而且这三种遍历方式之间互相转换也是非常方便的。
在计算机科学中，二叉树是一种重要的数据结构，它在图形处理、数据检索等方面有着广泛的应用。
本文综上所述，已知一棵二叉树的前序序列为bacdeghf，中序序列为cadbhgef，根据二叉树的前序序列和中序序列，可以确定该二叉树的结构，其后序序列为cdebhgfe。
二叉树的前序序列、中序序列和后序序列都是树的一种遍历方式，它们都可以用来确定一棵树的结构，而且这三种遍历方式之间互相转换也是非常方便的。
数据结构二叉树先序中序后序考研题目
数据结构二叉树先序中序后序考研题目
以下是一些关于二叉树先序、中序和后序遍历的考研题目：
1. 已知二叉树的先序遍历序列为 "A B D E C F"，中序遍历序列为 "D B E A F C"，请画出该二叉树。
2. 已知二叉树的中序遍历序列为 "D B E A F C"，后序遍历序列为 "D E B F C A"，请画出该二叉树。
3. 给定一棵二叉树的先序遍历序列为 "A B D E F C"，中序遍历序列为 "D B E F A C"，请写出该二叉树的后序遍历序列。
4. 请写出一棵二叉树的先序遍历序列为 "A B D E C F"，中序遍历序列为 "D B E A F C"，后序遍历序列为 "D E B F C A" 的二叉树。
5. 已知一棵二叉树的中序遍历序列为 "D B E A F C"，后序遍历序列为 "D E B F C A"，请写出该二叉树的先序遍历序列。
6. 给定一棵二叉树的先序遍历序列为 "A B D E F C"，后序遍历序列为 "D E F B C A"，请写出该二叉树的中序遍历序列。
以上题目可以帮助你练习理解二叉树的遍历方式及其序列之间的关系。
二叉树的遍历题目及答案
二叉树的遍历题目及答案1. 二叉树的基本组成部分是：根（N）、左子树（L）和右子树（R）。
因而二叉树的遍历次序有六种。
最常用的是三种：前序法（即按N L R次序），后序法（即按L R N 次序）和中序法（也称对称序法，即按L N R次序）。
这三种方法相互之间有关联。
若已知一棵二叉树的前序序列是BEFCGDH，中序序列是FEBGCHD，则它的后序序列必是 F E G H D C B 。
解：法1：先由已知条件画图，再后序遍历得到结果；法2：不画图也能快速得出后序序列，只要找到根的位置特征。
由前序先确定root，由中序先确定左子树。
例如，前序遍历BEFCGDH中，根结点在最前面，是B；则后序遍历中B一定在最后面。
法3：递归计算。
如B在前序序列中第一，中序中在中间（可知左右子树上有哪些元素），则在后序中必为最后。
如法对B的左右子树同样处理，则问题得解。
2.给定二叉树的两种遍历序列，分别是：前序遍历序列：D，A，C，E，B，H，F，G，I；中序遍历序列：D，C，B，E，H，A，G，I，F，试画出二叉树B，并简述由任意二叉树B的前序遍历序列和中序遍历序列求二叉树B的思想方法。
解：方法是：由前序先确定root，由中序可确定root的左、右子树。
然后由其左子树的元素集合和右子树的集合对应前序遍历序列中的元素集合，可继续确定root的左右孩子。
将他们分别作为新的root，不断递归，则所有元素都将被唯一确定，问题得解。
3、当一棵二叉树的前序序列和中序序列分别是HGEDBFCA和EGBDHFAC时，其后序序列必是A. BDEAGFHCB. EBDGACFHC. HGFEDCBAD. HFGDEABC答案：B4. 已知一棵二叉树的前序遍历为ABDECF，中序遍历为DBEAFC，则对该树进行后序遍历得到的序列为______。
A．DEBAFCB．DEFBCAC．DEBCFAD．DEBFCA[解析] 由二叉树前序遍历序列和中序遍历序列可以唯一确定一棵二叉树。
已知二叉树的先序遍历和中序遍历画出该二叉树
已知⼆叉树的先序遍历和中序遍历画出该⼆叉树对⼀棵⼆叉树进⾏遍历，我们可以采取3中顺序进⾏遍历，分别是前序遍历、中序遍历和后序遍历。
这三种⽅式是以访问⽗节点的顺序来进⾏命名的。
假设⽗节点是N，左节点是L，右节点是R，那么对应的访问遍历顺序如下：前序遍历 N－>L－>R中序遍历 L－>N－>R后序遍历 L－>R－>N所以，对于以下这棵树，三种遍历⽅式的结果是前序遍历 ABCDEF中序遍历 CBDAEF后序遍历 CDBFEA已知⼆叉树的前序遍历和中序遍历，如何得到它的后序遍历其实，只要知道其中任意两种遍历的顺序，我们就可以推断出剩下的⼀种遍历⽅式的顺序，这⾥我们只是以：知道前序遍历和中序遍历，推断后序遍历作为例⼦，其他组合⽅式原理是⼀样的。
要完成这个任务，我们⾸先要利⽤以下⼏个特性：特性A，对于前序遍历，第⼀个肯定是根节点；特性B，对于后序遍历，最后⼀个肯定是根节点；特性C，利⽤前序或后序遍历，确定根节点，在中序遍历中，根节点的两边就可以分出左⼦树和右⼦树；特性D，对左⼦树和右⼦树分别做前⾯3点的分析和拆分，相当于做递归，我们就可以重建出完整的⼆叉树；我们以⼀个例⼦做⼀下这个过程，假设：前序遍历的顺序是: CABGHEDF中序遍历的顺序是: GHBACDEF第⼀步，我们根据特性A，可以得知根节点是C，然后，根据特性C，我们知道左⼦树是：GHBA，右⼦树是：DEF。
C/ \GHBA DEF第⼆步，取出左⼦树，左⼦树的前序遍历是：ABGH，中序遍历是：GHBA，根据特性A和C，得出左⼦树的⽗节点是A，并且A没有右⼦树。
C/ \A DEF/GBH第三步，使⽤同样的⽅法，前序是BGH，中序是GHB，得出⽗节点是B，GH是左⼦树,没有右⼦树。
C/ \A DEF/B/GH第四步,前序是GH, 中序是GH, 所以 G是⽗节点, H是右⼦树, 没有左⼦树.C/ \A DEF/B/G\H第四步，回到右⼦树，它的前序是EDF，中序是DEF，依然根据特性A和C，得出⽗节点是E，左右节点是D和F。
数据结构二叉树先序中序后序考研题目
数据结构二叉树先序中序后序考研题目在考研所涉及的数据结构中，二叉树以及与之相关的先序、中序和后序遍历是一个重要的考察点。
通过对二叉树的各种遍历方式的理解和掌握，可以帮助考生更好地理解树这个数据结构，提高解题的效率和正确率。
本文将针对数据结构中关于二叉树先序、中序和后序遍历的考研题目进行深入探讨，并希望能为考生提供一些帮助和启发。
一、先序、中序和后序遍历的概念在开始具体讨论考研题目之前，我们先来回顾一下先序、中序和后序遍历的概念。
在二叉树中，所谓的先序、中序和后序遍历，是指对二叉树中的节点进行遍历的顺序方式。
1. 先序遍历：先访问根节点，然后依次递归地访问左子树和右子树。
在遍历过程中，对于任一节点，先访问该节点，然后再访问其左右子树。
2. 中序遍历：先递归地访问左子树，然后访问根节点，最后再递归地访问右子树。
在遍历过程中，对于任一节点，先访问其左子树，然后访问该节点，最后再访问其右子树。
3. 后序遍历：先递归地访问左子树，然后再递归地访问右子树，最后再访问根节点。
在遍历过程中，对于任一节点，先访问其左右子树，然后再访问该节点。
二、考研题目解析1. 题目一：给出一个二叉树的中序遍历和后序遍历序列，构建该二叉树。
这是一个典型的二叉树重建题目，考查对中序和后序遍历结果的理解和利用。
解题的关键在于根据后序遍历序列确定根节点，在中序遍历序列中找到对应的根节点位置，然后再将中序遍历序列分为左右两个子树部分，分别递归构建左右子树。
考生需要对二叉树遍历的特点有清晰的认识，以及对递归构建树结构有一定的掌握。
2. 题目二：给出一个二叉树的先序遍历和中序遍历序列，构建该二叉树。
这个题目与上一个题目相似，同样是考察对二叉树重建的理解和应用。
解题思路也类似，首先根据先序遍历的结果确定根节点，在中序遍历序列中找到对应的根节点位置，然后递归构建左右子树。
需要注意的是，先序遍历序列的第一个元素即为根节点，而中序遍历序列中根节点的左边是左子树，右边是右子树。
已知二叉树的中序和先序序列,求后序序列
3、递归求解树。将左子树和右子树分别看成一棵二叉树，重复1、2、3步，直到所有的节点完成定位。
二、已知二叉树的后序序列和中序序列，求解树。
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
typedef struct Node /*树结点类型*/
{
int info; /*数据域*/
struct Node* parent; /*父结点*/
struct Node* lchild; /*左孩子结点*/
4、在后序序列LH中最后出现的元素为H，H|L|D|B|EK|A|FCG
5、在后序序列KE中最后出现的元素为E，H|L|D|B|E|K|A|FCG
5、在后序序列FGC中最后出现的元素为C，H|L|D|B|E|K|A|F|C|G
6、所有元素都已经定位，二叉树求解完成。
A
/ \
B C
/ \ / \
D E F G
post_order(root->rchild);
printf("%d ",root->info);
}
}
int main(void)
{
PNode *root;
int pre[50]={1,2,4,8,10,5,9,3,6,7};
int in[ 50]={8,10,4,2,5,9,1,6,3,7} ;
1、确定树的根。树根是当前树中所有元素在后序遍历中最后出现的元素。
二叉树的先序,中序,后序遍历例题
二叉树的先序,中序,后序遍历例题二叉树的先序遍历、中序遍历和后序遍历是三种常见的遍历方式。
以下是相应的例题:1. 先序遍历以下是一个简单的二叉树，请实现先序遍历:```3/1 5/2 4 6```先序遍历的结果应该是:3,1,2,4,5,6。
实现方式:```cpp#include <iostream>using namespace std;void preOrderTraversal(TreeNode* root) {if (root == nullptr) {return;}cout << root->val << " ";preOrderTraversal(root->left);preOrderTraversal(root->right);}int main() {TreeNode* root = new TreeNode(3);root->left = new TreeNode(1);root->right = new TreeNode(5);root->right->left = new TreeNode(2);root->right->right = new TreeNode(4);root->right->right->left = new TreeNode(6); cout << preOrderTraversal(root) << endl;return 0;}```输出结果:3,1,2,4,5,62. 中序遍历以下是一个简单的二叉树，请实现中序遍历:```1/4 2/5 3 6```中序遍历的结果应该是:1,4,2,5,3,6。
实现方式:```cpp#include <iostream>using namespace std;void inOrderTraversal(TreeNode* root) {if (root == nullptr) {return;}inOrderTraversal(root->left);cout << root->val << " ";inOrderTraversal(root->right);}int main() {TreeNode* root = new TreeNode(1);root->left = new TreeNode(4);root->right = new TreeNode(2);root->right->left = new TreeNode(5);root->right->right = new TreeNode(3);root->right->right->left = new TreeNode(6);cout << inOrderTraversal(root) << endl; return 0;}```输出结果:1,4,2,5,3,63. 后序遍历以下是一个简单的二叉树，请实现后序遍历: ```2/4 6/1 3 5```后序遍历的结果应该是:2,4,6,1,3,5。
二叉树前序和中序遍历求后序 表格法
二叉树前序和中序遍历求后序表格法1.概述二叉树是计算机科学中常见的数据结构，它可以用来表示树形结构的数据。
在二叉树的遍历中，前序遍历、中序遍历和后序遍历是三种重要的遍历方式。
本文将介绍如何通过前序遍历和中序遍历的结果来求出二叉树的后序遍历结果，以及如何使用表格法来进行求解。
2.二叉树遍历的概念在二叉树中，前序遍历指的是首先访问根节点，然后再递归地前序遍历左子树和右子树；中序遍历指的是先递归地中序遍历左子树，然后访问根节点，最后再递归地中序遍历右子树；后序遍历指的是先递归地后序遍历左子树和右子树，最后再访问根节点。
在本文中，我们将讨论如何通过前序遍历和中序遍历的结果来求出后序遍历的结果。
3.二叉树的定义我们需要了解二叉树的定义。
二叉树是一种树形结构，它的每个节点最多有两个子节点，分别为左子节点和右子节点。
对于任意一个节点，它的左子树和右子树也分别是二叉树。
如果一个节点没有左子树或者右子树，我们称其为叶子节点。
二叉树一般用递归的方式来定义，并且可以通过链式存储结构或者顺序存储结构来实现。
4.二叉树前序和中序遍历求后序接下来，我们将介绍如何通过二叉树的前序遍历和中序遍历结果来求出后序遍历的结果。
4.1 基本思路我们知道前序遍历的顺序是根节点、左子树、右子树，中序遍历的顺序是左子树、根节点、右子树。
假设我们已经知道了二叉树的前序遍历序列和中序遍历序列，那么我们可以通过这两个序列来确定二叉树的结构。
具体地，我们可以通过前序遍历序列找到根节点，然后在中序遍历序列中找到该根节点的位置，这样就可以确定左子树和右子树的中序遍历序列。
再根据左子树和右子树的节点数目，我们可以在前序遍历序列中确定左子树和右子树的前序遍历序列。
我们可以递归地对左子树和右子树进行求解，直到最终得到二叉树的后序遍历序列。
4.2 具体步骤具体地，通过前序遍历序列和中序遍历序列求后序遍历序列的步骤如下：1）在前序遍历序列中找到根节点2）在中序遍历序列中找到根节点的位置，确定左子树和右子树的中序遍历序列3）计算左子树和右子树的节点数目，确定左子树和右子树的前序遍历序列4）递归地对左子树和右子树进行求解5）最终得到二叉树的后序遍历序列4.3 表格法求解除了上述的基本思路和具体步骤外，我们还可以通过表格法来求解二叉树的后序遍历序列。
前序序列和后续序列确定二叉树
前序序列和后续序列确定⼆叉树⼆叉树：已知前序与后序建树那么我们换⼀种思考⽅式，我们先来看看先序与后序序列的排布规律。
以下⾯这棵树来举例：其先序序列为： 1 2 3 4 6 7 5后序序列为：2 6 7 4 5 3 1⾸先我们要知道：先序序列遍历顺序是：根结点-左⼦树-右⼦树后序序列遍历顺序是：左⼦树-右⼦树-根结点很明显，我们可以看出结点在先、后序列中的排布有以下这些特征：【1】、在先序序列中，根结点在⼦树中的结点前⾯，在后序序列中，根结点在⼦树中的结点后⾯。
【2】、以任⼀节点为根结点时，其⼦树在先序后序序列中排布都是先左⼦树后右⼦树，⽽根结点排在最后。
那么，反过来思考，已知这个先序与后序序列所确定的树是唯⼀的吗？进⼀步推⼴：怎么通过先序与后序序列判断是否存在唯⼀的树呢？现在，我们来⼀步步分析已知先序与后序的建树过程：①、根据特征【1】可知：根结点为先序序列第⼀个节点以及后序序列最后⼀个结点，因此根结点为1。
②、先序序列中第⼆个结点为2，其在后序序列中的位置是第⼀个，那么根据特征【2】我们可以知道结点2是没有⼦树的，⽽且结点2要么在根结点的左⼦树，要么在右⼦树。
假设结点2在右⼦树，那么由特征【2】可知根结点1没有左⼦树，⽽且先序序列中结点2后⾯的结点全部为结点2的⼦树上的结点。
再看后序序列，由特征【2】可知，结点2后⾯的结点不可能是其⼦树上的结点。
因此，假设显然与已知⽭盾。
这样，我们⼜知道结点2是结点1的左孩⼦，且结点2没有⼦结点。
③、先序序列第三个位置上的结点为3，该结点在后序序列中排倒数第⼆个。
由②可知，结点3必然是根结点1的右孩⼦。
④、先序序列第四个位置上的结点为4，该结点在后序序列中排第四个。
因为结点4在先序序列中排在结点3后⾯，⼜因为结点3是根结点1的右孩⼦，所以结点4只可能在结点3的⼦树上。
结点3的⼦树可能出现的情况是：只有左⼦树，只有右⼦树，左右⼦树都有。
因为在后序序列中，结点4左边是结点6、7，右边是结点5。
已知二叉树的先序遍历序列和中序遍历序列,求其后序遍历序列
已知⼆叉树的先序遍历序列和中序遍历序列,求其后序遍历序列2018.1.19 Fri已知⼆叉树的先序遍历序列和中序遍历序列,求其后序遍历序列例：先序遍历：ABDGCEFH中序遍历：DGBAECHF解：⾸先要先知道各种遍历⽅式的规则：先序遍历（先根遍历、前序遍历）：1. 访问根结点2. 遍历左⼦树3. 遍历右⼦树中序遍历（中根遍历）：1. 遍历左⼦树2. 访问根结点3. 遍历右⼦树后序遍历（后根遍历）：1. 遍历左⼦树2. 遍历右⼦树3. 访问根结点且⽆论哪种遍历，左右⼦树仍然遵循该遍历规则。
若没有左⼦结点或右⼦结点（即不是满⼆叉树，如图2）则输出⼀个空代替⼀下就好，然后继续遍历。
例如图⼆中后序遍历为：BOA，即BA。
因为先序遍历是先访问根节点，所以A⼀定是根节点。
因此可以进⾏如下拆分：先序遍历：A BDGCEFH中序遍历：DGB A ECHF⼜因为中序遍历的顺序是：左⼦树，根节点，右⼦树，所以再拆 先序遍历：A BDG CEFH中序遍历：DGB A ECHF然后同理看BDG树先序遍历：B DG中序遍历：DG B得到B是A的左⼦结点。
同理看DG树： 先序遍历：D G中序遍历：D G得到D是B的左⼦结点， G是D的右⼦结点。
（因为如果G是左⼦结点的话中序遍历是GD）。
得到了左⼦树。
右⼦树同理：先序遍历：C E FH 中序遍历：E C HF得到C是A的右⼦结点，E是C的左⼦结点。
先序遍历：F H 中序遍历：H F得到F是C的右⼦结点，H是F的左⼦结点。
得到右⼦树。
得到如图1的⼆叉树。
然后得到后序遍历：GDBEHFCA。
先序 中序 后序
先序中序后序首先，我们看看前序、中序、后序遍历的特性：前序遍历：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;}以上程序是可⾏的已已知先序和中序为例，先通过先序求得根结点，再在中序中定位根结点，得知左右⼦树，进⽽能够在先序中分开左右⼦树。
后序加中序同理。
核⼼步骤我认为是找到根结点后定位的这⼀步，是把整棵树化解开来的基础。
数据结构模拟试题（8）
一．单选题1．数据结构是（）A．一种数据类型B．数据的存储结构C．一组性质相同的数据元素的集合D．相互之间存在一种或多种特定关系的数据元素的集合2．算法分析的目的是（）A．辨别数据结构的合理性B. 评价算法的优劣C．研究算法中输入与输出的关系D．鉴别算法的可读性3．在线性表的下列运算中，不改变数据元素之间结构关系的运算是（）A．插入B．删除C．排序D．定位4．若进栈序列为1，2，3，4，5，6，且进栈和出栈可以穿插进行，则可能出现的出栈序列为（）A．3，2，6，1，4，5 B．3，4，2，1，6，5C．1，2，5，3，4，6 D．5，6，4，2，3，15．设串sl=”Data Structures with C++”,s2=”it”，则子串定位函数index(s1,s2)的值为（）A．15 B．16C．17 D．186．广义表A=(a,(b),(),(c,d,e))的长度为( )A．4 B．5C．6 D．77．一棵含18个结点的二叉树的高度至少为( )A．3 B．4C．5 D．68．.已知二叉树的先序序列为ABDECF，中序序列为DBEAFC，则后序序列为( ) A．DEBAFC B．DEFBCAC．DEBCFA D．DEBFCA9．无向图中一个顶点的度是指图中( )A．通过该顶点的简单路径数B．与该顶点相邻接的顶点数C．通过该顶点的回路数D．与该顶点连通的顶点数10．已知一个图如下所示，从顶点a出发进行广度优先遍历可能得到的序列为( )A．a c e f b d B．a c b d f eC．a c b d e f D．a c d b f e11．在下列排序方法中，平均时间性能为O(nlogn)且空间性能最好的是( )A．快速排序B．堆排序C．归并排序D．基数排序12．已知一组关键字为{25,48,36,72,79,82,23,40,16,35}，其中每相邻两个为有序子序列。
对这些子序列进行一趟两两归并的结果是( )A．{25,36,48,72,23,40,79,82,16,35}B．{25,36,48,72,16,23,40,79,82,35}C．{25,36,48,72,16,23,35,40,79,82}D．{16,23,25,35,36,40,48,72,79,82}13．设顺序存储的线性表共有123个元素，按分块查找的要求等分成3块。
二叉树的先序,中序,后序遍历的递归工作栈的关系
二叉树的先序,中序,后序遍历的递归工作栈的关系在计算机科学中，二叉树是一种非常重要的数据结构，它在很多算法和数据处理中都有着广泛的应用。
而二叉树的先序、中序、后序遍历以及它们与递归和工作栈的关系更是程序员面试中常见的问题。
本文将从深度和广度两个方面，按照先序、中序、后序的顺序逐步展开对这个主题的探讨。
一、先序遍历先序遍历是指先访问根节点，然后递归地先序遍历左子树，最后递归地先序遍历右子树。
在实际的计算机算法中，我们可以使用递归或者栈来实现先序遍历。
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)```在这个递归函数中，同样使用了递归的工作栈来保存中间结果。
数据结构——已知先序中序求后序，已知中序后序求先序
数据结构——已知先序中序求后序，已知中序后序求先序 总结下⼆叉树的已知两种遍历⽅式求第三种遍历顺序的⽅法，已知先序和中序遍历或者后序与中序遍历后⼆叉树是唯⼀确定的，下⾯介绍怎么求出第三种遍历顺序。
先序遍历顺序为：根结点——左⼦结点——右⼦结点，中序遍历为：左⼦结点——根结点——右⼦结点，我们注意到，先序遍历的第⼀个元素就是⼆叉树根结点，我们在中序遍历中以该元素分为左右两部分，则左边为左⼦树，右边为右⼦树，递归即可还原⼆叉树，这个过程中可直接输出后序遍历的顺序。
同理，可以⽤后序与中序还原出先序遍历的顺序。
代码及测试数据如下：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 }。
前序遍历和中序遍历唯一确定一颗二叉树
前序遍历和中序遍历唯⼀确定⼀颗⼆叉树---恢复内容开始---问题描述如果给出了遍历⼆叉树的前序序列和中序序列，则可以构造出唯⼀的⼀颗⼆叉树。
基本要求已知⼀棵⼆叉树的前序序列和中序序列，试设计完成下列任务的⼀个算法：（1）.构造⼀颗⼆叉树（2）.证明构造正确（即分拨⼉以前序和中序遍历该树，将得到的结果与给出的序列进⾏⽐较）（3）.对该⼆叉树进⾏后序遍历，输出后序遍历序列（4）.⽤凹⼊法输出该⼆叉树测试数据前序序列为ABDEGCFHIJ，中序序列为DBGEAHFIJC代码思路1.确定树的根节点,树根是当前树中所有元素在前序遍历中最先出现的元素。
2.求解树的⼦树,找出根节点在中序遍历中的位置，根左边的所有元素就是左⼦树，根右边的所有元素就是右⼦树。
若根节点左边或右边为空，则该⽅向⼦树为空；若根节点左边和右边都为空，则根节点已经为叶⼦节点。
3.递归求解树,将左⼦树和右⼦树分别看成⼀棵⼆叉树，重复1、2、3步，直到所有的节点完成定位。
源代码/*1.确定树的根节点,树根是当前树中所有元素在前序遍历中最先出现的元素。
2.求解树的⼦树,找出根节点在中序遍历中的位置，根左边的所有元素就是左⼦树，根右边的所有元素就是右⼦树。
若根节点左边或右边为空，则该⽅向⼦树为空；若根节点左边和右边都为空，则根节点已经为叶⼦节点。
3.递归求解树,将左⼦树和右⼦树分别看成⼀棵⼆叉树，重复1、2、3步，直到所有的节点完成定位。
*/#include<iostream>#include<algorithm>#include<string>#include<cstring>using namespace std;const int maxint = 10000;char ch1[maxint], ch2[maxint]; //前序序列，中序序列int length; //⼆叉树结点的个数struct tree {char name;struct tree *leftchild;struct tree *rightchild;};//访问函数void vis(char name) {cout << name;}//初始化void init(struct tree **root){*root = (struct tree *)malloc(sizeof(struct tree));(*root)->leftchild = NULL;(*root)->rightchild = NULL;}//创建左⼦树struct tree *build_ltree(struct tree *h,char name) {struct tree *p, *t;if (h == NULL) return NULL;t = h->leftchild;p= (struct tree*)malloc(sizeof(struct tree));p->name = name;p->leftchild = t;p->rightchild = NULL;h->leftchild = p;return h->leftchild;}//创建右⼦树struct tree *build_rtree(struct tree *h, char name) {struct tree *p, *t;if (h == NULL) return NULL;t = h->rightchild;p = (struct tree*)malloc(sizeof(struct tree));p->name = name;p->leftchild = NULL;p->rightchild = t;h->rightchild = p;return h->rightchild;}void print_tree(struct tree *t, int n) {if (t == NULL) return;print_tree(t->rightchild, n + 1);for (int i = 0; i < n - 1; i++) cout << "";if (n > 0) {cout<<"***";cout << t->name << endl;}print_tree(t->leftchild, n + 1);}//前序遍历void preorder(struct tree *t, void vis(char name)) {if (t != NULL) {vis(t->name);preorder(t->leftchild, vis);preorder(t->rightchild, vis);}}//中序遍历void inorder(struct tree *t, void vis(char name)) {if (t != NULL) {inorder(t->leftchild, vis);vis(t->name);inorder(t->rightchild, vis);}}//后序遍历void postorder(struct tree *t, void vis(char name)) {if (t != NULL) {postorder(t->leftchild, vis);postorder(t->rightchild, vis);vis(t->name);}}//寻找对应中序序列中和前序序列相对应的结点的位置int bfs(char ch[],char name) {int i(0);while (ch[i] != name) ++i;return i;}//找到左⼦树的位置int seek_left(int flag[], int t){int temp;temp = t;while (flag[temp] != 1 && temp >= 0)temp--;if (flag[temp] == 1)return temp;else return -1;}//找到右⼦树的位置int seek_right(int flag[], int t){int temp;temp = t;while (flag[temp] != 1 && temp <= 10000)temp++;if (flag[temp] == 1)return temp;else return -1;}int main() {while (1) {cout << " ***************唯⼀确定⼀颗⼆叉树***************" << endl;cout << " * *" << endl;cout << " * 给定前序序列和中序序列唯⼀确定⼀颗⼆叉树 *" << endl; cout << " * *" << endl;cout << " ************************************************" << endl;struct tree *root; //定义根节点init(&root); //创建根节点struct tree *node_tree[maxint]; //⼆叉树中的结点int flag[maxint]; //标记数组int left, right;memset(flag, 0, sizeof flag); //标记数组全部赋值为0cout << "请输⼊前序序列：";cin >> ch1;cout << "请输⼊中序序列：";cin >> ch2;length = strlen(ch1);char node; //前序序列中的结点int num; //中序序列中对应前序序列结点的位置for (int i = 0; i < length; ++i) {node = ch1[i];num = bfs(ch2, node);left = seek_left(flag, num); //找到左⼦树位置right = seek_right(flag, num); //找到右⼦树位置if (left == -1 && right == -1) { //第⼀次的时候肯定会执⾏这个条件后⾯的语句 node_tree[num] = build_ltree(root, node);flag[num] = 1;}else if (left != -1 && node_tree[left]->rightchild == NULL) {node_tree[num] = build_rtree(node_tree[left], node);flag[num] = 1;}else if (right != -1 && node_tree[right]->leftchild == NULL) {node_tree[num] = build_ltree(node_tree[right], node);}}cout << "此⼆叉树的结构是:" << endl << endl;print_tree(root, 0);cout << "此⼆叉树的前序序列为：";preorder(root->leftchild, vis);cout << endl;cout << "此⼆叉树的中序序列为：";inorder(root->leftchild, vis);cout << endl;cout << "此⼆叉树的后序序列为：";postorder(root->leftchild, vis);cout << endl << endl << endl;}return0;}效果图总结断更⼀个⽉后，重新写博。
数据结构考试题库
绪论一、填空题1.数据的逻辑结构被分为集合、(线性结构)、(树形结构)和(图状结构)四种。
2.物理结构是数据结构在计算机中的表示，又称为(存储结构)。
3.数据元素的逻辑结构包括( 线性)、(树)和图状结构3种类型，树形结构和图状结构合称为(非线性结构)。
4.(数据元素)是数据的基本单位，(数据项)是数据不可分割的最小单位。
5.线性结构中元素之间存在(一个对一个)关系，树形结构中元素之间存在(一个对多个)关系，图状结构中元素之间存在(多个对多个)关系。
6.数据结构是一门研究非数值计算的程序设计问题中：计算机的(数据元素)以及它们之间的(关系)和(运筹)等的学科。
7.算法的五个重要特性为有穷性、确定性、(输入)、(输出)和(可行性)。
二、选择题1.数据的不可分割的基本单位是(D)。
A.元素B.结点C.数据类型D.数据项*2.线性表的逻辑顺序与存储顺序总是一致的，这种说法(B)。
A.正确B.不正确C.不确定D.无法选择3.线性结构是指数据元素之间存在一种(D)。
A.一对多关系B.多对多关系C.多对一关系D.一对一关系4.在数据结构中，从逻辑上可以把数据结构分成(A)。
A.动态结构和静态结构B.紧凑结构和非紧凑结构C.线性结构和非线性结构D.内部结构和外部结构5.线性表若采用链式存储结构时，要求内存中可用存储单元的地址( D)。
A.必须是连续的B.部分地址必须是连续的C.一定是不连续的D.连续不连续都可以三、简答题1.算法的特性是什么。
答：有穷性确定性可行性有0或多个输入有1或多个输出线性结构一、填空题1.在一个长度为n的线性表中删除第i个元素（1≤i≤n）时，需向前移动(n-i)个元素。
2.从循环队列中删除一个元素时，其操作是(先移动队首指针，后取出元素)。
3.在线性表的单链接存储中，若一个元素所在结点的地址为p，则其后继结点的地址为(p->next)。
4.在一个单链表中指针p所指向结点的后面插入一个指针q所指向的结点时，首先把(p->next)的值赋给q->next，然后(q->date)的值赋给p->next。